public MailerJob(IUserRepository userRepository, ITweetRepository tweetRepository, IMassMailController mail)
{
this.userRepository = userRepository;
this.tweetRepository = tweetRepository;
this.mail = mail;
Console.WriteLine("MailerJob.ctor");
}
public FollowCommandHandler(
IConsole console,
IUserRepository userRepository)
: base(console)
{
_userRepository = userRepository;
}
public UserService(IUserRepository userRepository, IBetRepository betRepository, IMatchRepository matchRepository, IAdministratorService administratorService)
{
m_UserRepository = userRepository;
m_BetRepository = betRepository;
m_MatchRepository = matchRepository;
m_AdministratorService = administratorService;
}
public AccountController(IFormsAuthentication formsAuthentication,
IUserRepository users, ICommandSender cmds)
{
_formsAuthentication = formsAuthentication;
_users = users;
_cmds = cmds;
}
public GroupsService(IGroupsRepository groupsRepository, IUserRepository userRepository, IAppConfigurationProvider configurationProvider, ITasksService tasksService)
{
_groupsRepository = groupsRepository;
_userRepository = userRepository;
_tasksService = tasksService;
_configurationProvider = configurationProvider;
}
public CarrierController(ICityRepository cities, ICarrierRepository carriers, IIdentityService identity, IUserRepository users)
{
_cities = cities;
_carriers = carriers;
_identity = identity;
_users = users;
}
/// <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 ProjectController(IUserRepository userRepository, IProjectRepository projectRepository, OrganizationRepository organizationRepository, BillingManager billingManager, NotificationSender notificationSender) {
_userRepository = userRepository;
_projectRepository = projectRepository;
_organizationRepository = organizationRepository;
_billingManager = billingManager;
_notificationSender = notificationSender;
}
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 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);
};
}
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 UserController(IUserRepository userRepository
, IUserService userService
)
{
_userRepository = userRepository;
_userService = userService;
}
public IdeaController(IIdeaRepository ideas, IUserRepository users, ISettingsRepository settings, IImageRepository imageRepository, IFeatureRepository features)
{
_ideas = ideas;
_users = users;
_settings = settings;
_features = features;
}
public OAuth2TokenController(IUserRepository userRepository, IConfigurationRepository configurationRepository, IClientsRepository clientsRepository, ICodeTokenRepository refreshTokenRepository)
{
UserRepository = userRepository;
ConfigurationRepository = configurationRepository;
ClientsRepository = clientsRepository;
RefreshTokenRepository = refreshTokenRepository;
}
public UserService(IUserRepository userRepository, IUserInfoRepository userInfoRepository, IUserPreferencesRepository userPreferencesRepository, IUnitOfWork unitOfWork)
{
_userRepository = userRepository;
_userInfoRepository = userInfoRepository;
_userPreferencesRepository = userPreferencesRepository;
_unitOfWork = unitOfWork;
}
public ApplicantProfilePublishesController(IApplicantRepository applicantRepository, IApplicantProfileThemeLibraryRepository applicantprofilethemelibraryRepository, IUserRepository userRepository, IApplicantProfilePublishRepository applicantprofilepublishRepository)
{
this.applicantRepository = applicantRepository;
this.applicantprofilethemelibraryRepository = applicantprofilethemelibraryRepository;
this.userRepository = userRepository;
this.applicantprofilepublishRepository = applicantprofilepublishRepository;
}
public TenantProvisioningService(ITenantRepository tenantRepository, IUserRepository userRepository,
IRoleRepository roleRepository)
{
this._tenantRepository = tenantRepository;
this._userRepository = userRepository;
this._roleRepository = roleRepository;
}
public RentalAgreementService(IRentalAgreementRepository theRentalAgreementRepository,
ICustomerRepository theCustomerRepository, IUserRepository theUserRepository)
{
_rentalAgreementRepository = theRentalAgreementRepository;
_customerRepository = theCustomerRepository;
_userRepository = theUserRepository;
}
public VotesController(IPollRepository PollRepository, IUserIdentityService UserIdentityService,
IUserRepository UserRepository, IVoteRepository VoteRepository, ICategoryRepository CategoryRepository)
{
if (PollRepository == null)
{
throw new ArgumentNullException("CategoryRepository");
}
if (UserIdentityService == null)
{
throw new ArgumentNullException("UserIdentityService");
}
if (UserRepository == null)
{
throw new ArgumentNullException("UserIdentityService");
}
if (VoteRepository == null)
{
throw new ArgumentNullException("VoteRepository");
}
if (CategoryRepository == null)
{
throw new ArgumentNullException("CategoryRepository");
}
this.pollRepository = PollRepository;
this.userService = UserIdentityService;
this.userRepository = UserRepository;
this.voteRepository = VoteRepository;
this.categoryRepository = CategoryRepository;
}
public void Init()
{
_databaseFactory = new GaragableDatabaseFactory();
_userRepo = new UserRepository(_databaseFactory);
_randomString = new RandomStringGenerator();
_unitOfWork = new UnitOfWork(_databaseFactory);
}
public UserCreationService(IDbContextScopeFactory dbContextScopeFactory, IUserRepository userRepository)
{
if (dbContextScopeFactory == null) throw new ArgumentNullException("dbContextScopeFactory");
if (userRepository == null) throw new ArgumentNullException("userRepository");
_dbContextScopeFactory = dbContextScopeFactory;
_userRepository = userRepository;
}
public void AddUsersToRoles()
{
var users = Builder<User>.CreateListOfSize(2).
TheFirst(1).With(x => x.Login = "******").
TheLast(1).With(x => x.Login = "******").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 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 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;
}
public AllowAuthorAttribute()
{
isAccess = false;
_userRepository = DependencyResolver.Current.GetService<IUserRepository>();
_articleRepository = DependencyResolver.Current.GetService<IArticleRepository>();
}
/// <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 void SetUp()
{
blogRP = MockRepository.GenerateMock<IBlogRepository>();
postRP = MockRepository.GenerateMock<IPostRepository>();
userRP = MockRepository.GenerateMock<IUserRepository>();
friendlyUrlGen = MockRepository.GenerateMock<IFriendlyUrlGenerator>();
}
public TopicsController(ITopicsRepository topicsRepository,
IChaptersRepository chaptersRepository, IUserRepository userRepository)
{
ChaptersRepository = chaptersRepository;
UserRepository = userRepository;
TopicsRepository = topicsRepository;
}
public void Setup()
{
_domainService = Substitute.For<IUserDomainService>();
_roleRepository = Substitute.For<IRoleRepository>();
_userRepository = Substitute.For<IUserRepository>();
_handler = new CreateAdminUserAccountCommandHandler(_domainService, _userRepository,_roleRepository);
}
public DeleteUserUseCase(IUserRepository userRepository)
{
_userRepository = userRepository;
}
public HomeController(DevPartnersEmployeeContext context, IUserRepository user)
{
_context = context;
_user = user;
}
public ApiKeyAuthenticationHandler(ITokenRepository tokenRepository, IUserRepository userRepository, IOptionsMonitor <ApiKeyAuthenticationOptions> options, ILoggerFactory logger, UrlEncoder encoder, ISystemClock clock) : base(options, logger, encoder, clock)
{
_tokenRepository = tokenRepository;
_userRepository = userRepository;
}
/// <summary>
/// Alapértelmezett konstruktor
/// </summary>
/// <param name="users">A felhasználókat tartalmazó gyűjtemény</param>
/// <param name="roles">A jogokat tartalmazó gyűjtemény</param>
public SimpleAuthenticator(IUserRepository <IUser> users, IRoleRepository <IRole> roles)
{
UserRepository = users;
RoleRepository = roles;
}
public UserAppService(IMapper mapper, UserDomain userDomain, IUnitOfWork unitOfWork, IUserRepository userRepository) : base(mapper)
{
List.Add(unitOfWork);
_userDomain = userDomain;
_unitOfWork = unitOfWork;
_userRepository = userRepository;
}
public CampLogic(ICustomerRepository customerRepository, ICampRepository campRepository, IRepository<Account> accountRepository, IFieldRepository fieldRepository, IUserRepository userRepository, IRepository<UserCamp> userCampRepository)
{
this.customerRepository = customerRepository;
this.campRepository = campRepository;
this.accountRepository = accountRepository;
this.fieldRepository = fieldRepository;
this.userRepository = userRepository;
this.userCampRepository = userCampRepository;
}
public Program(IUserRepository userRepository)
{
this.userRepository = userRepository;
}
public UserBusinessLogic(IUserRepository userRepository)
{
_userRepository = userRepository;
}
public UserService(IUserRepository userRepository, IOptions <JwtSettings> jwtSettings)
{
_userRepository = userRepository;
_jwtSettings = jwtSettings.Value;
}
public LikesController(IUserRepository userRepository, ILikesRepository likesRepository)
{
_likesRepository = likesRepository;
_userRepository = userRepository;
}
public UserController(IUserRepository repo)
{
this.repo = repo;
}
public PartialsController(IUserRepository _userRepository, IOrganisationRepository _organisationRepository, IAppModuleRepository _appModuleRepository)
{
this._userRepository = _userRepository;
this._organisationRepository = _organisationRepository;
this._appModuleRepository = _appModuleRepository;
}
/*
* This public constructor is used to inject several services into the application.
* These can then be used for accessing the corresponding repository.
*/
public UserController(IUserRepository repo, IAuthRepository authRepo, IMapper mapper)
{
this.repo = repo;
this.authRepo = authRepo;
this.mapper = mapper;
}
public BillAppService(IBarcodeLogRepository barcodeLogRepository, SerialNumberManager serialNumberManager, ILetterRepository letterRepository, IExchangeListDetailRepository exchangeListDetailRepository, IExchangeListRepository exchangeListRepository, UnitOfWork unitOfWork, IExchangeObjectRepository exchangeObjectRepository, IUserRepository userRepository, IDepartmentRepository departmentRepository, IPlaceWardenRepository placeWardenRepository, ILogger <BillAppService> logger)
{
_barcodeLogRepository = barcodeLogRepository;
_serialNumberManager = serialNumberManager;
_letterRepository = letterRepository;
_exchangeListDetailRepository = exchangeListDetailRepository;
_exchangeListRepository = exchangeListRepository;
_unitOfWork = unitOfWork;
_exchangeObjectRepository = exchangeObjectRepository;
_userRepository = userRepository;
_departmentRepository = departmentRepository;
_placeWardenRepository = placeWardenRepository;
_logger = logger;
}
public SyncUserService(IClientUserReader clientUserReader, IUserRepository userRepository)
{
_userRepository = userRepository;
_clientUserReader = clientUserReader;
}
public UserService(IUserRepository userRepository) : base(userRepository)
{
_userRepository = userRepository;
}
public static async Task <User> Execute(ITokenRepository tokenRepository, IUserRepository userRepository, ITokenInfoExtractor tokenInfoExtractor,
string token, string appKey, string device) =>
await new GetTokenInfo(tokenRepository, userRepository, tokenInfoExtractor, token, appKey, device).Do();
public UsersController(IUserRepository userRepo)
{
_userRepo = userRepo;
}
public CommentsController(IBlogRepository repo, IUserRepository userRepo, IMapper mapper)
{
_userRepo = userRepo;
_mapper = mapper;
_repo = repo;
}
public HomeController(IUserRepository userRepository)
{
_userRepository = userRepository;
}
public AuthController(ApplicationDbContext context, IUserRepository repo)
{
_context = context;
_repo = repo;
}
public AdsService(IUserRepository repository, IMapper mapper)
{
_repository = repository;
_mapper = mapper;
}
/// <summary>
/// 初始化一个<see cref="QueryUserService"/>类型的实例
/// </summary>
/// <param name="sqlQuery">Sql查询对象</param>
/// <param name="userRepository">用户仓储</param>
public QueryUserService(ISqlQuery sqlQuery, IUserRepository userRepository)
{
SqlQuery = sqlQuery;
UserRepository = userRepository;
}
/// <summary>
///
/// </summary>
/// <param name="logger"></param>
/// <param name="companyRepository"></param>
/// <param name="userRepository"></param>
/// <param name="companyAvatarsRepository"></param>
/// <param name="TenantManager"></param>
public CompanyManager(ILogger <CompanyManager> logger, ITenantRepository TenantRep, IRequestStatusRepository requestStatusRepository, ICompanyRepository companyRepository, IUserRepository userRepository, IAzureCompanyAvatarRepository companyAvatarsRepository)
{
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_companyRepository = companyRepository ?? throw new ArgumentNullException(nameof(companyRepository));
_TenantRep = TenantRep ?? throw new ArgumentNullException(nameof(companyRepository));
_companyAvatarsRepository = companyAvatarsRepository ?? throw new ArgumentNullException(nameof(companyAvatarsRepository));
_userRepository = userRepository ?? throw new ArgumentNullException(nameof(userRepository));
}
public UserService(IUserRepository repo)
{
_repo = repo;
}
public AuthService(IUserRepository userRepository)
{
_userRepository = userRepository;
}
public void Initialize()
{
userRepository = new UserRepository();
}
public SqlSugarController(UserRepository userRepository)
{
_user = userRepository;
}
public AdminController(IUserRepository repo)
{
repository = repo;
}
public LoginController(IUserRepository userRepository)
{
this.userRepository = userRepository;
}
