Exemple #1
0
        public async Task <IActionResult> RegisterWithRole([FromBody] RegisterWithRoleViewModel model)
        {
            try
            {
                UserAccount user = new UserAccount
                {
                    Email    = model.Email,
                    UserName = model.Email
                };

                var result = await _userManager.CreateAsync(user, model.Password);


                if (result.Succeeded)
                {
                    await _userManager.AddToRoleAsync(user, model.RoleName);

                    await _signInManager.SignInAsync(user, false);

                    return(Ok(new { Email = model.Email, RoleName = model.RoleName }));
                }

                return(StatusCode(403, result.Errors.
                                  Select(x => new { Code = x.Code, Description = x.Description })));
            }
            catch (Exception e)
            {
                return(StatusCode(500));
            }
        }
Exemple #2
0
        public async Task <IActionResult> Search([FromBody][Bind("Email,RoleName")] RegisterWithRoleViewModel model)
        {
            try
            {
                var list_Of_Searching = await _userManager.Users
                                        .Where(x => EF.Functions.Like(x.Email, $"%{model.Email}%"))
                                        .Select(x => new { x.Email, RoleName = _userManager.GetRolesAsync(x).Result.FirstOrDefault() })
                                        .ToListAsync();

                return(Ok(list_Of_Searching));
            }
            catch (Exception e)
            {
            }
            return(StatusCode(206));
        }
Exemple #3
0
        public async Task <IActionResult> RegisterUser(RegisterWithRoleViewModel registerWithRoleViewModel)
        {
            if (ModelState.IsValid)
            {
                CustomIdentityUser user = new CustomIdentityUser
                {
                    UserName = registerWithRoleViewModel.Email,
                    Email    = registerWithRoleViewModel.Email,
                };

                IdentityResult result = _userManager.CreateAsync(user, registerWithRoleViewModel.Password).Result;

                if (result.Succeeded)
                {
                    // await roleManager.AddClaimAsync(adminRole, new Claim(CustomClaimTypes.Permission, "projects.view"));
                    //await _userManager.AddClaimAsync(user, new Claim("claimtip", user.Email));
                    CustomIdentityRole role = await _roleManager.FindByNameAsync(registerWithRoleViewModel.Role.Trim());

                    if (role == null)
                    {
                        await _userManager.DeleteAsync(user);

                        ModelState.AddModelError("Error", "role not verified");
                    }
                    else
                    {
                        _userManager.AddToRoleAsync(user, registerWithRoleViewModel.Role.Trim()).Wait();
                    }
                    // _userManager.AddToRoleAsync(user, "Manager").Wait();
                    //return RedirectToAction("Login", "Acc");
                }
                else
                {
                    List <IdentityError> errors = result.Errors.ToList <IdentityError>();
                    foreach (var error in errors)
                    {
                        ModelState.AddModelError("Error", error.Description);
                    }
                }
            }
            return(View(registerWithRoleViewModel));
        }