public HomeController(UserManager <ApplicationUser> _userManager, IMoviesRepository _moviesRepository, ICategoryRepository category, IBiletHoleRepository _biletHoleRepository)
 {
     userManager         = _userManager;
     moviesRepository    = _moviesRepository;
     categoryRepository  = category;
     biletHoleRepository = _biletHoleRepository;
 }
Exemple #2
0
 public MoviesService(IMoviesRepository moviesRepository, ICategoriesRepository categoriesRepository,
                      IActorsRepository actorsRepository)
 {
     this.moviesRepository     = moviesRepository;
     this.categoriesRepository = categoriesRepository;
     this.actorsRepository     = actorsRepository;
 }
 public MoviesService(
     IFilesService filesService,
     IMoviesRepository moviesRepository)
 {
     _filesService     = filesService;
     _moviesRepository = moviesRepository;
 }
Exemple #4
0
 public HomeController(ILogger <HomeController> logger, IMoviesRepository repository, MoviesContext context)
 {
     //settting the private objects, settings, db stuff
     _logger     = logger;
     _repository = repository;
     _context    = context;
 }
 public RecordingsController(ILogger <TvItemsController> logger, IMoviesRepository repository, IMapper mapper, LinkGenerator linkGenerator)
 {
     this.logger        = logger;
     this.repository    = repository;
     this.mapper        = mapper;
     this.linkGenerator = linkGenerator;
 }
Exemple #6
0
 public BillboardCalculatorShould()
 {
     _repository = Substitute.For <IMoviesRepository>();
     _utc        = Substitute.For <IUtc>();
     _utc.Now().Returns(new DateTime(2020, 02, 09));
     _weekDates = new WeekDates(_utc);
 }
Exemple #7
0
 public MoviesService(IMoviesRepository moviesRepository, ISaveRepository unitOfWork, IMemoryCache cache, ILogger <MoviesService> logger)
 {
     this._moviesRepository = moviesRepository;
     this._unitOfWork       = unitOfWork;
     this._cache            = cache;
     this._logger           = logger;
 }
Exemple #8
0
 public HomeController(ILogger <HomeController> logger, MoviesContext con, IMoviesRepository respository)
 {
     //connecting the DB to the app
     _logger     = logger;
     _repository = respository;
     _context    = con;
 }
Exemple #9
0
 public FavoriteService(IFavoriteRepository favoriteRepository, ISerialRepository _serialRepository, IMoviesRepository _movieRepository, IMapper mapper)
 {
     this.favoriteRepository = favoriteRepository;
     this._serialRepository  = _serialRepository;
     this._movieRepository   = _movieRepository;
     this.mapper             = mapper;
 }
Exemple #10
0
        public async void Configure(
            IApplicationBuilder app,
            ISqsClient sqsClient,
            ISqsConsumerService sqsConsumerService,
            IActorsRepository actorsRepository,
            IMoviesRepository moviesRepository)
        {
            app.UseSerilogRequestLogging();
            app.UseRouting();
            app.UseEndpoints(endpoints =>
            {
                endpoints.MapControllers();
                endpoints.MapCustomHealthChecks("SqsReader service");
            });

            if (_appConfig.AwsQueueAutomaticallyCreate)
            {
                await sqsClient.CreateQueueAsync();
            }

            sqsConsumerService.StartConsuming();
            await actorsRepository.CreateTableAsync();

            await moviesRepository.CreateTableAsync();
        }
Exemple #11
0
        public BillboardCalculator(IMoviesRepository repository, IWeekDates weekDates, int weeksFromNow, int bigRoomsScreens, int smallRoomsScreens, bool basedOnCityMovies)
        {
            _repository        = repository;
            _weekDates         = weekDates;
            _weeksFromNow      = weeksFromNow;
            _bigRoomsScreens   = bigRoomsScreens;
            _smallRoomsScreens = smallRoomsScreens;
            _basedOnCityMovies = basedOnCityMovies;

            if (!IsValidWeeksFromNow())
            {
                throw new ArgumentException($"Weeks must be between {MIN_WEEKS_FROM_NOW} and {MAX_WEEKS_FROM_NOW}");
            }
            if (!IsValidBigRoomsScreensNumber())
            {
                throw new ArgumentException($"Number of big rooms must be between {MIN_SCREENS} and {MAX_SCREENS}");
            }
            if (!IsValidSmallRoomsScreensNumber())
            {
                throw new ArgumentException($"Number of small rooms must be between {MIN_SCREENS} and {MAX_SCREENS}");
            }
            if (!IsValidTotalRoomsScreensNumber())
            {
                throw new ArgumentException($"Total number of rooms must be greater than {MIN_SCREENS}");
            }
        }
Exemple #12
0
 public TheatreManagerService(
     IMoviesRepository moviesRepository,
     IWeekBoardService weekBoardService)
 {
     _moviesRepository = moviesRepository;
     _weekBoardService = weekBoardService;
 }
Exemple #13
0
 public MoviesDomain(IMoviesRepository moviesRepository, IRatingRepository ratingRepository)
 {
     _moviesRepository = moviesRepository;
     //I had some circular references with movies and rating domains.
     //Ideally a domain should only talk directly with its own repository, shouldn't be talking to other repositories
     _ratingRepository = ratingRepository;
 }
 public MoviesController(IMoviesRepository moviesRepository, IMapper mapper, ILogger <MoviesController> logger, MoviesDBcontext context)
 {
     this.moviesRepository = moviesRepository;
     this.mapper           = mapper ?? throw new ArgumentNullException(nameof(mapper));
     this.logger           = logger;
     this._context         = context;
 }
Exemple #15
0
 public AdministratorController(ILogger <AdministratorController> logger, IMoviesRepository moviesRepository, IUserRepository userRepository, IProjectionsRespository projectionsRepository, CineMagicDbContext dbContext)
 {
     _logger = logger;
     this._moviesRepository      = moviesRepository;
     this._projectionsRepository = projectionsRepository;
     this._userRepository        = userRepository;
     _dbContext = dbContext;
 }
Exemple #16
0
 public ManagersControllerShould()
 {
     _repository = Substitute.For <IMoviesRepository>();
     _utc        = Substitute.For <IUtc>();
     _utc.Now().Returns(new DateTime(2020, 02, 09));
     _weekDates = new WeekDates(_utc);
     _logger    = Substitute.For <ILogger <ManagersController> >();
 }
 public MoviesService(IMoviesRepository moviesRepository, IUserRepository userRepository, ICommentsRepository commentsRepository, IMovieGenresService movieGenresService, ILogService logService)
 {
     _moviesRepository   = moviesRepository;
     _userRepository     = userRepository;
     _commentsRepository = commentsRepository;
     _movieGenresService = movieGenresService;
     _logService         = logService;
 }
Exemple #18
0
 public MovieService(IMoviesRepository moviesRepository, IProjectionsRepository projectionsRepository, IMovieTagsRepository movieTagsRepository, ITicketRepository ticketRepository, ITagRepository tagRepository)
 {
     _moviesRepository      = moviesRepository;
     _projectionsRepository = projectionsRepository;
     _movieTagsRepository   = movieTagsRepository;
     _ticketRepository      = ticketRepository;
     _tagRepository         = tagRepository;
 }
Exemple #19
0
 public EmailRepository(IMoviesRepository movieRepository,
                        IHttpContextAccessor contextAccessor,
                        IConfiguration configuration)
 {
     _movieRepository = movieRepository;
     _httpContext     = contextAccessor.HttpContext;
     _emailEndpoint   = configuration.GetSection("EmailEndpoint").Value;
 }
Exemple #20
0
        public HomeController(ILogger <HomeController> logger, IMoviesRepository repository, MoviesDbContext con)
        {
            _logger = logger;

            //receive database data
            _repository = repository;
            _context    = con;
        }
Exemple #21
0
        public MoviesController(IMoviesRepository moviesRepository, IMapper mapper)
        {
            _moviesRepository = moviesRepository ??
                                throw new ArgumentNullException(nameof(moviesRepository));

            _mapper = mapper ??
                      throw new ArgumentNullException(nameof(mapper));
        }
 public SearchService(ICitiesRepository cityRepository, IMoviesRepository movieRepository, ICinemaRepository cinemaRepository, IShowsRepository showsRepository, IMapper mapper)
 {
     _cityRepository   = cityRepository;
     _movieRepository  = movieRepository;
     _cinemaRepository = cinemaRepository;
     _showsRepository  = showsRepository;
     _mapper           = mapper;
 }
Exemple #23
0
 public ReservationsController(IMoviesRepository moviesRepository, IProjectionsRespository projectionsRepository, IAvailableSeatsRepository availableSeatsRepository, IReservationsRepository reservationsRepository, IHttpContextAccessor httpContextAccessor, IUserRepository userRepository)
 {
     this._moviesRepository         = moviesRepository;
     this._projectionsRepository    = projectionsRepository;
     this._availableSeatsRepository = availableSeatsRepository;
     this._reservationsRepository   = reservationsRepository;
     this._httpContextAccessor      = httpContextAccessor;
     this._userRepository           = userRepository;
 }
Exemple #24
0
 public MoviesService(
     ILogProvider logProvider,
     ICacheProvider cacheProvider, 
     IMoviesRepository moviesRepository)
 {
     _cacheProvider = cacheProvider;
     _logProvider = logProvider;
     _moviesRepository = moviesRepository;
 }
Exemple #25
0
 public MoviesController(ApplicationDbContext context,
                         IMoviesRepository moviesRepository,
                         IFileStorageService fileStorageService, IMapper mapper, UserManager <IdentityUser> userManager)
 {
     _context            = context;
     _moviesRepository   = moviesRepository;
     _fileStorageService = fileStorageService;
     _mapper             = mapper;
     _userManager        = userManager;
 }
Exemple #26
0
 public SearchService(ICitiesRepository cityRepository, IMoviesRepository movieRepository, ICinemaRepository cinemaRepository, IShowsRepository showsRepository, ICinemaSeatingRepository cinemaSeatingRepository, ITicketsRepository ticketsRepository, IReservationsRepository reservationsRepository, IMapper mapper)
 {
     _cityRepository          = cityRepository;
     _movieRepository         = movieRepository;
     _cinemaRepository        = cinemaRepository;
     _showsRepository         = showsRepository;
     _cinemaSeatingRepository = cinemaSeatingRepository;
     _ticketsRepository       = ticketsRepository;
     _reservationsRepository  = reservationsRepository;
     _mapper = mapper;
 }
Exemple #27
0
 public UsersController(IUsersRepository usersRepository, IMoviesRepository movieRepository,
                        IRatingsRepository ratingsRepository, ITransactionRepository transactionRepository)
 {
     _usersRepository = usersRepository
                        ?? throw new ArgumentNullException(nameof(usersRepository));
     _moviesRepository = movieRepository
                         ?? throw new ArgumentNullException(nameof(movieRepository));
     _ratingsRepository = ratingsRepository
                          ?? throw new ArgumentNullException(nameof(ratingsRepository));
     _transactionRepository = transactionRepository
                              ?? throw new ArgumentNullException(nameof(transactionRepository));
 }
Exemple #28
0
        public MovieService(IMoviesRepository moviesRepository, IDisplayService displayService, IImagesRepository imagesRepository)
        {
            var config = new MapperConfiguration(cfg =>
                                                 cfg.CreateMap <Movie, MovieDTO>()
                                                 .ForMember(dest => dest.Image, opt => opt.MapFrom(src => src.Image.Image))
                                                 );

            _moviesRepository = moviesRepository;
            _displayService   = displayService;
            _imagesRepository = imagesRepository;

            _mapper = new Mapper(config);
        }
Exemple #29
0
        public CustomersService(
            ICustomersRepository customersRepository,
            IMoviesRepository moviesRepository,
            IMovieAcquisitionService movieAcquisitionService,
            IDomainCustomersService domainCustomersService,
            IMapper mapper)
        {
            this.customersRepository     = customersRepository;
            this.moviesRepository        = moviesRepository;
            this.movieAcquisitionService = movieAcquisitionService;
            this.domainCustomersService  = domainCustomersService;

            this.mapper = mapper;
        }
 public DatabaseBuilder(IActorsRepository actorsRepository, IContentPathsRepository contentPathsRepository, 
     IDirectorsRepository directorsRepository, IEpisodesRepository episodesRepository, 
     IGenresRepository genresRepository, ISeasonsRepository seasonsRepository, ISeriesRepository seriesRepository, 
     ISubtitlesRepository subtitlesRepository, IWritersRepository writersRepository, 
     IMoviesRepository moviesRepository, OmdbApiHandler omdbApiHandler)
 {
     _actorsRepository = actorsRepository;
     _contentPathsRepository = contentPathsRepository;
     _directorsRepository = directorsRepository;
     _episodesRepository = episodesRepository;
     _genresRepository = genresRepository;
     _seasonsRepository = seasonsRepository;
     _seriesRepository = seriesRepository;
     _subtitlesRepository = subtitlesRepository;
     _writersRepository = writersRepository;
     _moviesRepository = moviesRepository;
     _omdbApiHandler = omdbApiHandler;
 }
        public void Should_Resolve_IMoviesRepository()
        {
            // Arrange
            var env = new Microsoft.AspNetCore.Hosting.Internal.HostingEnvironment();

            env.ContentRootPath = Path.Combine(_ContentRoot);

            Startup startup           = new Startup(env);
            var     serviceCollection = new ServiceCollection();

            startup.ConfigureServices(serviceCollection);

            // Act
            IMoviesRepository moviesRepository = (IMoviesRepository)serviceCollection.BuildServiceProvider().GetService(typeof(IMoviesRepository));

            // Assert
            Assert.NotNull(moviesRepository);
        }
 public DatabaseBuilder(IActorsRepository actorsRepository, IContentPathsRepository contentPathsRepository,
                        IDirectorsRepository directorsRepository, IEpisodesRepository episodesRepository,
                        IGenresRepository genresRepository, ISeasonsRepository seasonsRepository, ISeriesRepository seriesRepository,
                        ISubtitlesRepository subtitlesRepository, IWritersRepository writersRepository,
                        IMoviesRepository moviesRepository, OmdbApiHandler omdbApiHandler)
 {
     _actorsRepository       = actorsRepository;
     _contentPathsRepository = contentPathsRepository;
     _directorsRepository    = directorsRepository;
     _episodesRepository     = episodesRepository;
     _genresRepository       = genresRepository;
     _seasonsRepository      = seasonsRepository;
     _seriesRepository       = seriesRepository;
     _subtitlesRepository    = subtitlesRepository;
     _writersRepository      = writersRepository;
     _moviesRepository       = moviesRepository;
     _omdbApiHandler         = omdbApiHandler;
 }
        public OmdbApiHandler(IActorsRepository actorsRepository, IContentPathsRepository contentPathsRepository,
            IDirectorsRepository directorsRepository, IEpisodesRepository episodesRepository,
            IGenresRepository genresRepository, ISeasonsRepository seasonsRepository, ISeriesRepository seriesRepository,
            ISubtitlesRepository subtitlesRepository, IWritersRepository writersRepository, IMoviesRepository moviesRepository)
        {
            _actorsRepository = actorsRepository;
            _contentPathsRepository = contentPathsRepository;
            _directorsRepository = directorsRepository;
            _episodesRepository = episodesRepository;
            _genresRepository = genresRepository;
            _moviesRepository = moviesRepository;
            _seasonsRepository = seasonsRepository;
            _seriesRepository = seriesRepository;
            _subtitlesRepository = subtitlesRepository;
            _writersRepository = writersRepository;

            var image = new Bitmap(Properties.Resources.default_avatar);
            _defaultAvatar = new MemoryStream();
            image.Save(_defaultAvatar, System.Drawing.Imaging.ImageFormat.Png);
        }
 public ConsoleBasedServerHandler(DatabaseBuilder databaseBuilder, IActorsRepository actorsRepository, 
     IContentPathsRepository contentPathsRepository, IDirectorsRepository directorsRepository, 
     IEpisodesRepository episodesRepository, IGenresRepository genresRepository, 
     ISeasonsRepository seasonsRepository, ISeriesRepository seriesRepository, 
     ISubtitlesRepository subtitlesRepository, IWritersRepository writersRepository, 
     IMoviesRepository moviesRepository, FtpServer ftpServer)
 {
     _actorsRepository = actorsRepository;
     _contentPathsRepository = contentPathsRepository;
     _directorsRepository = directorsRepository;
     _episodesRepository = episodesRepository;
     _genresRepository = genresRepository;
     _moviesRepository = moviesRepository;
     _seasonsRepository = seasonsRepository;
     _seriesRepository = seriesRepository;
     _subtitlesRepository = subtitlesRepository;
     _writersRepository = writersRepository;
     _ftpServer = ftpServer;
     _databaseBuilder = databaseBuilder;
     CommandsDictionary = new Dictionary<string, Tuple<Action, string>>
     {
         {"help", new Tuple<Action, string>(PrintCommands, "Displays a list of all commands available.")},
         {"exit", new Tuple<Action, string>(ExitServer, "Safely shuts down the server and exits the command console.")},
         {"enableAutoStart", new Tuple<Action, string>(SetAutoStartOnLogin, "The server will start automatically when the user logs in.")},
         {"disableAutoStart", new Tuple<Action, string>(DisableAutoStartOnLogin, "The server will no longer start automatically when the user logs in.")},
         {"initServer", new Tuple<Action, string>(InitializaServer, "Manually start the server.")},
         {"shutDownServer", new Tuple<Action, string>(ShutDownServer, "Manually stop the server.")},
         {"restartServer", new Tuple<Action, string>(RestartServer, "Manually restart the server.")},
         {"status", new Tuple<Action, string>(DisplayServerStatus, "Displays the server's status.")},
         {"addToMoviesDirectories", new Tuple<Action, string>(AddToMoviesDirectories, "Adds specified directory to the movies directory list.")},
         {"removeFromMoviesDirectories", new Tuple<Action, string>(RemoveFromMoviesDirectories, "Removes specified directory from the movies directory list.")},
         {"listMoviesDirectories", new Tuple<Action, string>(ListMoviesDirectories, "Lists all known movies directories.")},
         {"addAllOrNewMovies", new Tuple<Action, string>(AddAllOrNewMovies, "Scans all movies directories to find and add all or any missing movies to the database.")},
         {"testImage", new Tuple<Action, string>(TestImage, "Copies the selected movie's poster to the current user's desktop.")}
     };
 }
 public RepositoryMoviesService(IMoviesRepository moviesRepository)
 {
     this._moviesRepository = moviesRepository;
 }
 public MoviesBusinessWorkflow(IMoviesRepository moviesRepository, IMovieMapper movieMapper)
 {
     MoviesRepository = moviesRepository;
     MovieMapper = movieMapper;
 }
 public MoviesController(IMoviesRepository moviesRepository)
 {
     this._moviesRepository = moviesRepository;
 }
 public RepositoryMoviesService(IMoviesRepository moviesRepository, ICommentsRepository commentsRepository)
 {
     _moviesRepository = moviesRepository;
     _commentsRepository = commentsRepository;
 }
 public AdminController(ICategoriesRepository categoriesRepository,
                        IMoviesRepository moviesRepository)
 {
     _categoriesRepository = categoriesRepository;
     _moviesRepository = moviesRepository;
 }
 public MoviesController(IMoviesRepository moviesRepository,
                         ICategoriesRepository categoriesRepository)
 {
     _moviesRepository = moviesRepository;
     _categoriesRepository = categoriesRepository;
 }
 public ShoppingCartController(IShoppingCartService shoppingCartService,
                               IMoviesRepository moviesRepository)
 {
     _shoppingCartService = shoppingCartService;
     _moviesRepository = moviesRepository;
 }
        public void SetUp()
        {
            _moviesRepository = new FakeMoviesRepository();
            _shoppingCartRepository = new FakeShoppingCartRepository();
            _cartItemRepository = new FakeCartItemRepository();
            _orderItemRepository = new FakeOrderItemRepository();
            _orderRepository = new FakeOrderRepository();
            _userRepository = new FakeUserRepository();

            _authenticationService = new FakeAuthenticationService();
            _authenticationService.Authenticated = false;

            _shoppingCartService = new ShoppingCartService(_userRepository,
                                                           _shoppingCartRepository,
                                                           _cartItemRepository,
                                                           _orderRepository,
                                                           _orderItemRepository,
                                                           _authenticationService);
        }
 public MoviesController(IMoviesRepository repository)
 {
     _repository = repository;
 }
Exemple #44
0
 public MoviesTasks(IMoviesRepository moviesRepository)
 {
     this.moviesRepository = moviesRepository;
 }
 /// <summary>
 /// Constructor.
 /// </summary>
 public MoviesService()
 {
     movieRepository = new MoviesRepository();
 }
 public void SetUp()
 {
     _moviesRepository = new FakeMoviesRepository();
     _categoriesRepository = new FakeCategoriesRepository();
     _moviesController = new MoviesController(_moviesRepository, _categoriesRepository);
 }