public AccountController(IFormsAuthentication formsAuthentication, 
     IUserRepository users, ICommandSender cmds)
 {
     _formsAuthentication = formsAuthentication;
     _users = users;
     _cmds = cmds;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="SessionManager"/> class.
 /// </summary>
 /// <param name="userDataRepository">The user data repository.</param>
 /// <param name="configurationManager">The configuration manager.</param>
 /// <param name="logger">The logger.</param>
 /// <param name="userRepository">The user repository.</param>
 public SessionManager(IUserDataRepository userDataRepository, IServerConfigurationManager configurationManager, ILogger logger, IUserRepository userRepository)
 {
     _userDataRepository = userDataRepository;
     _configurationManager = configurationManager;
     _logger = logger;
     _userRepository = userRepository;
 }

 public GroupsService(IGroupsRepository groupsRepository, IUserRepository userRepository, IAppConfigurationProvider configurationProvider, ITasksService tasksService)
 {
     _groupsRepository = groupsRepository;
     _userRepository = userRepository;
     _tasksService = tasksService;
     _configurationProvider = configurationProvider;
 }

 public MenuViewModel(IUserRepository userRepository)
 {
     if (userRepository == null) 
         throw new ArgumentNullException("userRepository");
     _userRepository = userRepository;
     Menu = new ReactiveList<MenuOptionViewModel>();
     // Use WhenAny to observe one or more values
     var canLoadMenu = this.WhenAny(m => m.User, user => user.Value != null);
     // hook function to command, shouldn't contain UI/complex logic
     LoadMenu = ReactiveCommand.CreateAsyncTask(canLoadMenu, _ => _userRepository.GetMenuByUser(User));
     // RxApp.MainThreadScheduler is our UI thread, you can go wild here
     LoadMenu.ObserveOn(RxApp.MainThreadScheduler).Subscribe(menu =>
     {
         Menu.Clear();
         foreach (var option in menu)
         {
             var menuOption = new MenuOptionViewModel(option);
             Menu.Add(menuOption);
         }
     });
     LoadMenu.ThrownExceptions.Subscribe(ex =>
     {
         Menu.Clear();
         MessageBox.Show(ex.Message);
     });
     // Use WhenAnyValue to check if a property was changed
     // If user was changed reload menu
     this.WhenAnyValue(m => m.User).InvokeCommand(this, vm => vm.LoadMenu);
 }

        public void verify_receive_appropriate_error_message_when_user_provides_a_bad_user_name_or_password()
        {
            AuthenticationStatus authStatus = null;
            Story authenticateUserStory = new Story("Authenticate User");

            authenticateUserStory.AsA("Unauthenticated user")
                .IWant("supply my user name and password to the login form")
                .SoThat("I can  authenticate to the application");

            authenticateUserStory
                .WithScenario("User provides an invalid user name")
                .Given("My user name and password are ", "Big Daddy", "Gobldegook", delegate(string userName, string password) { UserRepositoryFactory factory = _mock.DynamicMock<UserRepositoryFactory>();

                                                                                                                                 using (_mock.Record())
                                                                                                                                 {
                                                                                                                                    Expect.Call(factory.Create(userName, password))
                                                                                                                                        .Return(_mock.DynamicMock<IUserRepository>());
                                                                                                                                 }

                                                                                                                                 _user = factory.Create(userName, password); })
                .When("I authenticate the user", delegate {_service = _mock.DynamicMock<IAuthenticationService>();
                                                            using (_mock.Record())
                                                            {
                                                                Expect.Call(_service.Authenticate(_user))
                                                                    .Return(new AuthenticationStatus(new Exception("Bad Username or Password")));
                                                            }
                                                           authStatus = _service.Authenticate(_user);})
                .Then("I should receive an Authentication status of", Status.Failed, delegate(Status expectedStatus) {Assert.AreEqual(expectedStatus, authStatus.Status);});
        }

 public UserService(IUserRepository userRepository, IUserInfoRepository userInfoRepository, IUserPreferencesRepository userPreferencesRepository,  IUnitOfWork unitOfWork)
 {
     _userRepository = userRepository;
     _userInfoRepository = userInfoRepository;
     _userPreferencesRepository = userPreferencesRepository;
     _unitOfWork = unitOfWork;
 }

 public IdeaController(IIdeaRepository ideas, IUserRepository users, ISettingsRepository settings, IImageRepository imageRepository, IFeatureRepository features)
 {
     _ideas = ideas;
     _users = users;
     _settings = settings;
     _features = features;
 }

		public WikiExporter(ApplicationSettings applicationSettings, PageService pageService, ISettingsRepository settingsRepository, IPageRepository pageRepository, IUserRepository userRepository, IPluginFactory pluginFactory)
		{
			if (applicationSettings == null)
				throw new ArgumentNullException(nameof(applicationSettings));

			if (pageService == null)
				throw new ArgumentNullException(nameof(pageService));

			if (settingsRepository == null)
				throw new ArgumentNullException(nameof(settingsRepository));

			if (pageRepository == null)
				throw new ArgumentNullException(nameof(pageRepository));

			if (userRepository == null)
				throw new ArgumentNullException(nameof(userRepository));

			if (pluginFactory == null)
				throw new ArgumentNullException(nameof(pluginFactory));

			_applicationSettings = applicationSettings;
			_pageService = pageService;
			_sqlExportBuilder = new SqlExportBuilder(settingsRepository, userRepository, pageRepository, pluginFactory);

			ExportFolder = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "App_Data", "Export");
		}

 public void SetUp()
 {
     blogRP = MockRepository.GenerateMock<IBlogRepository>();
     postRP = MockRepository.GenerateMock<IPostRepository>();
     userRP = MockRepository.GenerateMock<IUserRepository>();
     friendlyUrlGen = MockRepository.GenerateMock<IFriendlyUrlGenerator>();
 }

        public static User GetCurrentUser(this NancyContext context, IUserRepository _users)
        {
            if (context == null || context.CurrentUser == null || string.IsNullOrWhiteSpace(context.CurrentUser.UserName))
                return null;

            return _users.FindBy(u => u.UserName == context.CurrentUser.UserName).FirstOrDefault();
        }

 public ImageBrowserController(IInvestContext investContext, IUserRepository userRepository)
 {
     this.directoryBrowser = new DirectoryBrowser();
     this.thumbnailCreator = new ThumbnailCreator();
     this._investContext = investContext;
     this._userRepository = userRepository;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="UserManager" /> class.
 /// </summary>
 /// <param name="logger">The logger.</param>
 /// <param name="configurationManager">The configuration manager.</param>
 /// <param name="userRepository">The user repository.</param>
 public UserManager(ILogger logger, IServerConfigurationManager configurationManager, IUserRepository userRepository)
 {
     _logger = logger;
     UserRepository = userRepository;
     ConfigurationManager = configurationManager;
     Users = new List<User>();
 }

        public AllowAuthorAttribute()
        {
            isAccess = false;

            _userRepository = DependencyResolver.Current.GetService<IUserRepository>();
            _articleRepository = DependencyResolver.Current.GetService<IArticleRepository>();
        }

 public TopicsController(ITopicsRepository topicsRepository, 
     IChaptersRepository chaptersRepository, IUserRepository userRepository)
 {
     ChaptersRepository = chaptersRepository;
     UserRepository = userRepository;
     TopicsRepository = topicsRepository;
 }

 public TenantProvisioningService(ITenantRepository tenantRepository, IUserRepository userRepository,
     IRoleRepository roleRepository)
 {
     this._tenantRepository = tenantRepository;
     this._userRepository = userRepository;
     this._roleRepository = roleRepository;
 }

 public void AddUsersToRoles()
 {
     var users = Builder<User>.CreateListOfSize(2).
         TheFirst(1).With(x => x.Login = "A").
         TheLast(1).With(x => x.Login = "B").Build();
     var roles = Builder<Role>.CreateListOfSize(2).
         TheFirst(1).With(x => x.RoleName = "User").
         TheLast(1).With( x => x.RoleName = "Admin").Build();
     _userRepository = Mockery.Stub<IUserRepository>();
     _roleRepository = Mockery.Stub<IRoleRepository>();
     using (Mockery.Record())
     {
         Expect.Call(_userRepository.GetUserByLogin("A")).Return(users[0]);
         Expect.Call(_userRepository.GetUserByLogin("B")).Return(users[1]);
         Expect.Call(_roleRepository.GetRoleByRoleName("User")).Return(roles[0]);
         Expect.Call(_roleRepository.GetRoleByRoleName("Admin")).Return(roles[1]);
     }
     using (Mockery.Playback())
     {
         _roleService = new RoleService(_roleRepository, _userRepository);
         _roleService.AddUsersToRoles(new[] {"A", "B"}, new[] {"User", "Admin"});
     }
     Assert.AreEqual(users[0].Roles.Count, 2);
     Assert.AreEqual(users[1].Roles.Count, 2);
 }

 public OAuth2TokenController(IUserRepository userRepository, IConfigurationRepository configurationRepository, IClientsRepository clientsRepository, ICodeTokenRepository refreshTokenRepository)
 {
     UserRepository = userRepository;
     ConfigurationRepository = configurationRepository;
     ClientsRepository = clientsRepository;
     RefreshTokenRepository = refreshTokenRepository;
 }

 public void Setup()
 {
     _domainService = Substitute.For<IUserDomainService>();
     _roleRepository = Substitute.For<IRoleRepository>();
     _userRepository = Substitute.For<IUserRepository>();
     _handler = new CreateAdminUserAccountCommandHandler(_domainService, _userRepository,_roleRepository);
 }

 public UserController(IUserRepository userRepository
     , IUserService userService
    )
 {
     _userRepository = userRepository;
     _userService = userService;
 }

        public ExampleSecureModule(IUserRepository userRepo)
        {
            this.RequiresAuthentication();

            this.Get["/api/examples/ambientContext"] = args =>
            {
                ICustomClaimsIdentity currentUser = AmbientContext.CurrentClaimsPrinciple.ClaimsIdentity;
                string guid = currentUser.GetAttribute(AmbientContext.UserPrincipalGuidAttributeKey).ToString();

                var user = userRepo.Get(guid);
                user.Password = null;

                return JsonConvert.SerializeObject(user);
                //return 200;
            };

            this.Get["/api/examples/context"] = args =>
            {
                var currentUser = this.Context.CurrentUser;
                string username = currentUser.UserName;

                var user = userRepo.GetByUsername(username);
                user.Password = null;

                return JsonConvert.SerializeObject(user);
            };
        }