public AccountController(ICarServices carServices, IRoleProvider roleProvider, ICarProvider carProvider, IImageProccessorServices imageProccessorServices)
{
this.carServices = carServices;
this.roleProvider = roleProvider;
this.carProvider = carProvider;
this.imageProccessorServices = imageProccessorServices;
}
public AdminController(
IAuthorizationService authorizationService,
ITypeFeatureProvider typeFeatureProvider,
ISession session,
IStringLocalizer<AdminController> stringLocalizer,
IHtmlLocalizer<AdminController> htmlLocalizer,
ISiteService siteService,
IShapeFactory shapeFactory,
RoleManager<Role> roleManager,
IRoleProvider roleProvider,
INotifier notifier,
IEnumerable<IPermissionProvider> permissionProviders
)
{
TH = htmlLocalizer;
_notifier = notifier;
_roleProvider = roleProvider;
_typeFeatureProvider = typeFeatureProvider;
_permissionProviders = permissionProviders;
_roleManager = roleManager;
_shapeFactory = shapeFactory;
_siteService = siteService;
T = stringLocalizer;
_authorizationService = authorizationService;
_session = session;
}
public AzManager(IRoleProvider roleProvider, IPermissionProvider permissionProvider)
: this()
{
if (roleProvider == null) throw new ArgumentNullException("roleProvider");
if (permissionProvider == null) throw new ArgumentNullException("permissionProvider");
this.roleProvider = roleProvider;
this.permissionProvider = permissionProvider;
}
public bool CanCreate()
{
IRoleProvider perms = this.AuthProvider;
if (perms != null)
{
if (this.Context != null && this.Context.User != null)
{
return(perms.HasPermission(this.Context.User, EntityBundleUtils.EntityBundleCreatePermission));
}
}
return(false);
}
public bool CanUpdate()
{
IRoleProvider perms = this.AuthProvider;
if (perms != null)
{
if (this.Context != null && this.Context.User != null)
{
return(perms.HasPermission(this.Context.User, SiteProviderFactoryBase.SiteAliasSchemeUpdatePermission));
}
}
return(false);
}
public bool CanUpdate()
{
IRoleProvider perms = this.AuthProvider;
if (perms != null)
{
if (this.Context != null && this.Context.User != null)
{
return(perms.HasPermission(this.Context.User, PersonUpdatePermission));
}
}
return(false);
}
public bool CanAdd()
{
IRoleProvider perms = this.AuthProvider;
if (perms != null)
{
if (this.Context != null && this.Context.User != null)
{
return(perms.HasPermission(this.Context.User, UserAffiliationProviderFactoryBase.UserAffiliationAddPermission));
}
}
return(false);
}
public bool CanGet()
{
IRoleProvider perms = this.AuthProvider;
if (perms != null)
{
if (this.Context != null && this.Context.User != null)
{
return(perms.HasPermission(this.Context.User, FishModuleUtils.FishGetPermission));
}
}
return(false);
}
public bool CanDelete()
{
IRoleProvider perms = this.AuthProvider;
if (perms != null)
{
if (this.Context != null && this.Context.User != null)
{
return(perms.HasPermission(this.Context.User, WQModuleUtils.WQDeletePermission));
}
}
return(false);
}
public bool CanGet()
{
IRoleProvider perms = this.AuthProvider;
if (perms != null)
{
if (this.Context != null && this.Context.User != null)
{
return(perms.HasPermission(this.Context.User, InstrumentProviderFactoryBase.InstrumentFamilyGetPermission));
}
}
return(false);
}
public bool CanUpdate()
{
IRoleProvider perms = this.AuthProvider;
if (perms != null)
{
if (this.Context != null && this.Context.User != null)
{
return(perms.HasPermission(this.Context.User, TaxonomyProviderFactoryBase.TaxaUnitUpdatePermission));
}
}
return(false);
}
public override bool CanRemove()
{
IRoleProvider perms = this.AuthProvider;
if (perms != null)
{
if (this.Context != null && this.Context.User != null)
{
return(perms.HasPermission(this.Context.User, OrganizationHierarchyProviderFactoryBase.OrganizationHierarchyMembershipRemovePermission));
}
}
return(false);
}
public bool CanUpdate()
{
IRoleProvider perms = this.AuthProvider;
if (perms != null)
{
if (this.Context != null && this.Context.User != null)
{
return(perms.HasPermission(this.Context.User, InstrumentProviderFactoryBase.SensorTypeUpdatePermission));
}
}
return(false);
}
public bool CanDelete()
{
IRoleProvider perms = this.AuthProvider;
if (perms != null)
{
if (this.Context != null && this.Context.User != null)
{
return(perms.HasPermission(this.Context.User, ProjectProviderFactoryBase.ProjectDeletePermission));
}
}
return(false);
}
public bool CanGet()
{
IRoleProvider perms = this.AuthProvider;
if (perms != null)
{
if (this.Context != null && this.Context.User != null)
{
return(perms.HasPermission(this.Context.User, OrganizationProviderFactoryBase.OrganizationGetPermission));
}
}
return(false);
}
public async Task <ActionResult <RoleMetadata> > Create([FromBody] RoleMetadata data)
{
try
{
IRoleProvider res = await _workspace.Roles.Create(data);
return(Created($"users/{res.Id}", await res.GetMetadata()));
}
catch
{
return(Forbid());
}
}
public async Task <ActionResult <RoleMetadata> > GetByName(string name)
{
IRoleProvider res = await _workspace.Roles.GetByName(name);
if (res != null)
{
return(Ok(await res.GetMetadata()));
}
else
{
return(NotFound());
}
}
public bool CanUpdate()
{
IRoleProvider perms = this.AuthProvider;
if (perms != null)
{
if (this.Context != null && this.Context.User != null)
{
return(perms.HasPermission(this.Context.User, FieldActivityProviderFactoryBase.FieldActivityUpdatePermission));
}
}
return(false);
}
/// <summary>
/// Initializes a new instance of the <see cref="AccountController" /> class.
/// </summary>
/// <param name="userVerificationService">The user verification service.</param>
/// <param name="registrationService">The registration service.</param>
/// <param name="profileService">The profile service.</param>
/// <param name="roleProvider">The role provider.</param>
/// <param name="sessionStateService">The session state service.</param>
/// <param name="registerFactory">The register factory.</param>
public AccountController(IUserVerificationService userVerificationService,
IRegistrationService registrationService,
IProfileService profileService,
IRoleProvider roleProvider,
ISessionStateService sessionStateService,
IRegisterFactory registerFactory)
{
this.userVerificationService = userVerificationService;
this.registrationService = registrationService;
this.profileService = profileService;
this.roleProvider = roleProvider;
this.sessionService = sessionStateService;
this.registerFactory = registerFactory;
}
public bool CanUpdate()
{
IPermissionProvider perm = PostgresIdentityProviderFactory.Instance.Permissions;
if (perm != null)
{
IRoleProvider rol = Role;
if (rol != null)
{
return(rol.HasPermission(perm.Get(IdentityUtils.UpdatePermissionId)));
}
}
return(false);
}
public PersonController(IRoleProvider roleProvider, IMasterListProvider masterListProvider, IProjectProvider projectProvider, IClassificationProvider classificationProvider, IClassificationValueProvider classificationValueProvider, IUserProvider userProvider, IGenderProvider genderProvider, IPersonProvider personProvider, ICheckProvider checkProvider, IOrganizationProvider organizationProvider, IClaimCheck claimCheck, Microsoft.AspNetCore.Identity.UserManager <SIPx.API.Models.SipUser> userManager)
{
_roleProvider = roleProvider;
_masterListProvider = masterListProvider;
_projectProvider = projectProvider;
_classificationProvider = classificationProvider;
_classificationValueProvider = classificationValueProvider;
_userProvider = userProvider;
_genderProvider = genderProvider;
_personProvider = personProvider;
_checkProvider = checkProvider;
_organizationProvider = organizationProvider;
_claimCheck = claimCheck;
_userManager = userManager;
}
public EnvironmentProvider(
IProjectRepository projectRepository,
ICommandDispatcher commandHandlerProvider,
IDataSourceInitializer dataSourceInitializer,
IPluginInitializer pluginInitializer,
IRoleProvider roleProvider,
IDataSourceAccessInitializer dataSourceAccessInitializer)
{
_projectRepository = projectRepository;
_commandHandlerProvider = commandHandlerProvider;
_dataSourceInitializer = dataSourceInitializer;
_pluginInitializer = pluginInitializer;
_roleProvider = roleProvider;
_dataSourceAccessInitializer = dataSourceAccessInitializer;
}
public AzManager(IRoleProvider roleProvider, IPermissionProvider permissionProvider)
: this()
{
if (roleProvider == null)
{
throw new ArgumentNullException("roleProvider");
}
if (permissionProvider == null)
{
throw new ArgumentNullException("permissionProvider");
}
this.roleProvider = roleProvider;
this.permissionProvider = permissionProvider;
}
private void Scavenge(object notUsed)
{
if (AuthorizationManager.Instance.State == Runtime.RunState.Running)
{
LocalSystemUser u = new LocalSystemUser(SecurityUtils.AdminIdentity, "Admin", UserState.Active);
IRoleProvider prov = this.GetProviderOther(this.innerFact, new UserSecurityContext(u));
if (prov != null)
{
if (RoleMemorySet.Reset(prov))
{
RoleMembershipMemorySet.Reset(prov);
}
}
}
}
public Authentication(
IAuthenticationService authenticationService,
IOAuthService oAuthService,
IAccountLogic accountLogic,
IOAuthInintializer oAuthInintializer,
IRoleProvider roleProvider,
IUserRegistrationService userRegistrationService)
{
_authenticationService = authenticationService;
_oAuthService = oAuthService;
_accountLogic = accountLogic;
_oAuthInintializer = oAuthInintializer;
_roleProvider = roleProvider;
_userRegistrationService = userRegistrationService;
}
public PageSectionProcessConditionController(
IPageSectionContentConditionProvider pageSectionContentConditionProvider
, IContentProvider contentProvider
, IContentTypeProvider contentTypeProvider
, IContentTypeGroupProvider contentTypeGroupProvider
, IPersonProvider personProvider
, IProcessTypeStageTypeProvider processTypeStageTypeProvider
, IRoleProvider roleProvider
, IProcessTypeGroupProvider processTypeGroupProvider
, IProcessTypeProvider processTypeProvider
, IPageSectionProcessConditionProvider pageSectionProcessConditionProvider
, IPageSectionProcessConditionTypeProvider pageSectionProcessConditionTypeProvider
, IUserProvider userProvider
, IOrganizationProvider organizationProvider
, IProjectProvider projectProvider
, ILanguageProvider languageProvider
, IClassificationProvider classificationProvider
, ISecurityLevelProvider securityLevelProvider
, IMasterListProvider masterListProvider
, IMasterProvider masterProvider
, ICheckProvider checkProvider
, IClaimCheck claimCheck
, Microsoft.AspNetCore.Identity.UserManager <SIPx.API.Models.SipUser> userManager)
{
_masterProvider = masterProvider;
_pageSectionContentConditionProvider = pageSectionContentConditionProvider;
_contentProvider = contentProvider;
_contentTypeProvider = contentTypeProvider;
_contentTypeGroupProvider = contentTypeGroupProvider;
_personProvider = personProvider;
_processTypeStageTypeProvider = processTypeStageTypeProvider;
_roleProvider = roleProvider;
_processTypeGroupProvider = processTypeGroupProvider;
_processTypeProvider = processTypeProvider;
_pageSectionProcessConditionProvider = pageSectionProcessConditionProvider;
_pageSectionProcessConditionTypeProvider = pageSectionProcessConditionTypeProvider;
_userProvider = userProvider;
_organizationProvider = organizationProvider;
_projectProvider = projectProvider;
_languageProvider = languageProvider;
_classificationProvider = classificationProvider;
_securityLevelProvider = securityLevelProvider;
_masterListProvider = masterListProvider;
_checkProvider = checkProvider;
_claimCheck = claimCheck;
_userManager = userManager;
}
protected virtual void prepareIntegrationSource(string name = "file_loading_test_xml"){
var root =(this.GetType()+"_"+name).prepareTemporaryDirectory();
((DefaultFilePathResolver) myapp.files).Root = root;
this.r = new XmlRoleProvider<ApplicationXmlReader>();
myapp.files.Write("~/usr/security.map.config",@"<root>
<role name='A'/>
<role name='C'/>
<map role='A' as='B' />
<map role='B' as='D' />
<map role='D' as='E' />
<map role='C' as='F' />
<map user='******' as='A' />
<map user='******' as='B' />
<map user='******' as='B' />
<map user='******' as='C' />
</root>");
}
public UserDisplayDriver(
UserManager <IUser> userManager,
IUserService userService,
IRoleProvider roleProvider,
IUserStore <IUser> userStore,
IUserEmailStore <IUser> userEmailStore,
IUserRoleStore <IUser> userRoleStore,
IStringLocalizer <UserDisplayDriver> stringLocalizer)
{
_userManager = userManager;
_userService = userService;
_roleProvider = roleProvider;
_userStore = userStore;
_userEmailStore = userEmailStore;
_userRoleStore = userRoleStore;
T = stringLocalizer;
}
public ProcessTypeFlowConditionController(IOrganizationProvider organizationProvider, IProjectProvider projectProvider, IUserProvider userProvider, IRoleProvider roleProvider, ISecurityLevelProvider securityLevelProvider, ICheckProvider checkProvider, IProcessTypeFlowConditionComparisonOperatorProvider processTypeFlowConditionComparisonOperatorProvider, IProcessTypeFieldProvider processTypeFieldProvider, IProcessTypeFlowConditionTypeProvider processTypeFlowConditionTypeProvider, IProcessTypeFlowConditionProvider processTypeFlowConditionProvider, IMasterProvider masterProvider, IClaimCheck claimCheck, IProcessTypeProvider processTypeProvider, Microsoft.AspNetCore.Identity.UserManager <SIPx.API.Models.SipUser> userManager)
{
_organizationProvider = organizationProvider;
_projectProvider = projectProvider;
_userProvider = userProvider;
_roleProvider = roleProvider;
_securityLevelProvider = securityLevelProvider;
_checkProvider = checkProvider;
_processTypeFlowConditionComparisonOperatorProvider = processTypeFlowConditionComparisonOperatorProvider;
_processTypeFieldProvider = processTypeFieldProvider;
_processTypeFlowConditionTypeProvider = processTypeFlowConditionTypeProvider;
_processTypeFlowConditionProvider = processTypeFlowConditionProvider;
_masterProvider = masterProvider;
_claimCheck = claimCheck;
_processTypeProvider = processTypeProvider;
_userManager = userManager;
}
static void Grant(UserSecurityContext context)
{
IRoleProvider perms = AuthorizationManager.Instance.GetRoleProvider(context);
Permission p;
Role r = perms.Get(SecurityUtils.AdminRole);
p = new Permission(PermissionUtils.PermissionName(OperationType.Create, "UserAffiliation"), UserAffiliationUtils.AddPermissionId);
Console.WriteLine("Granting Permission: " + p.Name);
perms.AddToRole(r, p);
p = new Permission(PermissionUtils.PermissionName(OperationType.Retrive, "UserAffiliation"), UserAffiliationUtils.GetPermissionId);
Console.WriteLine("Granting Permission: " + p.Name);
perms.AddToRole(r, p);
p = new Permission(PermissionUtils.PermissionName(OperationType.Delete, "UserAffiliation"), UserAffiliationUtils.RemovePermissionId);
Console.WriteLine("Granting Permission: " + p.Name);
perms.AddToRole(r, p);
}
public UserStore(
IRoleProvider roleProvider,
ILookupNormalizer keyNormalizer,
IUnitOfWorkManager unitOfWorkManager,
IRepository <User, long> userRepository,
IRepository <UserLogin, long> userLoginRepository,
IRepository <Role> roleRepository,
IRepository <UserRole, long> userRoleRepository,
ILogger <UserStore> logger)
{
_roleProvider = roleProvider;
_keyNormalizer = keyNormalizer;
_unitOfWorkManager = unitOfWorkManager;
_userRepository = userRepository;
_userLoginRepository = userLoginRepository;
_logger = logger;
_userRoleRepository = userRoleRepository;
_roleRepository = roleRepository;
}
public void InializeSecurityController(IUserProvider provider, IRoleProvider roleProvider)
{
if (provider == null)
{
throw new Exception("Provider per la ricerca utente nullo");
}
_provider = provider;
if (roleProvider == null)
{
throw new Exception("Provider per la ricerca ruoli nullo");
}
_roleProvider = roleProvider;
_token = null;
}
public override void Handle(HttpContext context, CancellationToken cancel)
{
if (context != null && AuthorizationManager.Instance.State == Osrs.Runtime.RunState.Running && context.Request.Method == "POST") //all we support is post
{
UserIdentityBase user = Security.Session.GetUser(context);
if (user != null)
{
UserSecurityContext ctx = new UserSecurityContext(user);
IRoleProvider prov = AuthorizationManager.Instance.GetRoleProvider(ctx);
if (prov != null)
{
IEnumerable <Permission> perms = prov.GetPermissions(user);
if (perms != null)
{
JArray orgs = Jsonifier.ToJson(perms);
if (orgs != null)
{
RestUtils.Push(context.Response, JsonOpStatus.Ok, orgs);
}
else
{
RestUtils.Push(context.Response, JsonOpStatus.Failed);
}
}
else
{
RestUtils.Push(context.Response, JsonOpStatus.Ok, "[]");
}
}
else
{
RestUtils.Push(context.Response, JsonOpStatus.Failed, "No provider");
}
return;
}
else
{
context.Response.StatusCode = HttpStatusCodes.Status401Unauthorized;
}
}
context.Response.StatusCode = HttpStatusCodes.Status400BadRequest;
}
public AdminController(
IAuthorizationService authorizationService,
ISession session,
UserManager <User> userManager,
RoleManager <Role> roleManager,
IRoleProvider roleProvider,
IStringLocalizer <AdminController> stringLocalizer,
ISiteService siteService,
IShapeFactory shapeFactory
)
{
_roleProvider = roleProvider;
_roleManager = roleManager;
_shapeFactory = shapeFactory;
_siteService = siteService;
T = stringLocalizer;
_authorizationService = authorizationService;
_session = session;
_userManager = userManager;
}
internal static bool Reset(IRoleProvider prov)
{
try
{
RoleMembershipMemorySet tmp = new RoleMembershipMemorySet();
foreach (Role p in RoleMemorySet.Instance.GetRoles())
{
IEnumerable <Role> kids = prov.GetChildRoles(p);
if (kids != null)
{
foreach (Role r in kids)
{
tmp.AddRoleToRole(p.Id, r.Id);
}
}
IEnumerable <Guid> users = prov.GetUsers(p);
if (users != null)
{
foreach (Guid us in users)
{
tmp.AddUserToRole(us, p.Id);
}
}
IEnumerable <PermissionAssignment> pas = prov.GetPermissionAssignments(p);
if (pas != null)
{
foreach (PermissionAssignment pa in pas)
{
tmp.AddPermissionToRole(p.Id, pa.Permission.Id, pa.GrantType == GrantType.Grant);
}
}
}
instance = tmp;
return(true);
}
catch
{ }
return(false);
}
public AdminController(
IAuthorizationService authorizationService,
ISession session,
UserManager<User> userManager,
RoleManager<Role> roleManager,
IRoleProvider roleProvider,
IStringLocalizer<AdminController> stringLocalizer,
IHtmlLocalizer<AdminController> htmlLocalizer,
ISiteService siteService,
IShapeFactory shapeFactory,
INotifier notifier
)
{
_notifier = notifier;
_roleProvider = roleProvider;
_roleManager = roleManager;
New = shapeFactory;
_siteService = siteService;
T = stringLocalizer;
TH = htmlLocalizer;
_authorizationService = authorizationService;
_session = session;
_userManager = userManager;
}
public static void SetCurrentRoleProvider(IRoleProvider provider)
{
_roleProvider = provider;
}
private void InitProvider()
{
_provider = BWConfigurationSection.GetConfig().RoleProvider.GetProvider();
}
protected void InitialiseTestObjects()
{
_provider = new EFRoleProvider {CreateContext = () => _connection.GetContext()};
new AutomaticUpdater().RunWithContext(_connection.GetContext());
}
public PrincipalProvider(IAuthenticationService authenticationService, IRoleProvider roleProvider)
{
_authenticationService = authenticationService;
_roleProvider = roleProvider;
}
public RoleManager(IRoleProvider roleProvider)
{
RoleProvider = roleProvider;
}
public RoleService(IRoleProvider dal)
{
this._dal = dal;
}
public virtual void setup(){
this.r = new XmlRoleProvider<ApplicationXmlReader>(new ApplicationXmlReader(code));
}
public ProfileService(IRoleProvider provider)
{
_roleProvider = provider;
DtoMappings.Initialize();
}
