Example #1
0
 public RoleAccountRegister(ClamRoles role)
 {
     Id     = role.Id;
     Name   = role.Name;
     Users  = new List <string>();
     Claims = new List <string>();
 }
Example #2
0
 public async Task AddRole(RoleAccountRegister entity)
 {
     try
     {
         var role = new ClamRoles {
             Name = entity.Name
         };
         await _roleManager.CreateAsync(role);
     }
     catch (Exception)
     {
         throw;
     }
 }
Example #3
0
        public async Task <IActionResult> OnPostAsync(string returnUrl = null)
        {
            returnUrl      = returnUrl ?? Url.Content("~/");
            ExternalLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync()).ToList();
            if (ModelState.IsValid)
            {
                var user = new ClamUserAccountRegister
                {
                    UserName    = Input.UserName,
                    Email       = Input.Email,
                    FirstName   = Input.FirstName,
                    LastName    = Input.LastName,
                    Gender      = Input.Gender,
                    PhoneNumber = Input.PhoneNumber,
                    Birthday    = Input.Birthday,
                    AcceptTermsAndConditions = Input.AcceptTermsAndConditions
                };
                var result = await _userManager.CreateAsync(user, Input.Password);

                if (!(await _roleManager.RoleExistsAsync("Owner")) && (user.UserName.Equals("zipyx")))
                {
                    // List of Roles
                    List <string> roleTitles = new List <string>()
                    {
                        "Member", "Student", "Contributor", "Moderator", "Admin", "Engineer", "Developer", "Owner"
                    };
                    List <ClaimAccountRegister> ownerClaims = new List <ClaimAccountRegister>();
                    // Roles Created
                    foreach (var item in roleTitles)
                    {
                        var role = new ClamRoles {
                            Name = item
                        };
                        await _roleManager.CreateAsync(role);
                    }

                    // Add All roles to Owner
                    await _userManager.AddToRolesAsync(user, roleTitles);

                    // Add User Claims
                    foreach (Claim claim in ClaimsStore.AllClaims.ToList())
                    {
                        ownerClaims.Add(new ClaimAccountRegister()
                        {
                            ClaimType = claim.Type, ClaimValue = claim.Value, IsSelected = true
                        });
                        await _userManager.AddClaimAsync(user, claim);
                    }

                    // Add Role Claims
                    foreach (var role in roleTitles)
                    {
                        if (role.Equals("Owner"))
                        {
                            foreach (Claim claim in ClaimsStore.RoleClaims.ToList())
                            {
                                var foundRole = await _roleManager.FindByNameAsync(role);

                                await _roleManager.AddClaimAsync(foundRole, claim);
                            }
                            break;
                        }
                    }

                    //await _userManager.AddClaimsAsync(user, ownerClaims.Where(x => x.IsSelected).Select(y => new Claim(y.ClaimType, y.ClaimValue)));
                }
                if (result.Succeeded)
                {
                    _logger.LogInformation("User created a new account with password.");

                    var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);

                    code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
                    var callbackUrl = Url.Page(
                        "/Account/ConfirmEmail",
                        pageHandler: null,
                        values: new { area = "Identity", userId = user.Id, code = code },
                        protocol: Request.Scheme);

                    await _emailSender.SendEmailAsync(Input.Email, "Confirm your email",
                                                      $"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");

                    if (_userManager.Options.SignIn.RequireConfirmedAccount)
                    {
                        return(RedirectToPage("RegisterConfirmation", new { email = Input.Email }));
                    }
                    else
                    {
                        await _signInManager.SignInAsync(user, isPersistent : false);

                        return(LocalRedirect(returnUrl));
                    }
                }
                foreach (var error in result.Errors)
                {
                    ModelState.AddModelError(string.Empty, error.Description);
                }
            }

            // If we got this far, something failed, redisplay form
            return(Page());
        }