public UserServices(IDbGenericRepository<User, string> userRepos, IDbRepository<UserComment> userCommentRepos)
 {
     this.userRepos = userRepos;
     this.dbContext = new TripDestinationDbContext();
     this.userManager = new UserManager<User>(new UserStore<User>(this.dbContext));
     this.userCommentRepos = userCommentRepos;
 }

 public SatisticsService(IDbRepository<Tutorial> tutorials, IDbRepository<Review> reviews, IDbRepository<Comment> comments, IDbRepository<Like> likes)
 {
     this.tutorials = tutorials;
     this.reviews = reviews;
     this.comments = comments;
     this.likes = likes;
 }

 public TvShowsService(IDbRepository<TvShow> shows, IDbRepository<Actor> actors, IDbRepository<Tag> tags, IDbRepository<TvShowChannel> channels)
 {
     this.shows = shows;
     this.actors = actors;
     this.tags = tags;
     this.channels = channels;
 }

 public PublicItemController(
     IDbRepository<Item> items,
     IDbRepository<Image> images)
 {
     this.dataItem = items;
     this.dataImage = images;
 }

 public JoinOrganizationService(
     IDbRepository<JoinOrganizationRequest> joinOrganizationRequests,
     IDbRepository<User> users)
 {
     this.joinOrganizationRequests = joinOrganizationRequests;
     this.users = users;
 }

 public JokesService(
     IDbRepository<Joke> jokes,
     IIdentifierProvider identifierProvider)
 {
     this.jokes = jokes;
     this.identifierProvider = identifierProvider;
 }

        public int GenerateBattles(IDbRepository<Team> teamsRepository, IDbRepository<Battle> battlesRepository, int competitionId)
        {
            var teams = teamsRepository.All().Where(x => x.CompetitionId == competitionId).Select(x => new { x.Id }).ToList();
            var newBattles = 0;
            for (var i = 0; i < teams.Count; i++)
            {
                for (int j = i + 1; j < teams.Count; j++)
                {
                    var firstTeam = teams[i];
                    var secondTeam = teams[j];
                    if (battlesRepository.All().Any(
                        x =>
                        (x.FirstTeamId == firstTeam.Id && x.SecondTeamId == secondTeam.Id)
                        || (x.FirstTeamId == secondTeam.Id && x.FirstTeamId == firstTeam.Id)))
                    {
                        // Battle already exists
                        continue;
                    }

                    newBattles++;
                    battlesRepository.Add(new Battle { FirstTeamId = firstTeam.Id, SecondTeamId = secondTeam.Id });
                }
            }

            battlesRepository.Save();
            return newBattles;
        }

 public StoryService(
     IDbRepository<Story> storyRepository,
     IDbRepository<Genre> genreRepository)
 {
     this.storyRepository = storyRepository;
     this.genreRepository = genreRepository;
 }

        public ProductsController(IDbRepository<Product> products, IDbRepository<Category> categories)
        {
            this.products = products;
            this.categories = categories;

            ViewData["ActiveMenuName"] = "Products";
        }

 public TripServices(IDbRepository<Trip> tripRepos, IDbRepository<PassengerTrip> passengerTripsRepos, IUserServices userServices, INotificationServices notificationServices)
 {
     this.tripRepos = tripRepos;
     this.passengerTripsRepos = passengerTripsRepos;
     this.userServices = userServices;
     this.notificationServices = notificationServices;
 }

 public MoviesService(IDbRepository<Movie> movies, IDbRepository<Actor> actors, IDbRepository<Tag> tags, IDbRepository<Director> directors, IDbRepository<MovieStudio> studios)
 {
     this.movies = movies;
     this.actors = actors;
     this.directors = directors;
     this.tags = tags;
     this.studios = studios;
 }

 public AuctionController(IDbRepository<Auction> auctions,
     IDbRepository<Item> items,
     IAuctionService auctionService)
 {
     this.dataAuction = auctions;
     this.dataItem = items;
     this.auctionService = auctionService;
 }

 public OrganizationsService(
     IDbRepository<Organization> organizations,
     IDbRepository<User> users,
     IOrganizationImagesService organizationImages)
 {
     this.organizations = organizations;
     this.users = users;
     this.organizationImages = organizationImages;
 }

 public StatisticsService(
     IDbRepository<Story> storyRepository,
     IDbRepository<Chapter> chapterRepository,
     IDbRepository<Genre> genreRepository)
 {
     this.storyRepository = storyRepository;
     this.chapterRepository = chapterRepository;
     this.genreRepository = genreRepository;
 }

 public WishListController(
       IProductService products,
       IDbRepository<Wishlist> wishLists,
       IService<Product> productsService)
 {
     this.productsService = productsService;
     this.products = products;
     this.wishLists = wishLists;
 }

 public RoomsService(
     IDbRepository<BookedRoom> booked,
     IDbRepository<Room> rooms,
     IDbRepository<Reservation> reservations)
 {
     this.bookedRooms = booked;
     this.rooms = rooms;
     this.reservations = reservations;
 }

 public ShoppingCartController(
       IProductService products,
       IDbRepository<ShoppingCart> shoppingCarts,
       IService<Product> productsService)
 {
     this.productsService = productsService;
     this.products = products;
     this.shoppingCarts = shoppingCarts;
 }

        public AuditTrailQueryService(IDbRepository repository)
        {
            if (repository == null)
            {
                throw new ArgumentException("repository");
            }

            this.repository = repository;
        }

        public void RestartBattlesForTeam(IDbRepository<Battle> battlesRepository, int teamId)
        {
            var battlesForTeam = battlesRepository.All().Where(x => x.FirstTeamId == teamId || x.SecondTeamId == teamId);
            foreach (var battle in battlesForTeam)
            {
                battle.IsFinished = false;
            }

            battlesRepository.Save();
        }

        public ShopController(IDbRepository<Category> categories, IDbRepository<Product> products)
        {
            this.categories = categories;
            this.products = products;

            this.CalculateNumberOfProductsInCategories();

            ViewBag.Categories = this.categories.All().ToList();
            ViewBag.NumberOfProductsInCategories = this.numberOfProductsInCategories;
        }