public AccountController(IdentityUserManager userManager,
IConfiguration configuration,
ICurrentTenant currentTenant,
IdentityRoleManager roleManager,
IOptions <AbpAspNetCoreMultiTenancyOptions> options,
IProfileAppService profileAppService,
IRepository <IdentityUser> identityUser,
IIdentityRoleAppService roleAppService,
IIdentityUserAppService userAppService,
IAbpAuthorizationPolicyProvider abpAuthorizationPolicyProvider,
IAbpAuthorizationService authorizationService,
IRepository <PermissionGrant> permissionGrant,
IPermissionDefinitionManager permissionDefinitionManager,
IRepository <IdentityRole> identityRole,
Microsoft.AspNetCore.Identity.UserManager <IdentityUser> Uu
)
{
_userManager = userManager;
_Uu = Uu;
_currentTenant = currentTenant;
_aspNetCoreMultiTenancyOptions = options.Value;
_configuration = configuration;
_profileAppService = profileAppService;
_roleAppService = roleAppService;
_userAppService = userAppService;
_abpAuthorizationPolicyProvider = abpAuthorizationPolicyProvider;
_authorizationService = authorizationService;
_permissionDefinitionManager = permissionDefinitionManager;
_permissionGrant = permissionGrant;
_identityUser = identityUser;
_identityRole = identityRole;
_roleManager = roleManager;
}
public IdentityRoleManager_Tests()
{
_identityRoleManager = GetRequiredService <IdentityRoleManager>();
_identityRoleRepository = GetRequiredService <IIdentityRoleRepository>();
_lookupNormalizer = GetRequiredService <ILookupNormalizer>();
_testData = GetRequiredService <IdentityTestData>();
}
protected void Page_Load(object sender, EventArgs e) {
Feedback.Visible = false;
Guid roleId;
if (!Request.QueryString["id"].TryParseGuid(out roleId)) {
ShowError(Feedback, "The parameter for id is not in the correct format!");
SaveButton.Visible = false;
FormFields.Visible = false;
return;
}
_roleManager = IdentityRoleManager.GetManager();
_role = _roleManager.FindById(roleId);
if (_role == null) {
ShowError(Feedback, "No role was found for the given id!");
SaveButton.Visible = false;
FormFields.Visible = false;
return;
}
SaveButton.Click += SaveButton_Click;
if (!IsPostBack) {
RoleId.Value = roleId.ToString();
RoleName.Text = _role.Name;
if (Request.QueryString["message"] == "created") {
ShowMessage(Feedback, "Role has been created!");
}
}
RenderUsersInRole();
}
public IdentityRoleAppService(
IdentityRoleManager roleManager,
IIdentityRoleRepository roleRepository)
{
RoleManager = roleManager;
RoleRepository = roleRepository;
}
public async void CreateRolesAsync(IContainer container)
{
IdentityRoleManager roleManager = container.Resolve <IdentityRoleManager>();
IdentityUserManager userManager = container.Resolve <IdentityUserManager>();
if (userManager.FindById(6) != null)
{
await userManager.AddToRoleAsync(6, Role.Admin.ToString());
}
if (userManager.FindById(7) != null)
{
await userManager.AddToRoleAsync(7, Role.Seller.ToString());
}
if (roleManager.FindByNameAsync(Role.Admin.ToString()).Result == null)
{
await roleManager.CreateAsync(new CustomRole(Role.Admin.ToString()));
await userManager.AddToRoleAsync(1, Role.Admin.ToString());
}
if (roleManager.FindByNameAsync(Role.Seller.ToString()).Result == null)
{
await roleManager.CreateAsync(new CustomRole(Role.Seller.ToString()));
}
if (roleManager.FindByNameAsync(Role.Customer.ToString()).Result == null)
{
await roleManager.CreateAsync(new CustomRole(Role.Customer.ToString()));
}
}
public WzhIdentityRoleAppService(IdentityRoleManager roleManager,
IIdentityRoleRepository roleRepository,
IStringLocalizer <AbpVnextResource> localizer,
OrganizationUnitManager orgManager) : base(roleManager, roleRepository)
{
_localizer = localizer;
OrgManager = orgManager;
}
public IdentityRoleAppService(
IJsonSerializer jsonSerializer,
IdentityRoleManager roleManager,
IIdentityRoleRepository roleRepository)
{
_jsonSerializer = jsonSerializer;
RoleManager = roleManager;
RoleRepository = roleRepository;
}
public TigerIdentityRoleAppService(IdentityRoleManager roleManager,
IIdentityRoleRepository roleRepository,
//IStringLocalizer<HelloAbpResource> localizer,
OrganizationUnitManager orgManager) : base(roleManager, roleRepository)
{
//_localizer = localizer;
_orgManager = orgManager;
_roleManager = roleManager;
}
public OrganizationUnitRoleAppService(
OrganizationUnitManager organizationUnitManager,
IOrganizationUnitRoleRepository organizationUnitRoleRepository,
IdentityRoleManager roleManager)
{
_organizationUnitManager = organizationUnitManager;
_organizationUnitRoleRepository = organizationUnitRoleRepository;
_roleManager = roleManager;
}
public new void TestInitialize()
{
base.TestInitialize();
userManager = MockRepository.GenerateStub <IdentityUserManager>();
roleManager = MockRepository.GenerateStub <IdentityRoleManager>();
signInManager = MockRepository.GenerateStub <IdentitySignInManager>();
userService = MockRepository.GenerateStub <IUserService>();
companyService = MockRepository.GenerateStub <ICompanyService>();
mapper = MockRepository.GenerateStub <IMapper>();
}
public AdminController(IdentityUserManager userManager, IdentityRoleManager roleManager, IdentitySignInManager signInManager, IUserService userService, ICompanyService companyService, IMapper mapper)
{
this.userManager = userManager;
this.roleManager = roleManager;
this.signInManager = signInManager;
this.userService = userService;
this.companyService = companyService;
this.mapper = mapper;
}
protected void Page_Load(object sender, EventArgs e)
{
Feedback.Visible = false;
Guid userId;
if (!Request.QueryString["id"].TryParseGuid(out userId))
{
ShowError(Feedback, "The parameter for id is not in the correct format!");
SaveButton.Visible = false;
FormFields.Visible = false;
return;
}
_userManager = IdentityUserManager.GetManager();
_user = _userManager.FindById(userId);
if (_user == null)
{
ShowError(Feedback, "No user was found for the given id!");
SaveButton.Visible = false;
FormFields.Visible = false;
return;
}
SaveButton.Click += SaveButton_Click;
UserId.Value = userId.ToString();
UserName.Text = _user.UserName;
UserName.Attributes.Add("autocomplete", "off");
Password.Attributes.Add("autocomplete", "off");
if (!IsPostBack)
{
Email.Text = _user.Email;
FirstName.Text = _user.FirstName;
SurName.Text = _user.SurName;
PhoneNumber.Text = _user.PhoneNumber;
Password.Attributes.Add("value", PasswordMask);
ConfirmPassword.Attributes.Add("value", PasswordMask);
if (Request.QueryString["message"] == "created")
{
ShowMessage(Feedback, "User has been created!");
}
}
_roleManager = IdentityRoleManager.GetManager();
_roles = _roleManager.Roles.OrderBy(r => r.Name).ToList();
RenderRoles();
}
public TenantCreateEventHandler(
ICurrentTenant currentTenant,
IGuidGenerator guidGenerator,
IdentityUserManager identityUserManager,
IdentityRoleManager identityRoleManager,
ILogger <TenantCreateEventHandler> logger)
{
Logger = logger;
CurrentTenant = currentTenant;
GuidGenerator = guidGenerator;
IdentityUserManager = identityUserManager;
IdentityRoleManager = identityRoleManager;
}
public Distributed_Role_Change_Events_Test()
{
RoleRepository = GetRequiredService <IIdentityRoleRepository>();
;
PermissionGrantRepository = GetRequiredService <IPermissionGrantRepository>();
;
RoleManager = GetRequiredService <IdentityRoleManager>();
;
LookupNormalizer = GetRequiredService <ILookupNormalizer>();
;
UowManager = GetRequiredService <IUnitOfWorkManager>();
Cache = GetRequiredService <IDistributedCache <PermissionGrantCacheItem> >();
}
private void RenderRoles()
{
var stringBuilder = new StringBuilder();
var roleManager = IdentityRoleManager.GetManager();
var roles = roleManager.Roles.OrderBy(r => r.Name).ToList();
foreach (var role in roles)
{
stringBuilder.AppendFormat("<li><input type=\"checkbox\" Value=\"{0}\" Name=\"Roles\" /> {0}</li>", role.Name);
}
Roles.Text = stringBuilder.ToString();
}
public ProvisioningService(
MasterRepository masterRepository,
PushIdentityDbContext dbContext,
IdentityUserManager userManager,
IdentityRoleManager roleManager,
IPushLogger logger)
{
_masterRepository = masterRepository;
_dbContext = dbContext;
_userManager = userManager;
_roleManager = roleManager;
_logger = logger;
}
protected void Page_Load(object sender, EventArgs e)
{
var roleManager = IdentityRoleManager.GetManager();
var roles = roleManager.Roles.ToList();
var stringBuilder = new StringBuilder();
foreach (var role in roles)
{
stringBuilder.Append("<tr><td><a href=\"Identity/EditRole.aspx?id=" + role.Id + "\">" + role.Name + "</a></td></tr>");
}
RoleList.Text = stringBuilder.ToString();
}
void SaveButton_Click(object sender, EventArgs e)
{
var role = new IdentityRole(RoleName.Text);
var roleManager = IdentityRoleManager.GetManager();
var result = roleManager.Create(role);
if (result.Succeeded)
{
Response.Redirect("EditRole.aspx?id=" + role.Id + "&message=created");
}
else
{
ShowError(Feedback, "Couldn't save role: " + string.Join(", ", result.Errors));
}
}
public OrganizationUnitManager(
IOrganizationUnitRepository organizationUnitRepository,
ICancellationTokenProvider cancellationTokenProvider,
IOrganizationUnitUserRepository organizationUnitUserRepository,
IdentityRoleManager roleManager,
IdentityUserManager userManager,
IOrganizationUnitRoleRepository organizationUnitRoleRepository)
{
_organizationUnitRepository = organizationUnitRepository;
_cancellationTokenProvider = cancellationTokenProvider;
_organizationUnitUserRepository = organizationUnitUserRepository;
_roleManager = roleManager;
_userManager = userManager;
_organizationUnitRoleRepository = organizationUnitRoleRepository;
}
protected void Page_Load(object sender, EventArgs e) {
Feedback.Visible = false;
Guid userId;
if (!Request.QueryString["id"].TryParseGuid(out userId)) {
ShowError(Feedback, "The parameter for id is not in the correct format!");
SaveButton.Visible = false;
FormFields.Visible = false;
return;
}
_userManager = IdentityUserManager.GetManager();
_user = _userManager.FindById(userId);
if (_user == null) {
ShowError(Feedback, "No user was found for the given id!");
SaveButton.Visible = false;
FormFields.Visible = false;
return;
}
SaveButton.Click += SaveButton_Click;
UserId.Value = userId.ToString();
UserName.Text = _user.UserName;
UserName.Attributes.Add("autocomplete", "off");
Password.Attributes.Add("autocomplete", "off");
if (!IsPostBack) {
Email.Text = _user.Email;
FirstName.Text = _user.FirstName;
SurName.Text = _user.SurName;
PhoneNumber.Text = _user.PhoneNumber;
Password.Attributes.Add("value", PasswordMask);
ConfirmPassword.Attributes.Add("value", PasswordMask);
if (Request.QueryString["message"] == "created") {
ShowMessage(Feedback, "User has been created!");
}
}
_roleManager = IdentityRoleManager.GetManager();
_roles = _roleManager.Roles.OrderBy(r => r.Name).ToList();
RenderRoles();
}
public ActionResult Create([Bind(Include ="RoleName")]RoleViewModel model)
{
string message = "That role name has already been used";
if (ModelState.IsValid)
{
var role = new IdentityRole(model.RoleName);
IdentityRoleManager roleManager = new IdentityRoleManager(new RoleStore<IdentityRole>(_db));
if (_db.RoleExists(roleManager, model.RoleName))
{
return View(message);
}
else
{
_db.CreateRole(roleManager, model.RoleName);
return RedirectToAction("Index", "Roles");
}
}
return View();
}
public IdentityDataSeeder(
IGuidGenerator guidGenerator,
IIdentityRoleRepository roleRepository,
IIdentityUserRepository userRepository,
ILookupNormalizer lookupNormalizer,
IdentityUserManager userManager,
IdentityRoleManager roleManager,
ICurrentTenant currentTenant,
IOptions <IdentityOptions> identityOptions)
{
GuidGenerator = guidGenerator;
RoleRepository = roleRepository;
UserRepository = userRepository;
LookupNormalizer = lookupNormalizer;
UserManager = userManager;
RoleManager = roleManager;
CurrentTenant = currentTenant;
IdentityOptions = identityOptions;
}
public OrganizationUnitAppService(
OrganizationUnitManager organizationUnitManager,
IOrganizationUnitRepository organizationUnitRepository, IdentityRoleManager roleManager,
IIdentityRoleRepository roleRepository,
IOrganizationUnitRoleRepository organizationUnitRoleRepository,
IdentityUserOrganizationUnitRepository userOrganizationUnitRepository,
IdentityUserManager userManager,
IIdentityUserRepository userRepository)
{
OrganizationUnitManager = organizationUnitManager;
OrganizationUnitRepository = organizationUnitRepository;
UserOrganizationUnitRepository = userOrganizationUnitRepository;
RoleManager = roleManager;
OrganizationUnitRoleRepository = organizationUnitRoleRepository;
RoleRepository = roleRepository;
UserManager = userManager;
UserRepository = userRepository;
}
private async Task ValidateRoleName(IdentityRoleManager manager, Role role,
ICollection <IdentityError> errors)
{
var roleName = await manager.GetRoleNameAsync(role);
if (string.IsNullOrWhiteSpace(roleName))
{
errors.Add(Describer.InvalidRoleName(roleName));
}
else
{
var owner = await manager.FindByNameAsync(roleName, role.CompanyId, role.TenantId);
if (owner != null &&
!string.Equals(await manager.GetRoleIdAsync(owner), await manager.GetRoleIdAsync(role)))
{
errors.Add(Describer.DuplicateRoleName(roleName));
}
}
}
protected void Page_Load(object sender, EventArgs e)
{
Guid roleId;
if (!Request.QueryString["id"].TryParseGuid(out roleId))
{
throw new ArgumentException("Id not valid");
}
var roleManager = IdentityRoleManager.GetManager();
var role = roleManager.FindById(roleId);
if (role == null)
{
throw new Exception("No role with submitted id");
}
roleManager.Delete(role);
Response.Redirect("Roles.aspx");
}
public IdentityService(
MasterRepository masterRepository,
PushIdentityDbContext dbContext,
IdentityUserManager userManager,
IdentityRoleManager roleManager,
IdentitySignInManager signInManager,
InstanceContext instanceContext,
StateRepository stateRepository,
IPushLogger logger,
ShopifyUrlService shopifyUrlService)
{
_masterRepository = masterRepository;
_dbContext = dbContext;
_userManager = userManager;
_roleManager = roleManager;
_signInManager = signInManager;
_instanceContext = instanceContext;
_stateRepository = stateRepository;
_logger = logger;
_shopifyUrlService = shopifyUrlService;
}
public AppIdentityDataSeeder(
IGuidGenerator guidGenerator,
IIdentityRoleRepository roleRepository,
IIdentityUserRepository userRepository,
ILookupNormalizer lookupNormalizer,
IdentityUserManager userManager,
IdentityRoleManager roleManager,
ICurrentTenant currentTenant,
IPermissionDefinitionManager permissionDefinitionManager,
IPermissionManager permissionManager)
{
GuidGenerator = guidGenerator;
RoleRepository = roleRepository;
UserRepository = userRepository;
LookupNormalizer = lookupNormalizer;
UserManager = userManager;
RoleManager = roleManager;
CurrentTenant = currentTenant;
PermissionDefinitionManager = permissionDefinitionManager;
PermissionManager = permissionManager;
}
protected void Page_Load(object sender, EventArgs e)
{
Feedback.Visible = false;
Guid roleId;
if (!Request.QueryString["id"].TryParseGuid(out roleId))
{
ShowError(Feedback, "The parameter for id is not in the correct format!");
SaveButton.Visible = false;
FormFields.Visible = false;
return;
}
_roleManager = IdentityRoleManager.GetManager();
_role = _roleManager.FindById(roleId);
if (_role == null)
{
ShowError(Feedback, "No role was found for the given id!");
SaveButton.Visible = false;
FormFields.Visible = false;
return;
}
SaveButton.Click += SaveButton_Click;
if (!IsPostBack)
{
RoleId.Value = roleId.ToString();
RoleName.Text = _role.Name;
if (Request.QueryString["message"] == "created")
{
ShowMessage(Feedback, "Role has been created!");
}
}
RenderUsersInRole();
}
/// <summary>
/// Creates default roles.
/// </summary>
public void CreateRoles(DataContext context)
{
var roleManager = new IdentityRoleManager(new RoleStore(context));
if (!roleManager.RoleExists(RoleNames.Admin))
{
var result = roleManager.Create(new Role(RoleNames.Admin));
if (!result.Succeeded)
{
throw new Exception("Error creating admin role: " + result.Errors.FirstOrDefault());
}
}
if (!roleManager.RoleExists(RoleNames.User))
{
var result = roleManager.Create(new Role(RoleNames.User));
if (!result.Succeeded)
{
throw new Exception("Error creating user role: " + result.Errors.FirstOrDefault());
}
}
}
public ApplicationAccountManager(
IdentityUserStore <ApplicationUser> userStore, ApplicationUserManager userManager,
IdentityRoleStore roleStore, IdentityRoleManager roleManager)
: base(userStore, userManager, roleStore, roleManager)
{
}
public ManageRolesController(ApplicationUserManager userManager, IdentityRoleManager roleManager)
{
UserManager = userManager;
RoleManager = roleManager;
}
public bool RoleExists(IdentityRoleManager roleManager, string name)
{
return roleManager.RoleExists(name);
}
public bool CreateRole(IdentityRoleManager roleManager, string name)
{
var idResult = roleManager.Create(new IdentityRole(name));
return idResult.Succeeded;
}
public RoleRepository(IRepositoryManager <int> repositoryManager, IdentityRoleManager roleManager) : base(repositoryManager)
{
this.roleManager = roleManager;
}
public AbpLiquidContextHandler(IdentityUserManager identityUserManager, IdentityRoleManager identityRoleManager)
{
_identityUserManager = identityUserManager;
_identityRoleManager = identityRoleManager;
}
