public AuthorizationController(IAuthorizationRepository authorizeRepository, IMapper mapper, IHashingService hashingService, ITokenService tokenService) { this.authorizeRepository = authorizeRepository; this.mapper = mapper; this.hashingService = hashingService; this.tokenService = tokenService; }
public AuthorizationService(IAuthorizationRepository authRepo, IMapper mapper, IConfiguration config) { this.config = config; this.mapper = mapper; this.authRepo = authRepo; }
private void SetupEntities() { user = new User { Name = "Ayende" }; account = new Account { Name = "south sand" }; session.Save(user); session.Save(account); authorizationService = ServiceLocator.Current.GetInstance <IAuthorizationService>(); permissionService = ServiceLocator.Current.GetInstance <IPermissionsService>(); permissionsBuilderService = ServiceLocator.Current.GetInstance <IPermissionsBuilderService>(); authorizationRepository = ServiceLocator.Current.GetInstance <IAuthorizationRepository>(); authorizationRepository.CreateUsersGroup("Administrators"); authorizationRepository.CreateEntitiesGroup("Important Accounts"); authorizationRepository.CreateOperation("/Account/Edit"); authorizationRepository.CreateOperation("/Account/Disable"); authorizationRepository.AssociateUserWith(user, "Administrators"); authorizationRepository.AssociateEntityWith(account, "Important Accounts"); }
/// <summary> /// Counstructor /// </summary> /// <param name="fastFoodDbContext">FastFoodDbContext - Injection</param> /// <param name="foodRepository">FoodRepository - Injection</param> /// <param name="paymentRepository">PaymentRepository - Injection</param> /// <param name="userRepository">UserRepository - Injection</param> /// <param name="paymentMethodRepository">PaymentMethodRepository - Injection</param> /// <param name="sentEmailRepository">SentEmailRepository - Injection</param> /// <param name="sentMessageRepository">SentMessageRepository - Injection</param> /// <param name="authorizationRepository">AuthorizationRepository - Injection</param> public UnitOfWork ( FastFoodDbContext fastFoodDbContext, IFoodRepository foodRepository, IPaymentRepository paymentRepository, IUserRepository userRepository, IPaymentMethodRepository paymentMethodRepository, ISentEmailRepository sentEmailRepository, ISentMessageRepository sentMessageRepository, IAuthorizationRepository authorizationRepository ) { _fastFoodDbContext = fastFoodDbContext; FoodRepository = foodRepository; PaymentRepository = paymentRepository; UserRepository = userRepository; PaymentMethodRepository = paymentMethodRepository; SentEmailRepository = sentEmailRepository; SentMessageRepository = sentMessageRepository; AuthorizationRepository = authorizationRepository; // Setup the DbContext FoodRepository.DbContext = _fastFoodDbContext; PaymentRepository.DbContext = _fastFoodDbContext; UserRepository.DbContext = _fastFoodDbContext; PaymentMethodRepository.DbContext = _fastFoodDbContext; SentEmailRepository.DbContext = _fastFoodDbContext; SentMessageRepository.DbContext = _fastFoodDbContext; AuthorizationRepository.DbContext = _fastFoodDbContext; }
public CheckAccessFunctions(ITokenValidator tokenValidator, IJsonHttpContentValidator jsonHttpContentValidator, IMicrosoftGraphRepository microsoftGraphRepository, IAuthorizationRepository authorizationRepository) { this.tokenValidator = tokenValidator ?? throw new ArgumentNullException(nameof(tokenValidator)); this.jsonHttpContentValidator = jsonHttpContentValidator ?? throw new ArgumentNullException(nameof(jsonHttpContentValidator)); this.microsoftGraphRepository = microsoftGraphRepository ?? throw new ArgumentNullException(nameof(microsoftGraphRepository)); this.authorizationRepository = authorizationRepository ?? throw new ArgumentNullException(nameof(authorizationRepository)); }
public AuthorizationValidation(IHttpContextAccessor contextAccessor, IAuthorizationRepository authorizationRepository, IPersonRepository personRepository) : base(contextAccessor) { _authorizationRepository = authorizationRepository; _personRepository = personRepository; }
public AddAuthorizationRoleCommandHandler(IRoleRepository roleRepository, IAuthorizationRepository authorizationRepository) { _authorizationRepository = authorizationRepository ?? throw new ArgumentNullException(nameof(authorizationRepository)); _roleRepository = roleRepository ?? throw new ArgumentNullException(nameof(roleRepository)); }
public static async Task <IStatusGeneric <RoleToPermissions> > CreateRoleWithPermissionsAsync( string roleName, string description, IEnumerable <Permission> permissionInRole, IAuthorizationRepository repository) { if (roleName == null) { throw new ArgumentNullException(nameof(roleName)); } if (repository == null) { throw new ArgumentNullException(nameof(repository)); } var status = new StatusGenericHandler <RoleToPermissions>(); RoleToPermissions roleToPermissions = await repository.GetRoleToPermissionAsync(roleName); if (roleToPermissions != null) { status.AddError("That role already exists"); return(status); } return(status.SetResult(new RoleToPermissions(roleName, description, permissionInRole))); }
public static IAuthorizationRepository GetAuthorizationRepo() { if (authRepo == null) authRepo = new AuthorizationRepository(); return authRepo; }
private void SetupEntities() { user = new User(); user.Name = "Ayende"; account = new Account(); account.Name = "south sand"; UnitOfWork.CurrentSession.Save(user); UnitOfWork.CurrentSession.Save(account); authorizationService = IoC.Resolve<IAuthorizationService>(); permissionService = IoC.Resolve<IPermissionsService>(); permissionsBuilderService = IoC.Resolve<IPermissionsBuilderService>(); authorizationRepository = IoC.Resolve<IAuthorizationRepository>(); authorizationRepository.CreateUsersGroup("Administrators"); authorizationRepository.CreateEntitiesGroup("Important Accounts"); authorizationRepository.CreateOperation("/Account/Edit"); UnitOfWork.Current.TransactionalFlush(); authorizationRepository.AssociateUserWith(user, "Administrators"); authorizationRepository.AssociateEntityWith(account, "Important Accounts"); UnitOfWork.Current.TransactionalFlush(); }
public AuthorizationService( IAuthorizationRepository repository, IConfiguration configuration ) { _repository = repository; _configuration = configuration; }
public RoleService(IMapper mapper, IRoleRepository repository, IAuthorizationRepository authorizationRep) { this.mapper = mapper; this.repository = repository; this.authorizationRep = authorizationRep; CheckAuthorization(); }
public UserGroupListController(IDynamicExpressionQuery dynamicExpressionQuery, IAuthorizationRepository authorizationRepository, IEntityListGrid<UserGroupDto> grid) { _dynamicExpressionQuery = dynamicExpressionQuery; _authorizationRepository = authorizationRepository; _grid = grid; }
public AddPermissionsToUserClaimsFactory( UserManager <IdentityUser> userManager, IOptions <IdentityOptions> optionsAccessor, IAuthorizationRepository repository) : base(userManager, optionsAccessor) { _repository = repository ?? throw new ArgumentNullException(nameof(repository)); }
/// <summary> /// 获取权限系统存储服务 /// </summary> /// <returns></returns> public static IAuthorizationRepository GetAuthorizationRepository() { Initialize(); if (_azRepository == null) { _azRepository = System.Activator.CreateInstance(Type.GetType(_azRepositoryType), _config) as IAuthorizationRepository; } return(_azRepository); }
/// <summary> /// 获取权限系统存储服务 /// </summary> /// <returns></returns> public static IAuthorizationRepository GetAuthorizationRepository() { Initialize(); if (_azRepository == null) { _azRepository = System.Activator.CreateInstance(Type.GetType(_azRepositoryType),_config) as IAuthorizationRepository; } return _azRepository; }
public UserGroupPermissionListController(IDynamicExpressionQuery dynamicExpressionQuery, IPermissionsService permissionsService, IAuthorizationRepository authorizationRepository) { _dynamicExpressionQuery = dynamicExpressionQuery; _grid = ObjectFactory.Container.GetInstance<IEntityListGrid<PermissionDto>>("group"); _permissionsService = permissionsService; _authorizationRepository = authorizationRepository; }
public SessionAuthenticationHandler( IOptionsMonitor <AuthenticationSchemeOptions> options, ILoggerFactory logger, UrlEncoder encoder, ISystemClock clock, IAuthorizationRepository authorizationRepository) : base(options, logger, encoder, clock) { _authorizationRepository = authorizationRepository; }
public OrderRepository( IOrderAuthorizationRepository orderAuthorizationRepository, IAuthorizationRepository authorizationRepository, AcmeContext context) : base(context) { OrderAuthorizationRepository = orderAuthorizationRepository ?? throw new ArgumentNullException(nameof(orderAuthorizationRepository)); AuthorizationRepository = authorizationRepository ?? throw new ArgumentNullException(nameof(authorizationRepository)); }
public UserListController(IDynamicExpressionQuery dynamicExpressionQuery, IEntityListGrid<UserLoginInfo> grid, IRepository repository, IAuthorizationRepository authorizationRepository) { _dynamicExpressionQuery = dynamicExpressionQuery; _grid = grid; _repository = repository; _authorizationRepository = authorizationRepository; }
public AuthorizationLogic(IAuthorizationRepository authorizationRepository, IConfiguration configuration, IHttpContextAccessor contextAccessor, IPushNotificationService pushNotificationService) { _authorizationRepository = authorizationRepository; _configuration = configuration; _contextAccessor = contextAccessor; _pushNotificationService = pushNotificationService; }
public InvoiceApplicationService( IAuthorizationRepository authorizationRepository, IInvoiceRepository invoiceRepository, IUnitOfWork unitOfWork, IDateService dateService) { _authorizationRepository = authorizationRepository; _invoiceRepository = invoiceRepository; _unitOfWork = unitOfWork; _dateService = dateService; }
public AccountController( IAuthorizationRepository repository, UserManager <IdentityUser> userManager, SignInManager <IdentityUser> signInManager, IEmailSender emailSender, ILogger <AccountController> logger) : base(logger) { _repository = repository; _userManager = userManager; _signInManager = signInManager; _emailSender = emailSender; }
public PermissionController(IRepository repository, IPermissionsService permissionsService, IAuthorizationRepository authorizationRepository, IPermissionsBuilderService permissionsBuilderService, ISelectListItemService selectListItemService) { _repository = repository; _permissionsService = permissionsService; _authorizationRepository = authorizationRepository; _permissionsBuilderService = permissionsBuilderService; _selectListItemService = selectListItemService; }
public UserController( IRepository repository, ISaveEntityService saveEntityService, ISecurityDataService securityDataService, ISelectListItemService selectListItemService, IAuthorizationRepository authorizationRepository) { _repository = repository; _saveEntityService = saveEntityService; _securityDataService = securityDataService; _selectListItemService = selectListItemService; _authorizationRepository = authorizationRepository; }
public async Task <int> GetUserId(HttpRequest req) { AuthGUID authGUID = await GetGUIDAsync(req); if (!authGUID.Acces || authGUID.GUID == "") { return(0); } IAuthorizationRepository authRepository = DIContainer.Instance.GetService <IAuthorizationRepository>(); return(authRepository.GetUserId(authGUID.GUID, false)); }
public ChallengeService(IChallengeRepository challengeRepository, IAuthorizationRepository authorizationRepository, IAccountService accountService, IOptions <ServerOptions> options) : base(options) { ChallengeRepository = challengeRepository ?? throw new ArgumentNullException(nameof(challengeRepository)); AuthorizationRepository = authorizationRepository ?? throw new ArgumentNullException(nameof(authorizationRepository)); AccountService = accountService ?? throw new ArgumentNullException(nameof(accountService)); }
public HomeController( Microsoft.AspNetCore.Identity.UserManager <IdentityUser> userManager, SignInManager <IdentityUser> signInManager, ILogger <RegisterModel> logger, IEmailSender emailSender, ApplicationDbContext DB, IAuthorizationRepository authorization) { _userManager = userManager; _signInManager = signInManager; _logger = logger; _emailSender = emailSender; this.dbContext = DB; this.authorizationRepository = authorization; }
public async Task <AuthResultModel> AuthForDoctorOrPatient(HttpRequest req, int userId) { AuthGUID authGUID = await GetGUIDAsync(req); if (!authGUID.Acces || authGUID.GUID == "") { return(new AuthResultModel(false, AuthStatusCode.Unauthorized)); } IAuthorizationRepository authRepository = DIContainer.Instance.GetService <IAuthorizationRepository>(); return(authRepository.HasAcces(userId, authGUID.GUID) ? new AuthResultModel(true, AuthStatusCode.Ok) : new AuthResultModel(false, AuthStatusCode.Forbidden)); }
protected override void SetUp() { base.SetUp(); var currentConversation = ServiceLocator.Current.GetInstance<IConversation>(); using (currentConversation.SetAsCurrent()) { _authZRepo = ServiceLocator.Current.GetInstance<AuthorizationRepositoryFactory>().Create(); _userRepository = ServiceLocator.Current.GetInstance<UserRepository>(); _permissionBuilderService = ServiceLocator.Current.GetInstance<PermissionsBuilderServiceFactory>().Create(); _seniorUser = _userRepository.Create(new User { Name = "Senior" }); _juniorUser = _userRepository.Create(new User { Name = "Junior" }); _seniorMgrs = _authZRepo.CreateUsersGroup("Senior Managers"); _juniorMgrs = _authZRepo.CreateUsersGroup("Junior Managers"); _op4Senior = _authZRepo.CreateOperation("/Operation/ForSenior"); currentConversation.Flush(); _op4Junior = _authZRepo.CreateOperation("/Operation/ForJunior"); _authZRepo.AssociateUserWith(_seniorUser, _seniorMgrs); _authZRepo.AssociateUserWith(_juniorUser, _juniorMgrs); _permissionBuilderService .Allow(_op4Junior) .For(_juniorMgrs) .OnEverything() .DefaultLevel() .Save(); _permissionBuilderService .Deny(_op4Senior) .For(_juniorMgrs) .OnEverything() .DefaultLevel() .Save(); _permissionBuilderService .Allow(_op4Senior) .For(_seniorMgrs) .OnEverything() .DefaultLevel() .Save(); currentConversation.Flush(); } _targetController = ServiceLocator.Current.GetInstance<PermissionController>(); }
public HomeController( Microsoft.AspNetCore.Identity.UserManager <IdentityUser> userManager, SignInManager <IdentityUser> signInManager, ILogger <RegisterModel> logger, IEmailSender emailSender, IAuthorizationRepository authorization, IPatientsRepository patients, ITemporaryPatientsRepository temporaryPatients, ITurnsRepository turns) { _userManager = userManager; _signInManager = signInManager; _logger = logger; _emailSender = emailSender; this.authorizationRepository = authorization; this.patientsRepository = patients; this.temporaryPatientsRepository = temporaryPatients; this.turnsRepository = turns; }
public async Task <AuthResultModel> AuthForDoctor(HttpRequest req, int doctorId) { AuthGUID authGUID = await GetGUIDAsync(req); if (!authGUID.AuthResult.Result) { return(authGUID.AuthResult); } IAuthorizationRepository authRepository = DIContainer.Instance.GetService <IAuthorizationRepository>(); if (authRepository.UserAuth(doctorId, authGUID.GUID, true)) { return(new AuthResultModel(true, AuthStatusCode.Ok)); } return(new AuthResultModel(false, AuthStatusCode.Forbidden)); }
public ConverterService( IAuthorizationRepository authorizationRepository, IChallengeRepository challengeRepository, IOrderAuthorizationRepository orderAuthorizationRepository, IExternalAccountRepository externalAccountRepository, IOptions <ServerOptions> options) : base(options) { AuthorizationRepository = authorizationRepository ?? throw new ArgumentNullException(nameof(authorizationRepository)); ChallengeRepository = challengeRepository ?? throw new ArgumentNullException(nameof(challengeRepository)); OrderAuthorizationRepository = orderAuthorizationRepository ?? throw new ArgumentNullException(nameof(orderAuthorizationRepository)); ExternalAccountRepository = externalAccountRepository ?? throw new ArgumentNullException(nameof(externalAccountRepository)); }
/** * Authorization Check for every call */ public async Task <AuthResultModel> CheckAuthorization(HttpRequest req, int userId = 0, bool isDoctor = false) { // Get AuthentificationHeader from request AuthenticationHeaderValue.TryParse(req.Headers[HeaderNames.Authorization], out var authHeader); if (authHeader == null) { return(new AuthResultModel(false, AuthStatusCode.Unauthorized)); } // Token validation with Auth0 servers ClaimsPrincipal claims = await Auth0.ValidateTokenAsync(authHeader); if (claims == null) { return(new AuthResultModel(false, AuthStatusCode.Unauthorized)); } // Get Token Guid for Authorization string tokenGuid = claims.FindFirst("http://schemas.xmlsoap.org/ws/2005/05/identity/claims/nameidentifier").Value; IAuthorizationRepository authRepository = DIContainer.Instance.GetService <IAuthorizationRepository>(); // If userId needs to come from token, only calls the method GetAccountId if userId is zero if (userId == 0 && authRepository.GetUserId(tokenGuid, isDoctor) == 0) { return(new AuthResultModel(false, AuthStatusCode.Forbidden)); } // When a call is from a Doctor that needs info about a patient, the following method will be called // UserId is here patientId if (isDoctor && authRepository.CheckDoctorAcces(userId, tokenGuid)) { return(new AuthResultModel(true, AuthStatusCode.Ok)); } // When a call is from a patient of doctor and only ask for information about the same user the following method will be called if (userId != 0 && !authRepository.UserAuth(userId, tokenGuid, isDoctor)) { return(new AuthResultModel(false, AuthStatusCode.Forbidden)); } return(new AuthResultModel(true, AuthStatusCode.Ok)); }
public async Task <IStatusGeneric> DeleteRoleAsync( string roleName, bool isRemoveFromUsers, IAuthorizationRepository repository) { if (repository == null) { throw new ArgumentNullException(nameof(repository)); } var status = new StatusGenericHandler { Message = "Deleted role successfully." }; RoleToPermissions roleToUpdate = await repository.GetRoleToPermissionAsync(roleName); if (roleToUpdate == null) { return(status.AddError("That role doesn't exists")); } ICollection <UserToRole> usersWithRoles = await repository.GetUsersToRoleByNameAsync(roleName); if (usersWithRoles.Any()) { if (!isRemoveFromUsers) { return(status.AddError($"That role is used by {usersWithRoles.Count} and you didn't ask for them to be updated.")); } await repository.DeleteAsync(usersWithRoles); status.Message = $"Removed role from {usersWithRoles.Count} user and then deleted role successfully."; } await repository.DeleteAsync(roleToUpdate); return(status); }
public static async Task <IStatusGeneric <UserToRole> > AddRoleToUserAsync( string userId, string roleName, IAuthorizationRepository repository) { if (userId == null) { throw new ArgumentNullException(nameof(userId)); } if (roleName == null) { throw new ArgumentNullException(nameof(roleName)); } if (repository == null) { throw new ArgumentNullException(nameof(repository)); } var status = new StatusGenericHandler <UserToRole>(); UserToRole userToRole = await repository.GetUserToRoleAsync(userId, roleName); if (userToRole != null) { status.AddError($"The user already has the Role '{roleName}'."); return(status); } RoleToPermissions roleToAdd = await repository.GetRoleToPermissionAsync(roleName); if (roleToAdd == null) { status.AddError($"Could not find the Role '{roleName}'."); return(status); } return(status.SetResult(new UserToRole(userId, roleToAdd))); }
public RihnoRoleProvider() { var cfg = new Configuration() .SetProperty(Environment.ConnectionDriver, typeof(Sql2008ClientDriver).AssemblyQualifiedName) .SetProperty(Environment.Dialect, typeof(MsSql2008Dialect).AssemblyQualifiedName) .SetProperty(Environment.ConnectionString, Storage.RhinoConnectionString)//ConfigurationManager.AppSettings["RhinoSecurity.ConnectionString"]) amit 23052017 .SetProperty(Environment.ReleaseConnections, "on_close") .SetProperty(Environment.UseSecondLevelCache, "true") .SetProperty(Environment.UseQueryCache, "true") .SetProperty(Environment.CacheProvider, typeof(HashtableCacheProvider).AssemblyQualifiedName) .AddAssembly(typeof(AMS.Broker.DataStore.User).Assembly); Security.Configure <AMS.Broker.DataStore.User>(cfg, SecurityTableStructure.Prefix); Factory = cfg.BuildSessionFactory(); Session = Factory.OpenSession(); Session.FlushMode = FlushMode.Always; AuthRepository = new AuthorizationRepository(Session); PermissionsBuilderService = new PermissionsBuilderService(Session, AuthRepository); PermissionService = new PermissionsService(AuthRepository, Session); AuthorizationService = new AuthorizationService(PermissionService, AuthRepository); }
/// <summary> /// Initializes a new instance of the <see cref="PermissionsService"/> class. /// </summary> /// <param name="authorizationRepository">The authorization editing service.</param> /// <param name="session">The NHibernate session</param> public PermissionsService(IAuthorizationRepository authorizationRepository, ISession session) { this.authorizationRepository = authorizationRepository; this.session = session; }
public AuthorizationService() { _repository = new AuthorizationRepository(_context); }
public PermissionsController(IRepository repository,IPermissionsService permissionsService,IAuthorizationRepository authorizationRepository) { _repository = repository; _permissionsService = permissionsService; _authorizationRepository = authorizationRepository; }
/// <summary> /// Initializes a new instance of the <see cref="AuthorizationService"/> class. /// </summary> /// <param name="permissionsService">The permissions service.</param> /// <param name="authorizationRepository">The authorization editing service.</param> public AuthorizationService(IPermissionsService permissionsService, IAuthorizationRepository authorizationRepository) { this.permissionsService = permissionsService; this.authorizationRepository = authorizationRepository; }
private void SetupEntities() { user = new User {Name = "Ayende"}; account = new Account {Name = "south sand"}; session.Save(user); session.Save(account); authorizationService = ServiceLocator.Current.GetInstance<IAuthorizationService>(); permissionService = ServiceLocator.Current.GetInstance<IPermissionsService>(); permissionsBuilderService = ServiceLocator.Current.GetInstance<IPermissionsBuilderService>(); authorizationRepository = ServiceLocator.Current.GetInstance<IAuthorizationRepository>(); authorizationRepository.CreateUsersGroup("Administrators"); authorizationRepository.CreateEntitiesGroup("Important Accounts"); authorizationRepository.CreateOperation("/Account/Edit"); authorizationRepository.AssociateUserWith(user, "Administrators"); authorizationRepository.AssociateEntityWith(account, "Important Accounts"); }
/// <summary> /// Initializes a new instance of the <see cref="PermissionsBuilderService"/> class. /// </summary> /// <param name="session">The nhibernate session</param> /// <param name="authorizationRepository">The authorization editing service.</param> public PermissionsBuilderService(ISession session, IAuthorizationRepository authorizationRepository) { this.session = session; this.authorizationRepository = authorizationRepository; }
public void TestFixtureSetUp() { ServiceLocatorImpl = Init(); AuthZRepository = ServiceLocator.Current.GetInstance<IAuthorizationRepository>(); AuthZService = ServiceLocator.Current.GetInstance<IAuthorizationService>(); }
/// <summary> /// Initializes the controller with dependency injection. /// </summary> /// <param name="dashParam">Implementation of IDashboardRepository.</param> /// <param name="authParam">Implementation of IAuthorizationRepository.</param> public DashboardController(IDashboardRepository dashParam, IAuthorizationRepository authParam, ISiteSettingRepository siteParam) { repo = dashParam; authRepo = authParam; site = siteParam; }
public UserGroupController(IAuthorizationRepository authorizationRepository, IRepository repository) { _authorizationRepository = authorizationRepository; _repository = repository; }