public IValidator Validate(IValidator validator, ISecurityRepository securityRepository) { NullGuard.NotNull(validator, nameof(validator)) .NotNull(securityRepository, nameof(securityRepository)); return(validator.ValidateIdentityIdentifier(Identifier, GetType(), nameof(Identifier))); }
public SecurityService(ISecurityRepository securityRepository, JwtIssuerOptions jwtIssuerOptions, IMapper mapper) { this._securityRepository = securityRepository; _mapper = mapper; _jwtIssuerOptions = jwtIssuerOptions; }
public BrokerController(ITraderRepository traderRepository, ISecurityRepository securityRepository, ITradeRepository tradeRepository) { _traderRepository = traderRepository; _securityRepository = securityRepository; _tradeRepository = tradeRepository; }
static void CheckInitialized(ISecurityRepository securityRepository) { if (_symbols == null) { _symbols = securityRepository.GetAllAsync().Result .ToDictionary(security => security.Symbol, security => security.Name).Keys.ToList(); } if (Prices.Count == 0) { foreach (var symbol in _symbols) { Prices.Add(symbol, new List <int>()); } } if (LastChange.Count != 0) { return; } Day = 0; foreach (var symbol in _symbols) { LastChange.Add(symbol, 0); } }
/// <summary> /// Initializes a new instance of the <see cref="GetEntityByKeyAuthorizationDecorator{T}"/> class. /// </summary> /// <param name="next">The decorated instance for which authorization is being performed.</param> /// <param name="authorizationContextProvider">Provides access to the authorization context, such as the resource and action.</param> /// <param name="authorizationFilteringProvider"></param> /// <param name="authorizationFilterDefinitionProvider"></param> /// <param name="explicitObjectValidators"></param> /// <param name="authorizationBasisMetadataSelector"></param> /// <param name="securityRepository"></param> /// <param name="sessionFactory"></param> /// <param name="apiKeyContextProvider"></param> /// <param name="viewBasedSingleItemAuthorizationQuerySupport"></param> public GetEntityByKeyAuthorizationDecorator( IGetEntityByKey <T> next, IAuthorizationContextProvider authorizationContextProvider, IAuthorizationFilteringProvider authorizationFilteringProvider, IAuthorizationFilterDefinitionProvider authorizationFilterDefinitionProvider, IExplicitObjectValidator[] explicitObjectValidators, IAuthorizationBasisMetadataSelector authorizationBasisMetadataSelector, ISecurityRepository securityRepository, ISessionFactory sessionFactory, IApiKeyContextProvider apiKeyContextProvider, IViewBasedSingleItemAuthorizationQuerySupport viewBasedSingleItemAuthorizationQuerySupport) : base( authorizationContextProvider, authorizationFilteringProvider, authorizationFilterDefinitionProvider, explicitObjectValidators, authorizationBasisMetadataSelector, securityRepository, sessionFactory, apiKeyContextProvider, viewBasedSingleItemAuthorizationQuerySupport) { _next = next; _viewBasedSingleItemAuthorizationQuerySupport = viewBasedSingleItemAuthorizationQuerySupport; }
public AccountRepository(IStockEngine stockEngine, ISecurityRepository securityRepository, AccountAtAGlanceContext context) : base(context) { _StockEngine = stockEngine; _SecurityRepository = securityRepository; }
public HandleSignInInformationController( ISecurityRepository securityRepository, IContentRepository contentRepo, IUserManagementService userManager) : base(userManager) { _securityRepository = securityRepository; _contentRepo = contentRepo; }
public AuthenticateClientSecretCommandHandler(ISecurityRepository securityRepository, ITokenHelper tokenHelper) : base(securityRepository) { NullGuard.NotNull(tokenHelper, nameof(tokenHelper)); _tokenHelper = tokenHelper; }
public DataServiceController(IAccountRepository acctRepo, ISecurityRepository secRepo, IMarketsAndNewsRepository marketRepo) { _AccountRepository = acctRepo; _SecurityRepository = secRepo; _MarketRepository = marketRepo; }
public DataServiceController(IAccountRepository acctRepo, ISecurityRepository secRepo, IMarketsAndNewsRepository marketRepo) { _AccountRepository = acctRepo; _SecurityRepository = secRepo; _MarketRepository = marketRepo; }
public async Task <IActionResult> Login([FromForm] LoginModel model, [FromServices] ISecurityRepository securityRepo) { if (ModelState.IsValid == false) { return(View(model)); } var(error, session) = await securityRepo.Login(model.Username, model.Password); if (error != null) { this.AlertError(error); return(View(model)); } var claims = new List <Claim> { new Claim(ClaimTypes.SerialNumber, session.User.Id.ToString()), new Claim(ClaimTypes.Name, session.User.Name) }; await HttpContext.SignInAsync(new ClaimsPrincipal(new ClaimsIdentity(claims, CookieAuthenticationDefaults.AuthenticationScheme))); await HttpContext.SetSession(session); return(RedirectToAction(nameof(Index))); }
public ExchangeConferenceRoomService(IMeetingRepository meetingRepository, ISecurityRepository securityRepository, IBroadcastService broadcastService, IDateTimeService dateTimeService, IMeetingCacheService meetingCacheService, IChangeNotificationService changeNotificationService, IExchangeServiceManager exchangeServiceManager, ISimpleTimedCache simpleTimedCache, IInstantMessagingService instantMessagingService, ISmsMessagingService smsMessagingService, ISmsAddressLookupService smsAddressLookupService, ISignatureService signatureService, IRoomRepository roomRepository) { _meetingRepository = meetingRepository; _securityRepository = securityRepository; _broadcastService = broadcastService; _dateTimeService = dateTimeService; _meetingCacheService = meetingCacheService; _changeNotificationService = changeNotificationService; _exchangeServiceManager = exchangeServiceManager; _simpleTimedCache = simpleTimedCache; _instantMessagingService = instantMessagingService; _smsMessagingService = smsMessagingService; _smsAddressLookupService = smsAddressLookupService; _signatureService = signatureService; _roomRepository = roomRepository; _ignoreFree = bool.Parse(ConfigurationManager.AppSettings["ignoreFree"] ?? "false"); _useChangeNotification = bool.Parse(ConfigurationManager.AppSettings["useChangeNotification"] ?? "true"); _impersonateForAllCalls = bool.Parse(ConfigurationManager.AppSettings["impersonateForAllCalls"] ?? "true"); _emailDomains = (ConfigurationManager.AppSettings["emailDomains"] ?? "") .Split(';') .Select(_ => _.StartsWith("@") ? _.ToLowerInvariant() : "@" + _.ToLowerInvariant()) .ToArray(); }
public static void SetSecurityRepository(ISecurityRepository securityRepository) { if (_securityRepository == null) { _securityRepository = securityRepository; } }
internal static void Update(TradingDay tradingDay, ISecurityRepository securityRepository) { CheckInitialized(securityRepository); if (Prices.Count == 0) { foreach (var symbol in Symbols) { Prices.Add(symbol, 0); } } if (LastChanges.Count == 0) { foreach (var symbol in Symbols) { LastChanges.Add(symbol, 0); } } foreach (var symbol in Symbols) { var effect = tradingDay.Effects[symbol]; Prices[symbol] += effect; if (tradingDay.Day == 0) { continue; } LastChanges[symbol] = effect; } }
public AccountController(ISessionManagementRepository sessionManagementRepository, ISecurityRepository securityRepository, IParentRepository parentRepository, IUserRepository userRepository) { _sessionManagementRepository = sessionManagementRepository; _securityRepository = securityRepository; _parentRepository = parentRepository; _userRepository = userRepository; }
public AccountRepository(WSPersonService personService, ISecurityRepository securityRepo, WSRequestService wsRequestService, TicketProvider ticketProvider) { _personService = personService; _securityRepo = securityRepo; _ticketProvider = ticketProvider; _wsRequestService = wsRequestService; }
public AccountController(ISessionManagementRepository sessionManagementRepository, ISecurityRepository securityRepository, IParentRepository parentRepository, IUserRepository userRepository) { _sessionManagementRepository = sessionManagementRepository; _securityRepository = securityRepository; _parentRepository = parentRepository; _userRepository = userRepository; }
public GadgetController(IAccountRepository accountRepository, ISecurityRepository securityRepository, IConfigRepository configRepository, ILookupRepository lookupRepository) { _accountRepository = accountRepository; _securityRepository = securityRepository; _configRepository = configRepository; _lookupRepository = lookupRepository; }
public AdministrationService(IRepository <FinancialYear> fiscalYearRepo, IRepository <TaxGroup> taxGroupRepo, IRepository <ItemTaxGroup> itemTaxGroupRepo, IRepository <PaymentTerm> paymentTermRepo, IRepository <Bank> bankRepo, IRepository <Tax> taxRepo, IRepository <GeneralLedgerSetting> generalLedgerSetting, IRepository <Account> accountRepo, IRepository <AuditLog> auditLogRepo, ISecurityRepository securityRepository, IRepository <Company> company = null ) : base(null, generalLedgerSetting, paymentTermRepo, bankRepo) { _fiscalYearRepo = fiscalYearRepo; _taxGroupRepo = taxGroupRepo; _itemTaxGroupRepo = itemTaxGroupRepo; _paymentTermRepo = paymentTermRepo; _bankRepo = bankRepo; _genetalLedgerSetting = generalLedgerSetting; _taxRepo = taxRepo; _company = company; _accountRepo = accountRepo; _auditLogRepo = auditLogRepo; _securityRepository = securityRepository; }
public SetAuthorizationContextForPut( IAuthorizationContextProvider authorizationContextProvider, ISecurityRepository securityRepository, IResourceClaimUriProvider resourceClaimUriProvider) : base(authorizationContextProvider, securityRepository, resourceClaimUriProvider) { }
/// <summary> /// Gets the assigned permissions for the current user /// </summary> /// <param name="provider">the service-provider for the current scope</param> /// <param name="permissionEstimator">provides the selected permission-estimator back outside</param> /// <returns>a list of assigned permissions</returns> public static string[] GetUserPermissions(this IServiceProvider provider, out ISecurityRepository securityRepository, out bool isAuthenticated) { isAuthenticated = provider.IsUserAuthenticated(out securityRepository, out var labels, out var authType); var permissions = isAuthenticated?securityRepository.GetPermissions(labels, authType).Select(n => n.PermissionName).Distinct().ToArray():Array.Empty <string>(); return(permissions); }
// add validation checks public static AuthenticateResponse ValidateCredentials(string token, string securityToken, string apiKey, string productName) { try { //First, call the C3UserRepository class to get the user information based on the token //Next, call the APIRepository class to identify if the apiKey/productName combination is valid //create AuthenticationResponse object and populate //write APISession object, with TTL information ISecurityRepository <AuthenticateResponse> userRepo = SecurityRepositoryFactory <AuthenticateResponse> .GetUserRepository(productName); ISecurityRepository <AuthenticateResponse> securityRepo = SecurityRepositoryFactory <AuthenticateResponse> .GetSecurityRepository(productName); AuthenticateResponse userResponse = userRepo.LoginUser(token, securityToken); if (string.IsNullOrEmpty(userResponse.SQLUserID) == false) { userResponse = securityRepo.LoginUser(userResponse, securityToken, apiKey, productName); } else { throw new UnauthorizedAccessException("Login Failed! Unknown token and security token."); } return(userResponse); } catch (Exception) { throw; } }
/// <summary> /// Initializes a new instance of the <see cref="OwnershipInitializationCreateEntityDecorator{T}"/> class. /// </summary> /// <param name="next">The decorated instance for which authorization is being performed.</param> /// <param name="authorizationContextProvider">Provides access to the authorization context, such as the resource and action.</param> /// <param name="authorizationFilteringProvider">The component capable of authorizing the request, given necessary context.</param> /// <param name="authorizationFilterDefinitionProvider"></param> /// <param name="explicitObjectValidators"></param> /// <param name="authorizationBasisMetadataSelector"></param> /// <param name="securityRepository"></param> /// <param name="sessionFactory"></param> /// <param name="apiKeyContextProvider"></param> /// <param name="viewBasedSingleItemAuthorizationQuerySupport"></param> public OwnershipInitializationCreateEntityDecorator( ICreateEntity <T> next, IAuthorizationContextProvider authorizationContextProvider, IAuthorizationFilteringProvider authorizationFilteringProvider, IAuthorizationFilterDefinitionProvider authorizationFilterDefinitionProvider, IExplicitObjectValidator[] explicitObjectValidators, IAuthorizationBasisMetadataSelector authorizationBasisMetadataSelector, ISecurityRepository securityRepository, ISessionFactory sessionFactory, IApiKeyContextProvider apiKeyContextProvider, IViewBasedSingleItemAuthorizationQuerySupport viewBasedSingleItemAuthorizationQuerySupport) : base( authorizationContextProvider, authorizationFilteringProvider, authorizationFilterDefinitionProvider, explicitObjectValidators, authorizationBasisMetadataSelector, securityRepository, sessionFactory, apiKeyContextProvider, viewBasedSingleItemAuthorizationQuerySupport) { _next = Preconditions.ThrowIfNull(next, nameof(next)); _apiKeyContextProvider = Preconditions.ThrowIfNull(apiKeyContextProvider, nameof(apiKeyContextProvider)); }
public void RemoveUncommitedRoleTest() { ISecurityRepository client = GetClient(); var account = new Account() { UserName = "******" }; var role = new Role() { Name = "testRole" }; var roleAssignment = new RoleAssignment { Account = account, AccountId = account.AccountId, Role = role, RoleId = role.RoleId }; client.Attach(account); // add role account.RoleAssignments.Add(roleAssignment); Assert.True(client.IsAttachedTo(roleAssignment)); // remove uncommited role account.RoleAssignments.Remove(roleAssignment); client.Remove(roleAssignment); Assert.False(client.IsAttachedTo(roleAssignment)); }
public SecurityPriceService(ITradeDateRepository tradeDateRepository, ISecurityRepository securityRepository, ISecurityPriceRepository securityPriceRepository) { _tradeDateRepository = tradeDateRepository; _securityRepository = securityRepository; _securityPriceRepository = securityPriceRepository; }
protected RepositoryOperationAuthorizationDecoratorBase( IAuthorizationContextProvider authorizationContextProvider, IAuthorizationFilteringProvider authorizationFilteringProvider, IAuthorizationFilterDefinitionProvider authorizationFilterDefinitionProvider, IExplicitObjectValidator[] explicitObjectValidators, IAuthorizationBasisMetadataSelector authorizationBasisMetadataSelector, ISecurityRepository securityRepository, ISessionFactory sessionFactory, IApiKeyContextProvider apiKeyContextProvider, IViewBasedSingleItemAuthorizationQuerySupport viewBasedSingleItemAuthorizationQuerySupport) { _authorizationContextProvider = authorizationContextProvider; _authorizationFilteringProvider = authorizationFilteringProvider; _authorizationFilterDefinitionProvider = authorizationFilterDefinitionProvider; _explicitObjectValidators = explicitObjectValidators; _authorizationBasisMetadataSelector = authorizationBasisMetadataSelector; _sessionFactory = sessionFactory; _apiKeyContextProvider = apiKeyContextProvider; _viewBasedSingleItemAuthorizationQuerySupport = viewBasedSingleItemAuthorizationQuerySupport; // Lazy initialization _bitValuesByAction = new Lazy <Dictionary <string, Actions> >( () => new Dictionary <string, Actions> { { securityRepository.GetActionByName("Create").ActionUri, Actions.Create }, { securityRepository.GetActionByName("Read").ActionUri, Actions.Read }, { securityRepository.GetActionByName("Update").ActionUri, Actions.Update }, { securityRepository.GetActionByName("Delete").ActionUri, Actions.Delete } }); }
public SecurityService(ISecurityRepository repository, IConfiguration config, IList <Token> tokens) { this.Repository = repository; this.TokenStore = tokens; this.Configuration = config; SecurityMapper.Map(); }
public UserClient(ISecurityRepository securityRepository, ICustomerRepository customerRepository, ICustomerSessionService customerSession, ICacheRepository cacheRepository) { _securityRepository = securityRepository; _customerRepository = customerRepository; _cacheRepository = cacheRepository; _customerSession = customerSession; _isEnabled = CustomerConfiguration.Instance.Cache.IsEnabled; }
public DatabaseInitializer(AccountAtAGlanceContext context, IAccountRepository acctRepo, ISecurityRepository securityRepo, IMarketsAndNewsRepository marketsRepo) { _Context = context; _AccountRepository = acctRepo; _SecurityRepository = securityRepo; _MarketsAndNewsRepository = marketsRepo; }
public MorningstarService(IScraper scraper, ISecurityRepository securityRepository, ICategoryRepository categoryRepository) { _scraper = scraper; _securityRepository = securityRepository; _categoryRepository = categoryRepository; _exchangeMapping = InitializeExchangeMapping(); }
public override IValidator Validate(IValidator validator, ISecurityRepository securityRepository) { NullGuard.NotNull(validator, nameof(validator)) .NotNull(securityRepository, nameof(securityRepository)); return(base.Validate(validator, securityRepository) .Object.ShouldBeUnknownValue(Identifier, number => Task.Run(async() => await GetClientSecretIdentityAsync(securityRepository) == null), GetType(), nameof(Identifier))); }
public UserClient(ISecurityRepository securityRepository, ICustomerRepository customerRepository, ICustomerSessionService customerSession, ICacheRepository cacheRepository) { _securityRepository = securityRepository; _customerRepository = customerRepository; _cacheRepository = cacheRepository; _customerSession = customerSession; _isEnabled = CustomerConfiguration.Instance.Cache.IsEnabled; }
public DatabaseInitializer(AccountAtAGlanceContext context, IAccountRepository acctRepo, ISecurityRepository securityRepo, IMarketsAndNewsRepository marketsRepo) { _Context = context; _AccountRepository = acctRepo; _SecurityRepository = securityRepo; _MarketsAndNewsRepository = marketsRepo; }
public IpRegulationServiceBase( ISecurityRepository repository, IActorInfoProvider actorInfoProvider ) { Repository = repository; ActorInfoProvider = actorInfoProvider; }
public AccountController( ISecurityRepository securityRepository, IUserRepository userRepository, IUploadHandler uploadHandler, IFileManager fileManager) { _securityRepository = securityRepository; _fileManager = fileManager; _uploadHandler = uploadHandler; _userRepository = userRepository; }
public HomeController(IDeviceRepository deviceRepository, ISecurityRepository securityRepository) { if (deviceRepository == null) throw new ArgumentNullException(nameof(deviceRepository)); if (securityRepository == null) throw new ArgumentNullException(nameof(securityRepository)); this.deviceRepository = deviceRepository; this.securityRepository = securityRepository; }
public void Setup() { _mocks = new MockRepository(); _dataRepository = MockRepository.GenerateStub<ISecurityRepository>(); _securityHelper = MockRepository.GenerateStub<ISecurityHelper>(); _logService = MockRepository.GenerateStub<ILogService>(); _log = MockRepository.GenerateStub<ILog>(); _securityService = new SecurityService(_dataRepository, _securityHelper, _logService); _mockUser = MockRepository.GenerateStub<IPortalUser>(); }
public ExchangeConferenceRoomService(ExchangeService exchangeService, IMeetingRepository meetingRepository, ISecurityRepository securityRepository, IBroadcastService broadcastService, IDateTimeService dateTimeService, IMeetingCacheService meetingCacheService, IChangeNotificationService changeNotificationService, IConcurrencyLimiter concurrencyLimiter) { _exchangeService = exchangeService; _meetingRepository = meetingRepository; _securityRepository = securityRepository; _broadcastService = broadcastService; _dateTimeService = dateTimeService; _meetingCacheService = meetingCacheService; _changeNotificationService = changeNotificationService; _concurrencyLimiter = concurrencyLimiter; _ignoreFree = bool.Parse(ConfigurationManager.AppSettings["ignoreFree"] ?? "false"); _useChangeNotification = bool.Parse(ConfigurationManager.AppSettings["useChangeNotification"] ?? "true"); }
public NotificationController(INotificationRepository notificationRepository, IAcademicYearRepository academicYearRepository, IParentRepository parentRepository, ISessionManagementRepository sessionManagementRepository, ISecurityRepository securityRepository, IStudentRepository studentRepository, IEnrollRepository enrollsRepository) { _notificationRepository = notificationRepository; _academicYearRepository = academicYearRepository; _parentRepository = parentRepository; _sessionManagementRepository = sessionManagementRepository; _securityRepository = securityRepository; StudentRepository = studentRepository; EnrollsRepository = enrollsRepository; SecurityRepository = securityRepository; }
public HomeworkController(IHomeworkRepository homeworkRepository, IAcademicYearDetailsRepository academicYearDetailRepository, IAcademicYearRepository academicYearRepository, IGradeRepository gradeRepository, ICourseRepository courseRepository, IStudentRepository studentRepository, IEnrollRepository enrollsRepository, ISessionManagementRepository sessionManagementRepository, ISecurityRepository securityRepository, IParentRepository parentRepository) { _homeworkRepository = homeworkRepository; _academicYearRepository = academicYearRepository; _gradeRepository = gradeRepository; _courseRepository = courseRepository; _academicYearDetailRepository = academicYearDetailRepository; StudentRepository = studentRepository; EnrollsRepository = enrollsRepository; _sessionManagementRepository = sessionManagementRepository; SecurityRepository = securityRepository; _parentRepository = parentRepository; }
public UserController(IUserRepository userRepository, ISecurityRepository securityRepository) { _userRepository = userRepository; _securityRepository = securityRepository; _viewMessageLogic = new ViewMessageLogic(this); }
public SecurityController(ISettings settings, ISecurityRepository securityRepository) { _settings = settings; _securityRepository = securityRepository; }
public void Initialize() { mockBuilder = new Mockery(); context = mockBuilder.NewMock<ISecurityRepository>(); }
public HomeController(ISessionManagementRepository sessionManagement, ISecurityRepository securityRepository) { _sessionManagement = sessionManagement; _securityRepository = securityRepository; _viewMessageLogic = new ViewMessageLogic(this); }
public QuestradeService(IQuestradeApiTokenManager tokenManager, ISecurityRepository securityRepository, ICategoryRepository categoryRepository) { _tokenManager = tokenManager; _securityRepo = securityRepository; _categoryRepository = categoryRepository; }
/// <summary> /// Initializes a new instance of the <see cref="SecurityService"/> class. /// </summary> /// <param name="repository">The repository.</param> /// <param name="membershipProvider">The membership provider.</param> public SecurityService(ISecurityRepository repository, IUserSecurity membershipProvider) { SecurityRepository = repository; MembershipProvider = membershipProvider; }
/// <summary> /// Initializes a new instance of the <see cref="AdminDashboardViewModel"/> class. /// </summary> /// <param name="settings">The settings.</param> /// <param name="cache">The cache.</param> /// <param name="securityRepos">The security repos.</param> public AdminDashboardViewModel(ISettings settings, ICache cache, ISecurityRepository securityRepos) : this() { var modules = DependencyResolver.Current.GetServices<IViewModule>() .Union<IModule>(DependencyResolver.Current.GetServices<IServiceModule>()) .Union<IModule>(DependencyResolver.Current.GetServices<IToolboxModule>()); foreach (var module in modules) { string moduleType = string.Empty; if (module is IViewModule) moduleType = " (View)"; else if (module is IServiceModule) moduleType = " (Service)"; else if (module is IToolboxModule) moduleType = " (Toolbox)"; LoadedModules.Add(module.GetType().FullName + moduleType); } UserStats = securityRepos.GetUserStats(); CurrentOnlineUserCount = settings.Sessions.Count; CacheCount = cache.ItemCount; CacheLongTimeout = settings.CacheLongTimeoutSecs; CacheMediumTimeout = settings.CacheMediumTimeoutSecs; CacheShortTimeout = settings.CacheShortTimeoutSecs; CacheConfiguration = settings.CacheOptions; CacheProvider = settings.CacheProvider; LoggingProvider = settings.LoggingProvider; LoggingConfiguration = settings.LogConfiguration; DataProvider = settings.DataProvider; Database = settings.DBConnectionString; }
/// <summary> /// Initializes a new instance of the <see cref="AuthenticationService"/> class. /// </summary> /// <param name="repository">The repository.</param> /// <param name="membershipProvider">The membership provider.</param> public AuthenticationService(ISecurityRepository repository, IdentityUserSecurity membershipProvider) { MembershipProvider = membershipProvider; SecurityRepository = repository; }
/// <summary> /// Initializes a new instance of the <see cref="WebUserSecurity"/> class. /// </summary> /// <param name="securityRepository">The security repository.</param> public WebUserSecurity(ISecurityRepository securityRepository) { _securityRepository = securityRepository; LazyInitializer.EnsureInitialized(ref _initializer, ref _isInitialized, ref _initializerLock); }
/// <summary> /// Initializes a new instance of the <see cref="SecurityService"/> class. /// </summary> /// <param name="securityRepository"> /// The security repository. /// </param> public SecurityService(ISecurityRepository<User> securityRepository) { this.SecurityUserRepository = securityRepository; }
public SecurityService(ISecurityRepository securityRepository) { _securityRepository = securityRepository; }
/// <summary> /// Simple constructor to save the instance statically so the cache can be cleared /// </summary> public AuthorizeActionAttribute() : base() { _instance = this; SecurityRepository = DependencyResolver.Current.GetService<ISecurityRepository>(); }
public IdentityUserSecurity(ISecurityRepository securityRepository) { _securityRepository = securityRepository; }
private DataServiceController GetDataServiceController(IAccountRepository acct = null, ISecurityRepository sec = null, IMarketsAndNewsRepository markets = null) { var acctRepo = acct ?? new StubIAccountRepository(); var securityRepo = sec ?? new StubISecurityRepository(); var marketRepo = markets ?? new StubIMarketsAndNewsRepository(); var controller = new DataServiceController(acctRepo, securityRepo, marketRepo); return controller; }
public DataServiceController(IAccountRepository acctRepo, ISecurityRepository secRepo) { _AccountRepository = acctRepo; _SecurityRepository = secRepo; }
public UserController(ISecurityRepository repo) { this.securityEntity = repo; }
public ManageRolesController(ISecurityRepository repository) { _repository = repository; }
public SecurityBusinessComponent(ISecurityRepository unitOfWork) { this.rep = unitOfWork; }
/// <summary> /// Initializes a new instance of the <see cref="UserManager"/> class. /// </summary> /// <param name="UserRepository"> /// The user repository. /// </param> public UserManager(ISecurityRepository<User> UserRepository) { this.UserRepository = UserRepository; }