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;
}
