public void Initialize (ILoginService service, IConfigSource config, IRegistryCore registry)
        {
            IConfig loginServerConfig = config.Configs ["LoginService"];
            if (loginServerConfig != null) {
                m_UseTOS = loginServerConfig.GetBoolean ("UseTermsOfServiceOnFirstLogin", false);
                m_TOSLocation = loginServerConfig.GetString ("FileNameOfTOS", "");

                if (m_TOSLocation.Length > 0) {
                    // html appears to be broken
                    if (m_TOSLocation.ToLower ().StartsWith ("http://", StringComparison.Ordinal))
                        m_TOSLocation = m_TOSLocation.Replace ("ServersHostname", MainServer.Instance.HostName);
                    else {
                        var simBase = registry.RequestModuleInterface<ISimulationBase> ();
                        var TOSFileName = PathHelpers.VerifyReadFile (m_TOSLocation, ".txt", simBase.DefaultDataPath);
                        if (TOSFileName == "") {
                            m_UseTOS = false;
                            MainConsole.Instance.ErrorFormat ("Unable to locate the Terms of Service file : '{0}'", m_TOSLocation);
                            MainConsole.Instance.Error (" Show 'Terms of Service' for a new user login is disabled!");
                        } else
                            m_TOSLocation = TOSFileName;
                    }
                } else
                    m_UseTOS = false;

            }
            m_AuthenticationService = registry.RequestModuleInterface<IAuthenticationService> ();
            m_LoginService = service;
        }

 public UsersController(IUsersService usersService,
                        IUserAuthentication authentication,
                        ILoginService loginService)
     : base(authentication, loginService)
 {
     this.usersService = usersService;
 }

        public OAuthTokenLoginViewModel(
            ILoginService loginFactory, 
            IAccountsRepository accountsRepository,
            IAlertDialogFactory alertDialogFactory)
        {
            Title = "Login";

            var canLogin = this.WhenAnyValue(y => y.Token, (x) => !string.IsNullOrEmpty(x));
            LoginCommand = ReactiveCommand.CreateAsyncTask(canLogin, async _ => 
            {
                try
                {
                    using (alertDialogFactory.Activate("Logging in..."))
                    {
                        var account = await loginFactory.Authenticate(ApiDomain, WebDomain, Token, false);
                        await accountsRepository.SetDefault(account);
                        return account;
                    }
                }
                catch (UnauthorizedException)
                {
                    throw new Exception("The provided token is invalid! Please try again or " +
                        "create a new token as this one might have been revoked.");
                }
            });

            LoginCommand.Subscribe(x => MessageBus.Current.SendMessage(new LogoutMessage()));
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="AccountController"/> class.
        /// </summary>
        /// <param name="logger">Logger Service</param>
        /// <param name="loginService">Login Service</param>
        /// <param name="userService">User Service</param>
        /// <param name="passwordService">Password Service</param>
        public AccountController(
            ILoggerService logger, 
            ILoginService loginService, 
            IUserService userService, 
            IPasswordService passwordService)
            : base(logger)
        {
            if (loginService == null)
            {
                throw new ArgumentNullException("ILoginService, LoginController");
            }

            if (userService == null)
            {
                throw new ArgumentNullException("IUserService, LoginController");
            }

            if(passwordService == null)
            {
                throw new ArgumentNullException("IPasswordService, LoginController");
            }

            this._loginService = loginService;
            this._userService = userService;
            this._passwordService = passwordService;
        }

 public BCProxyLoginController(IPortalUserFacade portalUserFacade, ILoginService loginService, IFormsAuthenticationService formsAuthenticationService, IPortletTemplateFacade portletTemplateFacade)
 {
     _loginService = loginService;
     _formsAuthenticationService = formsAuthenticationService;
     _portletTemplateFacade = portletTemplateFacade;
     _portalUserFacade = portalUserFacade;
 }

      protected override void OnCreate (Bundle bundle)
      {
         AppSettings.TrackingId = "UA-65892866-1";
         AppSettings.RegisterTypes ();

         Logger.Instance = new AndroidLogger ();
         Mvx.RegisterType<IToastService, ToastService> ();
         Mvx.RegisterType<IAnalyticsService, AnalyticsService> ();

         base.OnCreate (bundle);

         SetContentView (Resource.Layout.Main);

         _apiService = Mvx.Resolve<IApiService> ();
         _toastService = Mvx.Resolve<IToastService> ();
         _loginService = Mvx.Resolve<ILoginService> ();

         IsLoading = true;
         CheckUserExists ();

         Button button = FindViewById<Button> (Resource.Id.button_register);

         button.Click += ClickHandler;

         AppLocation.Current.LocationServiceConnected += (object sender, ServiceConnectedEventArgs e) => {
         };
         AppLocation.StartLocationService ();
      }

 public HomeController(IHomeDataService homeDataService, ILoginService loginService, IUsersService usersService, IActivitiesService activitiesService)
 {
     _homeDataService = homeDataService;
     _loginService = loginService;
     _usersService = usersService;
     _activitiesService = activitiesService;
 }

        public LoginViewModel(IMessenger messenger, ILoginService loginService)
        {
            _messenger = messenger;
            _loginService = loginService;

            LoginCommand = new RelayCommand<object>(Login);
        }

        public AngelCourseService(IEventAggregator eventAggregator, ILoginService loginService)
        {
            this.eventAggregator = eventAggregator;
            this.loginService = loginService;

            eventAggregator.GetEvent<LoginStatusChangedEvent>().Subscribe(GetCoursesForUser, ThreadOption.UIThread);
            eventAggregator.GetEvent<ActiveCourseChangedEvent>().Subscribe(LoadCourse, ThreadOption.UIThread);
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="UserController"/> class.
 /// </summary>
 /// <param name="loginService">The login service.</param>
 /// <param name="userService">The user service.</param>
 /// <param name="emailService">The email service.</param>
 public UserController(ILoginService loginService, ISubscriberService subscriberService,
     IUserService userService, IEmailService emailService)
 {
     _loginService = loginService;
     _userService = userService;
     _emailService = emailService;
     _subscriberService = subscriberService;
 }

 public OpmlImporterController(
     IUserAuthentication authentication,
     ILoginService loginService,
     IOpmlImporterService opmlImporterService)
     : base(authentication, loginService)
 {
     this.opmlImporterService = opmlImporterService;
 }

 public OrderPlacedService(IUserService userService, ILoginService loginService, ISession session,
     IRegistrationService registrationService)
 {
     _userService = userService;
     _loginService = loginService;
     _session = session;
     _registrationService = registrationService;
 }

 public AccountController(
     IUserAuthentication authentication,
     ILoginService loginService,
     IAccountService accountService)
     : base(authentication, loginService)
 {
     this.accountService = accountService;
 }

 public UsersController(IUsersService usersService,
                        IUserAuthentication authentication,
                        ILoginService loginService,
                        ISessionProvider sessionProvider)
     : base(authentication, loginService, sessionProvider)
 {
     this.usersService = usersService;
 }

 public StreamController(
    IUserAuthentication authentication,
    ILoginService loginService,
    IRssSubscriptionService rssSubscriptionService)
     : base(authentication, loginService)
 {
     this.rssSubscriptionService = rssSubscriptionService;
 }

 public HomeController(
     IUserAuthentication authentication,
     ILoginService loginService,
     ISessionProvider sessionProvider,
     IRssChannelsRepository rssRepository)
     : base(authentication, loginService, sessionProvider)
 {
     this.rssRepository = rssRepository;
 }

 public MainWindowViewModel(
     ILoginService loginService,
     IBitBucketClient bitBucketClient,
     IUserService userService)
 {
     this.loginService = loginService;
     this.bitBucketClient = bitBucketClient;
     this.userService = userService;
 }

        public AdminLoginModule(ILoginService loginService, IDocumentStore store)
            : base("/admin")
        {
            this.RequiresInstallerDisabled(() => store.OpenSession());
            this.RequiresHttpsOrXProto();

            Get["/login"] =
                parameters =>
                {
                    using (IDocumentSession session = store.OpenSession())
                    {
                        SiteSettings site = session.GetSiteSettings();

                        if (site == null)
                        {
                            site = new SiteSettings
                            {
                                Title = "Admin",
                                SubTitle = "Go to Site -> Settings"
                            };
                        }

                        return View["admin/login", new
                        {
                            site.Title,
                            SubTitle = "Login"
                        }];
                    }
                };

            Get["/logout"] = parameters =>
            {
                // Called when the user clicks the sign out button in the application. Should
                // perform one of the Logout actions (see below)

                return View["admin/logout"];
            };

            Post["/login"] = parameters =>
            {
                // Called when the user submits the contents of the login form. Should
                // validate the user based on the posted form data, and perform one of the
                // Login actions (see below)
                var loginParameters = this.Bind<LoginParameters>();

                User user;
                if (!loginService.Login(loginParameters.UserName, loginParameters.Password, out user))
                {
                    return global::System.Net.HttpStatusCode.Unauthorized;
                }

                return this.LoginAndRedirect(
                    user.Identifier,
                    fallbackRedirectUrl: "/admin",
                    cookieExpiry: DateTime.Now.AddHours(1));
            };
        }

        public LoginViewModel(ILoginService loginService, IDialogService dialogService)
        {
            _loginService = loginService;
            _dialogService = dialogService;

            Username = "TestUser";
            Password = "YouCantSeeMe";
            IsLoading = false;
        }

 public AdminController(
     IUserAuthentication authentication,
     ILoginService loginService,
     IAdminService adminService,
     IUpdateService updateService)
     : base(authentication, loginService)
 {
     this.adminService = adminService;
     this.updateService = updateService;
 }