public AuthorizationHideForSessionFacet(IIdentifier identifier, IAuthorizationManager authorizationManager, ISpecification holder) : base(holder) { this.identifier = identifier; this.authorizationManager = authorizationManager; }
public RequestExecutionValidator(IAuthenticationManager authenticationManager, IAuthorizationManager authorizationManager, ILogger <RequestExecutionValidator> logger) { _authenticationManager = authenticationManager; _authorizationManager = authorizationManager; _logger = logger; }
/// <summary> /// Configure the authorizaion manager. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="services"></param> /// <returns></returns> public static IServiceCollection UseAuthorizationManager <T>(this IServiceCollection services) where T : class, IAuthorizationManager { IAuthorizationManager authorizationManager = Activator.CreateInstance <T>(); return(UseAuthorizationManager(services, authorizationManager)); }
public void TestSync( ) { DBHelper.Init(Settings.Default.ConnectionString); DBHelper.ExecuteNonQuery("Test_DeleteAllData"); IList <ADPrincipal> pl = GetPrincipalList( ); ADSyncHelper.SyncAdToSqlServer(pl, Settings.Default.ConnectionString, "TestAD"); IAuthorizationManager manager = Afcas.GetAuthorizationManager( ); using (new ObjectCacheScope( )) { Assert.AreEqual(5, manager.GetPrincipalList( ).Count); //removal from sql side should not matter manager.RemovePrincipal("p1"); ADSyncHelper.SyncAdToSqlServer(pl, Settings.Default.ConnectionString, "TestAD"); Assert.AreEqual(5, manager.GetPrincipalList( ).Count); } using (new ObjectCacheScope( )) { //removal from ad side ADPrincipal p1 = pl[0]; pl.RemoveAt(0); ADSyncHelper.SyncAdToSqlServer(pl, Settings.Default.ConnectionString, "TestAD"); IList <Principal> dbpl = manager.GetPrincipalList( ); Assert.AreEqual(4, dbpl.Count); Assert.That(!IsInList(p1.Name, dbpl)); Assert.That(!manager.IsMemberOf("g1", "p1")); } }
public DashboardViewModel(IDIContainer container, IAuthorizationManager authManager, INavigationService navigationService, ILocationHelper locationHelper, ILog log) { _authManager = authManager; _navigationService = navigationService; _locationHelper = locationHelper; _log = log; Client.Me().ContinueWith(t => { Me = t.Result.Response; }); Client.Vehicles().ContinueWith(t => { foreach (var v in t?.Result?.Response?.Data) { OnNext(v); } }); _vehicleObservable = Client.WatchVehicles(); _vehicleObservable.Subscribe(this); LogoutCommand = container.Resolve <IRelayCommand <object> >(); LogoutCommand.ExecuteAction = async b => { await authManager.Logout(); _navigationService.Navigate(this, "Logout", null); }; MapZoomLevel = 7; }
public ProcessingEngine( IPluginsContainer<ICommandImplementation> commandRepository, IPluginsContainer<ICommandObserver> commandObservers, ILogProvider logProvider, IPersistenceTransaction persistenceTransaction, IAuthorizationManager authorizationManager, XmlUtility xmlUtility, IUserInfo userInfo, ISqlUtility sqlUtility, ILocalizer localizer) { _commandRepository = commandRepository; _commandObservers = commandObservers; _logger = logProvider.GetLogger("ProcessingEngine"); _performanceLogger = logProvider.GetLogger("Performance"); _requestLogger = logProvider.GetLogger("ProcessingEngine Request"); _commandsLogger = logProvider.GetLogger("ProcessingEngine Commands"); _commandsResultLogger = logProvider.GetLogger("ProcessingEngine CommandsResult"); _persistenceTransaction = persistenceTransaction; _authorizationManager = authorizationManager; _xmlUtility = xmlUtility; _userInfo = userInfo; _sqlUtility = sqlUtility; _localizer = localizer; }
/// <summary> /// Initializes a new instance of the <see cref="LoginController" /> class. /// </summary> /// <param name="authenticService">The authentic service.</param> /// <param name="masterDataManager">The master data manager.</param> /// <param name="localDateTimeManager">The local date time manager.</param> /// <param name="authorizationManager">The authorization manager.</param> public LoginController(IAuthenticateManager authenticService, IMasterDataManager masterDataManager, ILocalDateTimeManager localDateTimeManager, IAuthorizationManager authorizationManager) { this.authenticationManager = authenticService; this.masterDataManager = masterDataManager; this.localDateTimeManager = localDateTimeManager; this.authorizationManager = authorizationManager; }
public override async Task OnAuthorizationAsync(HttpActionContext actionContext, CancellationToken cancellationToken) { _authorizationManager = actionContext.Request.GetDependencyScope() .GetService(typeof(IAuthorizationManager)) as IAuthorizationManager; if (!actionContext.RequestContext.Principal.Identity.IsAuthenticated) { Forbidden(actionContext, cancellationToken); } var userId = actionContext.RequestContext.Principal.Identity.GetUserId <int>(); if (userId == 0) { Forbidden(actionContext, cancellationToken); return; } if (!AccessByPermission(userId)) { Forbidden(actionContext, cancellationToken); return; } await base.OnAuthorizationAsync(actionContext, cancellationToken); }
public AccountController(IAuthorizationManager authorizationManager, IHttpContextAccessor contextAccessor, IAccountService accountService) { this.authorizationManager = authorizationManager ?? throw new ArgumentNullException(nameof(authorizationManager)); this.contextAccessor = contextAccessor ?? throw new ArgumentNullException(nameof(contextAccessor)); this.accountService = accountService ?? throw new ArgumentNullException(nameof(accountService)); }
public BackchannelAuthorizationService(IAuthorizationManager authorizationManager) { if (authorizationManager == null) { throw new ArgumentNullException(nameof(authorizationManager)); } _authorizationManager = authorizationManager; }
/// <summary> /// TokensController constructor /// </summary> /// <param name="userManager"></param> /// <param name="authorizationManager"></param> /// <param name="passwordHasher"></param> /// <param name="tokenConfiguration"></param> public TokensController(IUserManager userManager, IAuthorizationManager authorizationManager, IPasswordHasher <UserProfile> passwordHasher, ITokenConfiguration tokenConfiguration) { _userManager = userManager; _authorizationManager = authorizationManager; _passwordHasher = passwordHasher; _tokenConfiguration = tokenConfiguration; }
public CouchPotatoService(IAuthorizationManager authorizationManager,IChatBot chatBot) { _couchpotatoApiKey = ConfigurationManager.AppSettings["couchpotato_apikey"]; _couchpotatoUrl = ConfigurationManager.AppSettings["couchpotato_url"]; _userAllowedMovieIds = new Dictionary<string, List<string>>(); _authorizationManager = authorizationManager; _chatBot = chatBot; }
public ActivityProgramController( IActivityProgramServices AapServices, IAuthorizationManager authorizationManager) { _AapServices = AapServices; _viewModelMapperHelper = new ViewModelMapperHelper(_AapServices); _authorizationManager = authorizationManager; }
public GenericApplication(IUnitOfWork unitOfWork, IAuditTrailManager auditTrailManager, IAuthorizationManager authorizationManager) { UnitOfWork = unitOfWork; AuditTrailManager = auditTrailManager; AuthorizationManager = authorizationManager; }
public MessengerService() { _passwordHasher = new PasswordHasher(); _requestHelper = new RequestHelper(); _authorizationManager = new AuthorizationManager(); _rsa = new Rsa(); _session = _requestHelper.GetCurrentSession(); ImportRsaKey(); }
public ChatClient(IAuthorizationManager authorizationManager, IUserManager userManager, IMessageManager messageManager, IRelationManager relationManager) { _authorizationManager = authorizationManager; _userManager = userManager; _messageManager = messageManager; _relationManager = relationManager; }
public static IAuthorizationManager GetAuthorizationManager( ) { lock ( SyncRoot ) { if (_AuthManager == null) { _AuthManager = new AuthorizationManager( ); } return(_AuthManager); } }
private UserService Target(DatabaseContext context, IAuthorizationManager auth) { return(new UserService( userRepository: new UserRepository(context, AutomapperSingleton.Mapper), authorizationManager: auth, emailDomainValidatorService: new EmailDomainValidatorService("gmail.com|hipo.kz"), emailSender: new EmailSender(new SendGridClientFake()), viewRenderer: new ViewRendererFake(), baseUrls: new BaseUrls(_config))); }
public UserEmail( IEmailSender emailSender, IViewRenderer viewRenderer, IAuthorizationManager authManager, IBaseUrls urls) { emailSender.ThrowIfNull(nameof(emailSender)); viewRenderer.ThrowIfNull(nameof(viewRenderer)); _emailSender = emailSender; _viewRenderer = viewRenderer; _authManager = authManager; _urls = urls; }
public ApiClient(IAuthorizationManager authMgr, IClientManager clientMgr) { _authMgr = authMgr; _clientMgr = clientMgr; _client = new HttpClient { BaseAddress = new Uri(BASE_URI), }; _client.DefaultRequestHeaders.Add(API_KEY_HEADER, API_KEY); }
public ContactsController(IOperationContactsService operationContactsService, ICatalogService catalogService, IAuthorizationManager authorizationManager) { _operationContactsService = operationContactsService; _catalogService = catalogService; _authorizationManager = authorizationManager; _viewModelMapperHelper = new ViewModelMapperHelper(_operationContactsService, _catalogService); }
public EmailService( IEmailSender emailSender, IAuthorizationManager authManager, IViewRenderer viewRenderer, IBaseUrls url) { _emailSender = emailSender; _authManager = authManager; _view = viewRenderer; _url = url; }
/// <summary> /// Initializes a new instance of the <see cref="BasicAuthenticationBehavior"/> class. /// </summary> /// <param name="authorizationManager">The authorization manager.</param> public BasicAuthenticationBehavior(IAuthorizationManager authorizationManager) { if (authorizationManager == null) { throw new HttpResponseException(HttpStatusCode.InternalServerError, Resources.Global.MissingAuthorizationManager); } m_authorizationManager = authorizationManager; RequiresSsl = true; }
/// <summary> /// Initializes a new instance of the <see cref="DigestAuthenticationBehavior"/> class. /// </summary> /// <param name="authorizationManager">The authorization manager.</param> public DigestAuthenticationBehavior(IAuthorizationManager authorizationManager) { if (authorizationManager == null) { throw new HttpResponseException(HttpStatusCode.InternalServerError, Resources.Global.MissingAuthorizationManager); } NonceLifetime = TimeSpan.FromSeconds(DefaultNonceLifeTimeInSeconds); Qop = QualityOfProtection.Auth; m_authorizationManager = authorizationManager; m_encoder = new MD5Encoder(); m_encryptor = new RijndaelEncryptor(); }
public ProcessingEngine( IPluginsContainer<ICommandImplementation> commandRepository, IPluginsContainer<ICommandObserver> commandObservers, ILogProvider logProvider, IPersistenceTransaction persistenceTransaction, IAuthorizationManager authorizationManager) { _commandRepository = commandRepository; _commandObservers = commandObservers; _logger = logProvider.GetLogger("ProcessingEngine"); _performanceLogger = logProvider.GetLogger("Performance"); _persistenceTransaction = persistenceTransaction; _authorizationManager = authorizationManager; }
private void EnsureAuthZManager(HttpActionContext actionContext) { if (_authZType == null) { return; } if (_authZ == null) { var type = actionContext.ControllerContext.Configuration.DependencyResolver.GetService(_authZType) as IAuthorizationManager; if (type != null) { _authZ = type; } else { _authZ = Activator.CreateInstance(_authZType) as IAuthorizationManager; } } }
public override void SetAuthorizationManager(IAuthorizationManager newAuthorizationManager) { throw new NotImplementedException(); }
public AuthenticationController(IAuthenticationManagement authenticationManagement, IAuthorizationManager authorizationManager) { _authenticationManagement = authenticationManagement; _authorizationManager = authorizationManager; }
public AuthorizationService(IChatBot chatBot, IAuthorizationManager authorizationManager) { _chatBot = chatBot; _authorizationManager = authorizationManager; }
public AuthorizationActionFilter(IAuthorizationManager authorizationManagement) { _authorizationManagement = authorizationManagement; }
/// <summary> /// Constructs an instance of the KeyProvider_ZpaServer class. /// </summary> /// <param name="zpaFeatureFlags">The requested security options.</param> /// <param name="iAuthorizationManager">The password provider.</param> public KeyProvider_ZpaServer(ZpaFeatureFlags zpaFeatureFlags, IAuthorizationManager iAuthorizationManager) { this._zpaFeatureFlags = zpaFeatureFlags; this._iAuthorizationManager = iAuthorizationManager; }
/// <summary> /// </summary> /// <param name="defaultAuthorizer">This will be used unless the object is recognised by one of the namespaceAuthorizers</param> public CustomAuthorizerInstaller(ITypeAuthorizer<object> defaultAuthorizer, params INamespaceAuthorizer[] namespaceAuthorizers) { authManager = new CustomAuthorizationManager(defaultAuthorizer, namespaceAuthorizers); }
public SecurityFacetDecorator(IAuthorizationManager manager) { this.manager = manager; }
public abstract void SetAuthorizationManager(IAuthorizationManager newAuthorizationManager);
private static BasicAuthenticationBehavior CreateBehavior(IAuthorizationManager authorizationManager = null, bool isSecure = true) { BasicAuthenticationBehavior behavior = authorizationManager != null ? new BasicAuthenticationBehavior(authorizationManager) : new BasicAuthenticationBehavior(); behavior.LoadBalancerSupport = isSecure; // simulates HTTPS protocol return behavior; }
public override void SetAuthorizationManager(IAuthorizationManager newAuthorizationManager) { authorizationManager = newAuthorizationManager; }
public CustomAuthorizerInstaller(ITypeAuthorizer<object> defaultAuthorizer) { authManager = new CustomAuthorizationManager(defaultAuthorizer); }
public static void SetAuthorizationManager(this HttpConfiguration configuration, IAuthorizationManager manager) { configuration.Properties[ApiAuthorizeAttribute.PropertyName] = manager; }
/// <summary> /// Sets basic authentication for the service proxy and authorizes users through the provided authorization manager /// instance. /// </summary> /// <param name="authorizationManager">The authorization manager.</param> /// <returns>The configuration object.</returns> public ProxyConfiguration RequireAuthorization(IAuthorizationManager authorizationManager) { if (authorizationManager == null) { throw new ArgumentNullException("authorizationManager"); } Rest.Configuration.Options.ServiceProxyAuthorizationManager = authorizationManager; return this; }
public AuthorizationBehavior(IAuthorizationManager authorizationManager) { this.authorizationManager = authorizationManager; }
/// <summary> /// </summary> /// <param name="defaultAuthorizer">This will be used unless the object type exactly matches one of the typeauthorizers</param> /// <param name="typeAuthorizers">Each authorizer must implement ITypeAuthorizer for a concrete domain type</param> public CustomAuthorizerInstaller(ITypeAuthorizer<object> defaultAuthorizer, params object[] typeAuthorizers) { authManager = new CustomAuthorizationManager(defaultAuthorizer, typeAuthorizers); }