public BaseMvcController()
{
repository = new MovieRepository();
userRepository = new UserRepository();
cookieService = new CookieService();
userProfileService = new UserProfileService();
}
public MovieMessageController(
IMovieRepository movieRepository,
IGenreRepository genreRepository)
{
_movieRepository = movieRepository;
_genreRepository = genreRepository;
}
public GroupedMoviesViewModel(
IMessenger messenger,
IMovieRepository movieRepository)
{
MovieRepository = movieRepository;
if (MovieRepository != null)
{
MovieGroups = MovieRepository.LoadMovies()
.GroupBy(m => m.Genre)
.Select(g => new MovieGroupViewModel(messenger)
{
Title = g.Key.ToString(),
Movies = g.ToList(),
GroupImageUrl = g.First().ImageUrl
});
}
MovieTappedCommand = new RelayCommand<Movie>((movie) =>
{
var movieGroup = MovieGroups.First(mg => mg.Movies.Contains(movie));
messenger.Send<MovieSelectedMessage>(new MovieSelectedMessage { Movie = movie, MovieGroup = movieGroup });
});
MovieSelectedCommand = new RelayCommand(() =>
{
var movieGroup = MovieGroups.First(mg => mg.Movies.Contains(SelectedMovie));
messenger.Send<MovieSelectedMessage>(new MovieSelectedMessage { Movie = SelectedMovie, MovieGroup = movieGroup });
});
}
public MovieGroupDetailViewModel(
IMovieRepository movieRepository,
IMessenger messenger)
{
MovieRepository = movieRepository;
Messenger = messenger;
}
public HomeController(
IMovieRepository movieRepository,
IGenreRepository genreRepository)
{
_movieRepository = movieRepository;
_genreRepository = genreRepository;
}
public MovieListPageViewModel(MovieListPage view, IMovieRepository repository)
{
this.view = view;
this.repository = repository;
RetrieveData();
}
public MovieController()
{
this._MovieRepository = new MovieRepository(
new WSMMovieApi(Configuration.WSMMovieApiSid, Configuration.WSMMovieApiKey),
new TMDbMovieDb(Configuration.TheMovieDbApiKey)
);
}
public MovieService(IMovieRepository movieRepository, ITheaterRepository theaterRepository,
IGenreRepository genreRepository, ITimeIntervalRepository timeIntervalRepository)
{
_movieRepository = movieRepository;
_theaterRepository = theaterRepository;
_genreRepository = genreRepository;
_timeIntervalRepository = timeIntervalRepository;
}
/// <summary>
/// Initializes a new instance of the <see cref="ProductRepositoryLocator" /> class.
/// </summary>
/// <param name="bookRepository">The book repository.</param>
/// <param name="movieRepository">The movie repository.</param>
public ProductRepositoryLocator(IBookRepository bookRepository, IMovieRepository movieRepository)
{
Guard.ArgumentNotNull(bookRepository, "bookRepository");
Guard.ArgumentNotNull(movieRepository, "movieRepository");
this.bookRepository = bookRepository;
this.movieRepository = movieRepository;
}
public void SetLastMovieRanks(IMovieRepository movieRep)
{
LastMovieRanks = new Dictionary<int, int>();
foreach (var movie in Movies)
{
int lastLog = movieRep.GetPreviousMovieRank(movie.ID);
LastMovieRanks.Add(movie.ID, lastLog);
}
}
public MovieDataAccess()
{
#region MovieDataAccess
this._unitOfWork = UnitOfWorkFactory.CreateUnitOfWork<Movie>();
this._repository = RepositoryFactory.CreateRepository<IMovieRepository, MovieRepository>(this._unitOfWork);
#endregion
}
public ReviewController(
IMovieRepository movieRepository,
IReviewRepository reviewRepository,
ICurrentUser currentUser,
IReviewerGenreRepository reviewerGenreRepository)
{
_movieRepository = movieRepository;
_reviewRepository = reviewRepository;
_currentUser = currentUser;
_reviewerGenreRepository = reviewerGenreRepository;
}
public CatalogPageViewModel(CatalogPage view, IMovieRepository repository)
{
this.repository = repository;
this.view = view;
Genres = new ObservableCollection<Genre>();
Movies = new ObservableCollection<Movie>();
allMovies = new List<Movie>();
RetrieveData();
}
/// <summary>
/// The default constructor.
/// </summary>
/// <param name="userMovieRepository">A container for user-movie information.</param>
/// <param name="movieRepository">A container for movie information.</param>
/// <param name="configurationProvider">The application configuration.</param>
public MovieController(IUserMovieRepository userMovieRepository, IMovieRepository movieRepository,
IConfigurationProvider configurationProvider)
{
if (userMovieRepository == null)
throw new ArgumentNullException("userMovieRepository");
if (movieRepository == null)
throw new ArgumentNullException("movieRepository");
if (configurationProvider == null)
throw new ArgumentNullException("configurationProvider");
if (configurationProvider.EncodedMovieLocation == null)
throw new ArgumentNullException("configurationProvider.EncodedMovieLocation");
_userMovieRepository = userMovieRepository;
_movieRepository = movieRepository;
_baseMovieLocation = configurationProvider.PublicMovieLocation;
}
public MovieService(IMovieRepository mRepo)
{
_mRepo = mRepo;
//byte[] temp;
//foreach (var o in _mRepo.GetAll().ToList())
//{
// WebClient WebClient = new WebClient();
// if (o.Poster != null)
// {
// temp = WebClient.DownloadData(o.Poster);
// o.PosterBytes = temp;
// mRepo.Update(o);
// }
//}
}
static object GetMovieReviewData(int id, IMovieRepository movieRepository = null)
{
if (movieRepository == null)
{
movieRepository = System.Web.Mvc.DependencyResolver.Current.GetService<IMovieRepository>();
}
var q =
from x in movieRepository.All
where x.ID == id
select x.Reviews;
var reviews = q.FirstOrDefault();
if (reviews.Count == 0)
{
return new { NumberOfReviews = 0 };
}
else
{
var avg = reviews.Average(x => x.Stars);
var latestReview = reviews.OrderByDescending(x => x.ReviewDate).FirstOrDefault();
var dt = latestReview.ReviewDate.Ticks;
return new { MovieID = id, NumberOfReviews = reviews.Count, AverageStars = avg, LastReviewDate = dt };
}
}
public MoviesController(UserManager <AppUser> userManager, ApplicationDbContext context, IMovieRepository movieRepository, IActorRepository actorRepository)
{
_context = context;
_movieRepository = movieRepository;
_actorRepository = actorRepository;
_userManager = userManager;
}
public MoviesController(IGenreRepository genreRepository, IMovieRepository movieRepository)
{
_genreRepository = genreRepository;
_movieRepository = movieRepository;
}
public MovieController(IMovieRepository _movieRepository)
{
movieRepository = _movieRepository;
}
public UpdateCleanTitleForMovies(IMovieRepository movieRepository)
{
_movieRepository = movieRepository;
}
private readonly IMovieRepository _movieRepository; //Dependency Injection by constructor injection; why readonly: only change in declaration(inside constructor)
public MovieService(IMovieRepository movieRepository) // Constructor with an Interface as parameter: pass a class that implement this Interface
{
_movieRepository = movieRepository;
}
public UserController()
{
_movieRepository = new MovieRepository();
_badgeRepository = new BadgeRepository();
_seenRepository = new SeenRepository();
}
public MoviesController(IMovieRepository movieRepository, PageSize pageSize)
{
_moviesRepository = movieRepository;
_pageSize = pageSize;
}
public MovieSiteController(IMovieRepository movieRepository)
{
_movieRepository = movieRepository;
}
public CreateMovieHandler(IMovieRepository movieRepository)
{
_movieRepository = movieRepository;
}
public MovieService(
IMovieRepository movieRepository,
INotifier notifier) : base(notifier)
{
_movieRepository = movieRepository;
}
public ManageMoviesService(IMovieRepository movieRepository, IMapper mapper)
{
_movieRepository = movieRepository;
_mapper = mapper;
}
public MovieController(IMovieRepository repository)
{
context = repository;
}
public MoviesController(apiDbContext _db, IMovieRepository _movieRepo, IMapper _mapper)
{
db = _db;
movieRepo = _movieRepo;
mapper = _mapper;
}
protected override void WhenIRun()
{
this._repository = this.Sut.Resolve<IMovieRepository>();
}
public MovieService(IMovieRepository movieRepository, IActorRepository actorRepository)
{
_movieRepository = movieRepository;
_actorRepository = actorRepository;
}
public Controller(IMovieRepository repository)
{
_repository = repository;
}
public DataScraper(TMDbApi api, IMovieRepository movieRepository)
{
_api = api;
_movieRepository = movieRepository;
}
public MovieService(IMovieRepository movieRepository, IValidator <MovieRequest> movieRequestValidator, IValidator <AddMovieRating> addMovieRatingValidator)
{
_movieRepository = movieRepository;
_movieRequestValidator = movieRequestValidator;
_addMovieRatingValidator = addMovieRatingValidator;
}
public MoviesController(IMovieRepository movieRepository, IPersonRepository personRepository)
{
_movieRepository = movieRepository;
_personRepository = personRepository;
}
public MovieManagerService(IMapper mapper, IMovieRepository movieRepository)
{
_mapper = mapper;
_movieRepository = movieRepository;
}
public Movie GetById([FromServices] IMovieRepository repository, int id)
{
return(repository.GetById(id));
}
// GET: api/Genre
public GenreController(IMovieRepository movieRepository, IGenreRepository genreRepository)
{
_movieRepository = movieRepository;
_genreRepository = genreRepository;
}
public MovieService(IUnitOfWork unitOfWork, IMovieRepository movieRepository,
IOrderNumberSettingService orderNumberSettingService)
: base(movieRepository, unitOfWork)
{
_orderNumberSettingService = orderNumberSettingService;
}
public MovieService(IMovieRepository movieRepository)
{
_movieRepository = movieRepository;
}
public MovieService(IMovieRepository movieRepo)
{
_movieRepo = movieRepo;
}
public void InitializeTest()
{
_mockServieSettings = CreateSettings();
_mockMapper = new Mock <IMapper>();
_movieRepository = new MoviesMongoRepository(_mockServieSettings, _mockMapper.Object);
}
public MoviesController(IMovieRepository repo)
{
this.repo = repo;
}
public MovieListItemsController(IMovieRepository movieRepository)
{
this.movieRepository = movieRepository;
}
public MoviesController(IMovieRepository repository)
{
this._repository = repository;
}
public HomeController(ILogger <HomeController> logger, IMovieRepository movieRepository)
{
_logger = logger;
this.movieRepository = movieRepository;
}
public IEnumerable <Movie> GetMoviesWithoutGenre([FromServices] IMovieRepository repository)
{
return(repository.GetMoviesWithoutGenre());
}
public MovieService(IMovieRepository movieRepository) : base(movieRepository)
{
}
public MovieService(ModelStateDictionary modelState, IMovieRepository repository)
{
_modelState = modelState;
_repository = repository;
}
public IndexModel(IMovieRepository movieRepository)
{
this.movieRepository = movieRepository;
}
public DataScraper(string apiKey, IMovieRepository movieRepository)
{
_api = new TMDbApi(apiKey);
_movieRepository = movieRepository;
}
public IEnumerable <Movie> GetAll([FromServices] IMovieRepository repository)
{
return(repository.GetAll());
}
public MovieService(IMovieRepository movieRepository, IGenreRepository genreRepository, IUnitOfWork uow)
{
_movieRepository = movieRepository;
_genreRepository = genreRepository;
_uow = uow;
}
public MovieService(IMovieRepository movieRepository, IQueueClient queueClient)
{
this.movieRepository = movieRepository;
this.queueClient = queueClient;
}
public UserController(IMovieRepository movieRepository, ISeenRepository seenRepository, IBadgeRepository badgeRepository)
{
_movieRepository = movieRepository;
_seenRepository = seenRepository;
_badgeRepository = badgeRepository;
}
public MovieService(IMapper mapper, IMovieRepository movieRepository) : base(mapper)
{
base.InitializeBase(movieRepository);
}
public HomeController(IMovieRepository repository)
{
this.repository = repository;
}
public EloRatingService(IMovieRepository movieRepository)
{
_movieRepository = movieRepository;
}
public MoviesController(IMovieRepository movieRepository, IMapper mapper, IActionDescriptorCollectionProvider actionDescriptorCollectionProvider) : base(actionDescriptorCollectionProvider)
{
_movieRepository = movieRepository;
_mapper = mapper;
}
/// <summary></summary>
/// <param name="movieRepository"></param>
public HomeController(IMovieRepository movieRepository)
{
_movieRepository = movieRepository;
}
