public BaseController()
 {
     _mail = new MailSandler();
     _repository = DependencyResolver.Current.GetService<IRepository>();
    _mapper = DependencyResolver.Current.GetService<IMapper>();
    _auth = DependencyResolver.Current.GetService<IAuthentication>();
 }

        public InstitutionsController(IInstitutionRepository institutionRepository, IBaseScoreCardRepository baseScoreCardRepository, IValuationScoreCardRepository valuationScoreCardRepository, IUserProfileRepository userProfileRepository, IAuthentication authentication)
            : base(baseScoreCardRepository, valuationScoreCardRepository, userProfileRepository, authentication)
        {
            Requires.NotNull(institutionRepository, nameof(institutionRepository));

            this.institutionRepository = institutionRepository;
        }

        public AdminBaseController( IAuthentication authentication = null)
        {
            

            // Allows us to injects a IUserHelper in unit tests
            Authentication = authentication ?? DependencyManager.Authentication;
        }

        /// <summary>
        /// Logs on with specified authentication method.
        /// </summary>
        /// <param name="authentication">The authentication method.</param>
        /// <returns></returns>
        /// <exception cref="System.InvalidOperationException">
        /// Already logged on
        /// or
        /// Another unfinished log on/off request exists.
        /// </exception>
        /// <exception cref="System.Exception">Null user info is not allowed</exception>
        public async Task LogOn(IAuthentication authentication)
        {

            if (UserInfo != null)
            {
                throw new InvalidOperationException("Already logged on");
            }
            if (Interlocked.CompareExchange(ref IsWorking, 1, 0) == 0)
            {
                try
                {
                    var result = await authentication.Authenticate();
                    if (result == null)
                    {
                        throw new Exception("Null user info is not allowed");
                    }
                    UserInfo = result;
                    ServerConnection.AccessToken = UserInfo.AccessToken;
                    return;
                }
                finally
                {
                    Interlocked.CompareExchange(ref IsWorking, 0, 1);
                }
            }
            throw new InvalidOperationException("Another unfinished log on/off request exists.");
        }

        public BaseController(IDb db, ILogger logger, IAuthentication authentication = null)
        {
            Db = db;
            Logger = logger;

            Authentication = authentication ?? DependencyManager.Authentication;
        }

 public FeaturedController(IUserService userService, IAuthentication authentication, IListingService listingService, IFeaturedService featuredService)
 {
     _userService = userService;
     _authentication = authentication;
     _listingService = listingService;
     _featuredService = featuredService;
 }

 public MapModule(IRegionManager regionManager, IAuthentication authentication, IEventAggregator eventAggregator)
 {
     this.regionManager = regionManager;
     this.authentication = authentication;
     if (eventAggregator != null)
         eventAggregator.GetEvent<CompositePresentationEvent<LogonData>>().Subscribe(OnLogonChanged);
 }

 public PromotionController(IUserService userService, IAuthentication authentication, IListingService listingService, IPromotionService promotionService)
 {
     _userService = userService;
     _authentication = authentication;
     _listingService = listingService;
     _promotionService = promotionService;
 }

 public QoamCornersController(IBaseScoreCardRepository baseScoreCardRepository, IValuationScoreCardRepository valuationScoreCardRepository, IUserProfileRepository userProfileRepository, IAuthentication authentication, IJournalRepository journalRepository, ICornerRepository cornerRepository, IBulkImporter<CornerToImport> bulkImporter)
     : base(baseScoreCardRepository, valuationScoreCardRepository, userProfileRepository, authentication)
 {
     _journalRepository = journalRepository;
     _cornerRepository = cornerRepository;
     _bulkImporter = bulkImporter;
 }

        public AdminController(JournalsImport journalsImport, UlrichsImport ulrichsImport, DoajImport doajImport, JournalTocsImport journalsTocImport, JournalsExport journalsExport, IJournalRepository journalRepository, IUserProfileRepository userProfileRepository, IAuthentication authentication, IInstitutionRepository institutionRepository, IBlockedISSNRepository blockedIssnRepository, IBaseScoreCardRepository baseScoreCardRepository, IValuationScoreCardRepository valuationScoreCardRepository, IBulkImporter<SubmissionPageLink> bulkImporter, IBulkImporter<Institution> institutionImporter)
            : base(baseScoreCardRepository, valuationScoreCardRepository, userProfileRepository, authentication)
        {
            Requires.NotNull(journalsImport, nameof(journalsImport));
            Requires.NotNull(ulrichsImport, nameof(ulrichsImport));
            Requires.NotNull(journalsTocImport, nameof(journalsTocImport));
            Requires.NotNull(doajImport, nameof(doajImport));
            Requires.NotNull(journalsExport, nameof(journalsExport));
            Requires.NotNull(journalRepository, nameof(journalRepository));
            Requires.NotNull(institutionRepository, nameof(institutionRepository));
            Requires.NotNull(blockedIssnRepository, nameof(blockedIssnRepository));
            Requires.NotNull(bulkImporter, nameof(bulkImporter));
            Requires.NotNull(institutionImporter, nameof(institutionImporter));

            this.journalsImport = journalsImport;
            this.ulrichsImport = ulrichsImport;
            this.doajImport = doajImport;
            _journalsTocImport = journalsTocImport;
            this.journalsExport = journalsExport;
            this.journalRepository = journalRepository;
            this.institutionRepository = institutionRepository;
            this.blockedIssnRepository = blockedIssnRepository;

            _bulkImporter = bulkImporter;
            _institutionImporter = institutionImporter;
        }

		/// <summary>
		/// 
		/// </summary>
		/// <param name="authentication"></param>
		/// <param name="hasCommentary"></param>
		/// <param name="hasContext"></param>
		public TextClient(IAuthentication authentication, bool hasCommentary, bool hasContext)
			: base(authentication)
		{
			_authentication = authentication;
			HasCommentary = hasCommentary;
			HasContext = hasContext;
		}

 public BillingViewModelBuilder(CheckoutDetailsModel checkoutDetailsModel, IAuthentication authentication,ICustomerAccountService accountService, IMappingEngine mapper)
 {
     this.checkoutDetailsModel = checkoutDetailsModel;
     this.authentication = authentication;
     this.accountService = accountService;
     this.mapper = mapper;
 }

        /// <summary>
        /// Updates the authentication that this Client uses.
        /// </summary>
        /// <param name="authentication">The authentication to put into this Client.</param>
        public void ChangeAuthentication(IAuthentication authentication)
        {
            if (authentication.AuthenticationType != AuthenticationType.ClientId)
                throw new NotImplementedException();

            Authentication = authentication;
        }

 public HttpAuth(
     IPrincipalFactory principalFactory,
     IAuthentication authentication)
 {
     this.PrincipalFactory = principalFactory;
     this.Authentication = authentication;
 }

        public ScoreController(IBaseScoreCardRepository baseScoreCardRepository, IBaseJournalPriceRepository baseJournalPriceRepository, IValuationScoreCardRepository valuationScoreCardRepository, IValuationJournalPriceRepository valuationJournalPriceRepository, IScoreCardVersionRepository scoreCardVersionRepository, IJournalRepository journalRepository, ILanguageRepository languageRepository, ISubjectRepository subjectRepository, IQuestionRepository questionRepository, GeneralSettings generalSettings, IUserProfileRepository userProfileRepository, IInstitutionRepository institutionRepository, IAuthentication authentication)
            : base(userProfileRepository, authentication)
        {
            Requires.NotNull(baseScoreCardRepository, "baseScoreCardRepository");
            Requires.NotNull(baseJournalPriceRepository, "baseJournalPriceRepository");
            Requires.NotNull(valuationScoreCardRepository, "valuationScoreCardRepository");
            Requires.NotNull(valuationJournalPriceRepository, "valuationJournalPriceRepository");
            Requires.NotNull(scoreCardVersionRepository, "scoreCardVersionRepository");
            Requires.NotNull(journalRepository, "journalRepository");
            Requires.NotNull(languageRepository, "languageRepository");
            Requires.NotNull(subjectRepository, "keywordRepository");
            Requires.NotNull(questionRepository, "questionRepository");
            Requires.NotNull(institutionRepository, "institutionRepository");
            Requires.NotNull(generalSettings, "generalSettings");

            this.baseScoreCardRepository = baseScoreCardRepository;
            this.scoreCardVersionRepository = scoreCardVersionRepository;
            this.valuationJournalPriceRepository = valuationJournalPriceRepository;
            this.valuationScoreCardRepository = valuationScoreCardRepository;
            this.journalRepository = journalRepository;
            this.languageRepository = languageRepository;
            this.subjectRepository = subjectRepository;
            this.questionRepository = questionRepository;
            this.baseJournalPriceRepository = baseJournalPriceRepository;
            this.institutionRepository = institutionRepository;
            this.generalSettings = generalSettings;
        }

 public MembershipController(IUserService userService, IAuthentication authentication, IListingService listingService, IMembershipService membershipService)
 {
     _userService = userService;
     _authentication = authentication;
     _listingService = listingService;
     _membershipService = membershipService;
 }

 public AuthController(
     ICurrentUser currentUser,
     IAuthentication authentication)
 {
     _currentUser = currentUser;
     _authentication = authentication;
 }

        protected ApplicationController(IUserProfileRepository userProfileRepository, IAuthentication authentication)
        {
            Requires.NotNull(userProfileRepository, "userProfileRepository");
            Requires.NotNull(authentication, "authentication");

            this.UserProfileRepository = userProfileRepository;
            this.Authentication = authentication;
        }

 public AuthenticateEndpoint(IEndpoint endpoint, IAuthenticationRuleCollection authenticationRuleCollection, IAuthentication authentication, 
     IOutputWriter outputWriter)
 {
     this.endpoint = endpoint;
     this.authenticationRuleCollection = authenticationRuleCollection;
     this.authentication = authentication;
     this.outputWriter = outputWriter;
 }

 public ShoppingCartViewModelBuilder(IShoppingCart shoppingCart, IJewelRepository jewelRepository, CartItemViewModelBuilder cartItemViewModelBuilder, IAuthentication authentication, IMappingEngine mapper)
 {
     this.shoppingCart = shoppingCart;
     this.jewelRepository = jewelRepository;
     this.cartItemViewModelBuilder = cartItemViewModelBuilder;
     this.authentication = authentication;
     this.mapper = mapper;
 }