コード例 #1
0
ファイル: UserController.cs プロジェクト: ibakyrdjiev/ASP.NET
        public IHttpActionResult RemoveAdminFromUser(string username)
        {
            var user = this.Data.Users.All().ToList().FirstOrDefault(u => u.UserName == username);

            var um = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(new ApplicationDbContext()));

            string adminCheck = um.GetRoles(user.Id).FirstOrDefault(a => a.Contains("AppAdmin"));

            if (adminCheck == string.Empty)
            {
                return this.BadRequest(string.Format("user {0} is not admin", user.UserName));
            }

            um.RemoveFromRoleAsync(user.Id, "AppAdmin");

            this.Data.SaveChanges();

            return this.Ok(string.Format("user: {0} is not admin now", user.UserName));
        }
コード例 #2
0
        public ActionResult Demote(string id)
        {
            var currentUser = this.Data.Users.All().First(u => u.UserName == User.Identity.Name);
            var isSameUser = id == currentUser.Id;

            if (!isSameUser)
            {
                var store = new UserStore<User>(this.Data.Context);
                var manager = new UserManager<User>(store);

                manager.RemoveFromRoleAsync(id, GlobalConstants.AdminRole);

                this.Notify(GlobalConstants.DemoteUserSuccess, NotificationType.success);
            }
            else
            {
                this.Notify(GlobalConstants.DemoteUserFail, NotificationType.error);
            }

            return this.RedirectToAction("Manage");
        }
コード例 #3
0
        public async Task<IHttpActionResult> UpdateRuoloUtente(UpdateRuoloUtenteModel Model)
        {
            if (Model == null || !ModelState.IsValid)
                return BadRequest(ModelState);

            using (var userManager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(new ApplicationDbContext())))
            {
                var utente = await userManager.FindByNameAsync(Model.Username);
                if (utente == null)
                    return NotFound();

                if (Model.NuovoStato)
                {
                    await userManager.AddToRoleAsync(utente.Id, Model.Ruolo);
                }
                else
                {
                    await userManager.RemoveFromRoleAsync(utente.Id, Model.Ruolo);
                }
            }

            return Ok();
        }
コード例 #4
0
        public async Task <IHttpActionResult> DeleteTrader(string traderId)
        {
            TradesController trdCon = new TradesController();

            string          message = string.Empty;
            ApplicationUser trader  = db.Users.Find(traderId);

            if (trader == null)
            {
                // prepare the message
                ModelState.AddModelError("Message", "The author account can not be found!");
                // TODO logging here an unexpected error has occured
                return(BadRequest(ModelState));
            }
            try
            {
                // Business Rule: Remove the trader role of the account
                IdentityResult resultRole = await UserManager.RemoveFromRoleAsync(traderId, "Trader");

                if (!resultRole.Succeeded)
                {
                    foreach (string err in resultRole.Errors)
                    {
                        message += err;
                    }
                    ModelState.AddModelError("Message", "Trader Role Error: " + message + " Please contact the app admin!");
                    return(BadRequest(ModelState));
                }
                // Bussiness Rule: Remove the password when removing the trader role
                IdentityResult resultPassword = await UserManager.RemovePasswordAsync(traderId);

                if (!resultPassword.Succeeded)
                {
                    foreach (string err in resultPassword.Errors)
                    {
                        message += err;
                    }
                    ModelState.AddModelError("Message", "Trader Password Error: " + message + " Please contact the app admin!");
                    return(BadRequest(ModelState));
                }

                // deletion of trades will not delete the physical files
                var arts = from art in db.Trades
                           where (art.traderId == traderId)
                           select art;

                // the trade controller method will delete the physical uploaded trade images files
                foreach (Trade ar in arts)
                {
                    trdCon.DeletePhysicalImages(ar.tradeId);
                }

                // Business Rule: Remove the account and roles associcated when we have single role account
                // removing of trader will take care of removing the traders's trades and with that the images's
                // (multiple trades will remove multiple images from the tables)
                db.Users.Remove(trader);

                await db.SaveChangesAsync();

                return(Ok(trader));
            }
            catch (Exception Exc)
            {
                string error = Exc.InnerException.Message;

                // TODO // log the exception EXC on the server side
                RollBackDatabaseChanges();
                // prepare the message
                ModelState.AddModelError("Message", "An unexpected error occured during deleting the author account!");
                // TODO logging here an unexpected error has occured
                return(BadRequest(ModelState));
            }
        }
コード例 #5
0
        public async Task <ActionResult> DemoteToUser(string userId)
        {
            if (ModelState.IsValid)
            {
                var user = await UserManager.FindByIdAsync(userId);

                if (user == null)
                {
                    return(HttpNotFound());
                }

                try
                {
                    // Change role in db.
                    var resultRemoveFromRole = await UserManager.RemoveFromRoleAsync(userId, "Participant");

                    //var resultRemoveFromRoles = await UserManager.RemoveFromRolesAsync(userId, "Participant", "Editor", "Administrator"); // TODO Maybe add this
                    var resultAddToRole = await UserManager.AddToRolesAsync(userId, "User");

                    var resultUpdate = await UserManager.UpdateAsync(user);

                    //Move to errorpage
                    if (!resultRemoveFromRole.Succeeded || !resultAddToRole.Succeeded || !resultUpdate.Succeeded) // TODO
                    {
                        return(RedirectToAction("Index", "Seats"));                                               // TODO
                    }


                    if (!User.IsInRole("Administrator"))
                    {
                        // Change cookie.
                        var identity = new ClaimsIdentity(User.Identity);
                        identity.RemoveClaim(identity.FindFirst(identity.RoleClaimType));
                        identity.AddClaim(new Claim(identity.RoleClaimType, "User"));

                        IOwinContext context = Request.GetOwinContext();
                        var          authenticationContext = await context.Authentication.AuthenticateAsync(DefaultAuthenticationTypes.ApplicationCookie);

                        if (authenticationContext != null)
                        {
                            context.Authentication.AuthenticationResponseGrant = new AuthenticationResponseGrant(
                                identity,
                                authenticationContext.Properties);
                        }
                    }
                    await UserManager.UpdateSecurityStampAsync(userId);

                    ////Get the authentication manager
                    //var authenticationManager = HttpContext.GetOwinContext().Authentication;

                    ////Log the user out
                    //authenticationManager.SignOut();

                    ////Log the user back in
                    //var identityTemp = UserManager.CreateIdentity(user, DefaultAuthenticationTypes.ApplicationCookie);
                    //authenticationManager.SignIn(new AuthenticationProperties() { IsPersistent = true }, identityTemp);
                }
                catch (Exception) { }
            }
            return(RedirectToAction("Index", "Seats"));
        }
コード例 #6
0
 public async Task StopModeratorRights(string Id)
 {
     var user = userDbset.All().Where(i => i.Id == Id).FirstOrDefault();
     await userManager.RemoveFromRoleAsync(user, "Moderator");
 }
コード例 #7
0
        public async Task <JsonResult> Save(UserViewModel model)
        {
            if (ModelState.IsValid)
            {
                var user = Mapper.Map <UserViewModel, ApplicationUser>(model);
                user.UserName     = model.Email;
                user.IsApproved   = true;
                user.FirstName    = model.FirstName;
                user.Surname      = model.Surname;
                user.MobileNumber = model.MobileNumber;

                //var user = new ApplicationUser { UserName = model.Email, Email = model.Email };
                IdentityResult result  = null;
                string         message = string.Empty;
                if (string.IsNullOrEmpty(model.Id) || model.Id.Equals("0"))
                {
                    message = "User saved successfully";
                    result  = await _userManager.CreateAsync(user, model.Password);

                    if (result.Succeeded)
                    {
                        if (model.TrustId > 0)
                        {
                            model.Id       = user.Id;
                            model.TrustIds = new List <int>()
                            {
                                model.TrustId
                            };
                            await _userService.UpdateUserDetails(model);
                        }
                        if (!string.IsNullOrEmpty(model.Role) && IsPharmixAdmin)
                        {
                            await _userManager.AddToRoleAsync(user, model.Role);
                        }
                    }
                }
                else
                {
                    message           = "User updated successfully";
                    user              = _userManager.FindByIdAsync(model.Id).Result;
                    user.UserName     = model.Email;
                    user.IsApproved   = true;
                    user.FirstName    = model.FirstName;
                    user.Surname      = model.Surname;
                    user.MobileNumber = model.MobileNumber;
                    if (user != null)
                    {
                        var existingRoles = await _userManager.GetRolesAsync(user);

                        foreach (var role in existingRoles)
                        {
                            await _userManager.RemoveFromRoleAsync(user, role);
                        }
                        if (!string.IsNullOrEmpty(model.Role) && IsPharmixAdmin)
                        {
                            await _userManager.AddToRoleAsync(user, model.Role);
                        }
                        result = _userManager.ResetPasswordAsync(user, model.PasswordResetToken, model.ConfirmPassword).Result;

                        model.TrustIds = new List <int>()
                        {
                            model.TrustId
                        };
                        await _userService.UpdateUserDetails(model);
                    }
                }

                //if (result.Succeeded)
                //    await _userManager.AddToRoleAsync(user, "Customer");

                //ViewBag.IsSuccess = result.Succeeded;



                return(Json(new { StatusCode = StatusCodes.Status200OK, Message = message }));
            }
            return(Json(new { StatusCode = StatusCodes.Status500InternalServerError, Message = "User not saved" }));
        }
コード例 #8
0
        public async Task RemoveUserRoleAsync(string roleName, string userId)
        {
            ApplicationUser user = await userManager.FindByIdAsync(userId);

            await userManager.RemoveFromRoleAsync(user, roleName);
        }
コード例 #9
0
ファイル: UserAppService.cs プロジェクト: nailox/aspnet-core
        //Example for primitive method parameters.
        public async Task RemoveFromRole(long userId, string roleName)
        {
            var user = await UserManager.FindByIdAsync(userId.ToString());

            CheckErrors(await UserManager.RemoveFromRoleAsync(user, roleName));
        }
コード例 #10
0
        public async Task <IActionResult> UpdateUser([FromBody] UpdateUserDto userDto)
        {
            var lang          = Request.Headers["language"].ToString();
            var errorMessages = new List <string>();

            if (string.IsNullOrEmpty(userDto.FirstName))
            {
                errorMessages.Add(_translator.GetTranslation("VALIDATION.FIRSTNAME_REQUIRED", lang));
            }

            if (string.IsNullOrEmpty(userDto.LastName))
            {
                errorMessages.Add(_translator.GetTranslation("VALIDATION.LASTNAME_REQUIRED", lang));
            }

            if (string.IsNullOrEmpty(userDto.Country))
            {
                errorMessages.Add(_translator.GetTranslation("VALIDATION.COUNTRY_REQUIRED", lang));
            }

            if (string.IsNullOrEmpty(userDto.Gender))
            {
                errorMessages.Add(_translator.GetTranslation("VALIDATION.GENDER_REQUIRED", lang));
            }

            if (string.IsNullOrEmpty(userDto.Email))
            {
                errorMessages.Add(_translator.GetTranslation("VALIDATION.EMAIL_REQUIRED", lang));
            }



            if (errorMessages.Count > 0)
            {
                return(BadRequest(new { errors = errorMessages }));
            }

            try
            {
                var user = await _userManager.FindByIdAsync(userDto.Id);

                if (user == null)
                {
                    return(NotFound());
                }

                user.FirstName      = userDto.FirstName;
                user.LastName       = userDto.LastName;
                user.Email          = userDto.Email;
                user.EmailConfirmed = userDto.EmailConfirmed.Value;
                user.Country        = userDto.Country;
                user.Gender         = userDto.Gender;


                user.IsAdmin  = userDto.IsAdmin.Value;
                user.IsAuthor = userDto.IsAuthor.Value;

                var result = await _userManager.UpdateAsync(user);

                if (result.Succeeded)
                {
                    if (user.IsAdmin && !(await _userManager.IsInRoleAsync(user, "Admin")))
                    {
                        var addToAdminResult = await _userManager.AddToRoleAsync(user, "Admin");

                        if (!addToAdminResult.Succeeded)
                        {
                            errorMessages.Add(_translator.GetTranslation("ERROR", lang));

                            return(BadRequest(new { errors = errorMessages }));
                        }
                    }
                    else
                    {
                        var removeFromAdminResult = await _userManager.RemoveFromRoleAsync(user, "Admin");
                    }
                    if (user.IsAuthor && !(await _userManager.IsInRoleAsync(user, "Author")))
                    {
                        var addToAuthorResult = await _userManager.AddToRoleAsync(user, "Author");

                        if (!addToAuthorResult.Succeeded)
                        {
                            errorMessages.Add(_translator.GetTranslation("ERROR", lang));
                            return(BadRequest(new { errors = errorMessages }));
                        }
                    }
                    else
                    {
                        var removeFromAuthorResult = await _userManager.RemoveFromRoleAsync(user, "Author");
                    }


                    var response = new
                    {
                        Id             = user.Id,
                        FirstName      = user.FirstName,
                        LastName       = user.LastName,
                        Email          = user.Email,
                        EmailConfirmed = user.EmailConfirmed,
                        Country        = user.Country,
                        Gender         = user.Gender,
                        IsAdmin        = user.IsAdmin,
                        IsAuthor       = user.IsAuthor,
                        IsActive       = user.IsActive
                    };

                    return(Ok(new { user = response }));
                }
                errorMessages.Add(_translator.GetTranslation("ERROR", lang));
                return(BadRequest(new { errors = errorMessages }));
            }
            catch
            {
                // return error message if there was an exception

                errorMessages.Add(_translator.GetTranslation("ERROR", lang));

                return(BadRequest(new { errors = errorMessages }));
            }
        }
コード例 #11
0
        public ActionResult AddEdit(UserViewModels model)
        {
            if (!ModelState.IsValid)
            {
                return(View(model));
            }

            IdentityUser user;

            if (string.IsNullOrEmpty(model.Id))
            {
                user = new IdentityUser()
                {
                    UserName = model.Username, EmailConfirmed = true
                }
            }
            ;
            else
            {
                user = _userManager.FindByIdAsync(model.Id).Result;
            }

            user.Email       = model.Email;
            user.PhoneNumber = model.Phone;


            if (string.IsNullOrEmpty(model.Id))
            {
                _userManager.CreateAsync(user).Wait();
            }
            else
            {
                _userManager.UpdateAsync(user).Wait();
            }

            if (string.IsNullOrEmpty(model.Id)) // zapis hasla gdy nowy user
            {
                _userManager.AddPasswordAsync(user, model.Password).Wait();
            }

            List <string> roles = new List <string>();

            roles.AddRange(_userManager.GetRolesAsync(user).Result);

            foreach (var role in model.Roles)
            {
                if (!roles.Contains(role))
                {
                    _userManager.AddToRoleAsync(user, role).Wait();
                }
            }

            foreach (var role in roles)
            {
                if (!model.Roles.Contains(role))
                {
                    _userManager.RemoveFromRoleAsync(user, role).Wait();
                }
            }

            return(RedirectToAction("Index"));
        }
コード例 #12
0
        public async Task <string> EditUsario(string id, string userName, string email,
                                              string phoneNumber, int accessFiledCount,
                                              string concurrencyStamp,
                                              bool emailConfirmed,
                                              bool lockoutEnabled,
                                              DateTimeOffset lockoutEnd,
                                              string normalizedUserName,
                                              string normalizedEmail,
                                              string passwordHash,
                                              bool phoneNumberConfirmed,
                                              string securityStamp,
                                              bool twoFactorEnabled, string selectRole, ApplicationUser applicationUser)
        {
            var resp = "";

            try {
                applicationUser = new ApplicationUser
                {
                    Id                   = id,
                    UserName             = userName,
                    Email                = email,
                    PhoneNumber          = phoneNumber,
                    EmailConfirmed       = emailConfirmed,
                    LockoutEnabled       = lockoutEnabled,
                    LockoutEnd           = lockoutEnd,
                    NormalizedEmail      = normalizedEmail,
                    NormalizedUserName   = normalizedUserName,
                    PasswordHash         = passwordHash,
                    PhoneNumberConfirmed = phoneNumberConfirmed,
                    SecurityStamp        = securityStamp,
                    TwoFactorEnabled     = twoFactorEnabled,
                    AccessFailedCount    = accessFiledCount,
                    ConcurrencyStamp     = concurrencyStamp
                };
                //Actializar datos
                _context.Update(applicationUser);
                await _context.SaveChangesAsync();

                //obtemos el usuario
                var usuario = await _userManager.FindByIdAsync(id);

                usuarioRole = await _usuarioRole.GetRole(_userManager, _roleManager, id);

                if (usuarioRole[0].Text != "No Role")
                {
                    await _userManager.RemoveFromRoleAsync(usuario, usuarioRole[0].Text);
                }

                if (selectRole == "No Role")
                {
                    selectRole = "Usuario";
                }

                var resultado = await _userManager.AddToRoleAsync(usuario, selectRole);


                resp = "Save";
            } catch {
                resp = "No Save";
            }
            return(resp);
        }
コード例 #13
0
        public async Task <ActionResult> UserUpdate(ApplicationUser user)
        {
            // Create user if there is no user id
            var existingUser = await UserManager.FindByIdAsync(user.Id);

            if (existingUser == null)
            {
                user.UserName       = user.Email;
                user.Email          = user.Email;
                user.RegisterDate   = DateTime.Now;
                user.RegisterIP     = System.Web.HttpContext.Current.Request.GetVisitorIP();
                user.LastAccessDate = DateTime.Now;
                user.LastAccessIP   = System.Web.HttpContext.Current.Request.GetVisitorIP();

                var result = await UserManager.CreateAsync(user);

                if (!result.Succeeded)
                {
                    AddErrors(result);
                    return(View(user));
                }

                // Update cache
                _dataCacheService.RemoveCachedItem(CacheKeys.Statistics);
            }

            existingUser = await UserManager.FindByIdAsync(user.Id);

            existingUser.FirstName            = user.FirstName;
            existingUser.LastName             = user.LastName;
            existingUser.Gender               = user.Gender;
            existingUser.Rut                  = user.Rut; // nuevo
            existingUser.PhoneNumber          = user.PhoneNumber;
            existingUser.PhoneNumberConfirmed = user.PhoneNumberConfirmed;
            existingUser.Email                = user.Email;
            existingUser.EmailConfirmed       = user.EmailConfirmed;
            existingUser.AcceptEmail          = user.AcceptEmail;
            existingUser.Disabled             = user.Disabled;
            existingUser.CountryID            = user.CountryID;
            existingUser.Bank                 = user.Bank;
            existingUser.AccountType          = user.AccountType;
            existingUser.NumberAccount        = user.NumberAccount;
            existingUser.NameContactPerson    = user.NameContactPerson;
            existingUser.EmailContactPerson   = user.EmailContactPerson;
            existingUser.PhoneContactPerson   = user.PhoneContactPerson;

            // roles handling
            if (user.RoleAdministrator)
            {
                await UserManager.AddToRoleAsync(existingUser.Id, Enum_UserType.Administrator.ToString());
            }
            else
            {
                await UserManager.RemoveFromRoleAsync(existingUser.Id, Enum_UserType.Administrator.ToString());
            }

            if (user.RoleOwner)
            {
                await UserManager.AddToRoleAsync(existingUser.Id, Enum_UserType.Owner.ToString());
            }
            else
            {
                await UserManager.RemoveFromRoleAsync(existingUser.Id, Enum_UserType.Owner.ToString());
            }

            await UserManager.UpdateAsync(existingUser);

            // Update new password if there is one
            var newPassword = Request.Form["Password"].ToString();

            if (!string.IsNullOrEmpty(newPassword))
            {
                var resetToken = await UserManager.GeneratePasswordResetTokenAsync(existingUser.Id);

                await UserManager.ResetPasswordAsync(existingUser.Id, resetToken, newPassword);
            }

            return(RedirectToAction("Users"));
        }
コード例 #14
0
    protected void RoleCheckBox_CheckChanged(object sender, EventArgs e)
    {
        // Reference the CheckBox that raised this event
        CheckBox RoleCheckBox = sender as CheckBox;

        // Get the currently selected user and role
        string selectedUserName = UserList.SelectedValue;
        var um = new UserManager();
        var user = um.FindByName(selectedUserName);
        string roleName = RoleCheckBox.Text;

        // Determine if we need to add or remove the user from this role
        if (RoleCheckBox.Checked)
        {
            // Add the user to the role
            um.AddToRoleAsync(user.Id, roleName);

            // Display a status message
            ActionStatus.Text = string.Format("User {0} was added to role {1}.", selectedUserName, roleName);
        }
        else
        {
            // Remove the user from the role
            um.RemoveFromRoleAsync(user.Id, roleName);

            // Display a status message
            ActionStatus.Text = string.Format("User {0} was removed from role {1}.", selectedUserName, roleName);
        }

        // Refresh the "by role" interface
        DisplayUsersBelongingToRole();
    }
コード例 #15
0
        /// <summary>
        /// remove all current permission for the given user and insert new given permissions. 
        /// </summary>
        /// <param name="newRoles">Accepts a list of RolesName type string</param>
        /// <param name="UserID">Accepts a 128 chr userID type string</param>
        /// <returns></returns>
        public async Task<string> EditbuildingUserPermission(List<string> newRoles, string UserID)
        {
            var result = "";
            var RoleManager = new RoleManager<IdentityRole>(new RoleStore<IdentityRole>(context));
            var UserManager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(context));
            //get all roles for the current user
            List<string> AllRoles = UserManager.GetRoles(UserID).ToList();
            //delete all the roles
            foreach (var item in AllRoles)
            {
                await UserManager.RemoveFromRoleAsync(UserID, item);
            }
            //add new roles 
            foreach (var item in newRoles)
            {
                if (RoleManager.RoleExists(item))
                {
                    await UserManager.AddToRoleAsync(UserID, item);
                }
            }

            return result;

        }
コード例 #16
0
        public virtual async Task <ApplicationIdentityResult> RemoveFromRoleAsync(string userId, string role)
        {
            var identityResult = await _userManager.RemoveFromRoleAsync(userId, role).ConfigureAwait(false);

            return(identityResult.ToApplicationIdentityResult());
        }
コード例 #17
0
        public void AddRemoveUserRole()
        {
            string roleName = string.Format("{0}_{1}", Constants.AccountRoles.AccountTestAdminRole, Guid.NewGuid().ToString("N"));

            using (RoleStore <IdentityRole> rstore = new RoleStore <IdentityRole>())
            {
                var taskAdmin = rstore.CreateAsync(new IdentityRole(roleName));
                taskAdmin.Wait();
                var adminRole = rstore.FindByNameAsync(roleName);
                adminRole.Wait();
            }

            using (UserStore <IdentityUser> store = new UserStore <IdentityUser>())
            {
                using (UserManager <IdentityUser> manager = new UserManager <IdentityUser>(store))
                {
                    var user = User;
                    WriteLineObject <IdentityUser>(user);
                    var userRoleTask = manager.AddToRoleAsync(user.Id, roleName);
                    userRoleTask.Wait();
                    Assert.IsTrue(userRoleTask.Result.Succeeded, string.Concat(userRoleTask.Result.Errors));

                    var rolesTask = manager.GetRolesAsync(user.Id);
                    rolesTask.Wait();
                    Assert.IsTrue(rolesTask.Result.Contains(roleName), "Role not found");

                    var roles2Task = manager.IsInRoleAsync(user.Id, roleName);
                    roles2Task.Wait();
                    Assert.IsTrue(roles2Task.Result, "Role not found");

                    var userRemoveTask = manager.RemoveFromRoleAsync(user.Id, roleName);
                    userRemoveTask.Wait();
                    var rolesTask2 = manager.GetRolesAsync(user.Id);
                    rolesTask2.Wait();
                    Assert.IsFalse(rolesTask2.Result.Contains(roleName), "Role not removed.");

                    try
                    {
                        var t1 = store.AddToRoleAsync(null, roleName);
                        t1.Wait();
                    }
                    catch (AggregateException aggex) {
                        aggex.ValidateAggregateException <ArgumentNullException>();
                    }

                    try
                    {
                        var t2 = store.AddToRoleAsync(user, null);
                        t2.Wait();
                    }
                    catch (AggregateException aggex)
                    {
                        aggex.ValidateAggregateException <ArgumentNullException>();
                    }

                    try
                    {
                        var t3 = store.AddToRoleAsync(user, Guid.NewGuid().ToString());
                        t3.Wait();
                    }
                    catch (AggregateException aggex)
                    {
                        aggex.ValidateAggregateException <ArgumentNullException>();
                    }

                    try
                    {
                        var t4 = store.RemoveFromRoleAsync(null, roleName);
                        t4.Wait();
                    }
                    catch (ArgumentException) { }

                    try
                    {
                        var t5 = store.RemoveFromRoleAsync(user, null);
                        t5.Wait();
                    }
                    catch (ArgumentException) { }

                    try
                    {
                        var t6 = store.GetRolesAsync(null);
                        t6.Wait();
                    }
                    catch (ArgumentException) { }
                }
            }
        }
コード例 #18
0
        public async Task <(bool isSucceed, string message)> UpdateUserAsync(UserDTO model)
        {
            try
            {
                var(isSucceed, message) = (true, "User updated successfully");

                var user = await _userManager.FindByIdAsync(model.Id);

                if (user == null)
                {
                    throw new Exception("User not found");
                }

                user.Email = model.Email;
                if (!string.IsNullOrEmpty(model.Email))
                {
                    user.Email           = model.Email.Trim().ToLower();
                    user.NormalizedEmail = model.Email.Trim().ToUpper();
                    user.EmailConfirmed  = true;
                }
                user.PhoneNumber      = model.Mobile;
                user.TwoFactorEnabled = model.TwoFactorEnabled;

                var userProfile = await _dbContext.UserProfiles.FirstOrDefaultAsync(x => x.UserId == user.Id);

                if (userProfile == null)
                {
                    throw new Exception("User profile not found");
                }

                userProfile.PersonId         = model.UserProfile.PersonId;
                userProfile.LoginAs          = model.UserProfile.LoginAs;
                userProfile.CenterId         = model.UserProfile.CenterId;
                userProfile.ServiceSupplyIds = model.UserProfile.ServiceSupplyIds;

                _dbContext.Entry(userProfile).State = EntityState.Modified;

                var result = await _userManager.UpdateAsync(user);

                if (!result.Succeeded)
                {
                    isSucceed = false;
                    message   = result.Errors.FirstOrDefault().Description;
                }
                else
                {
                    if (!await _userManager.IsInRoleAsync(user, model.Roles.FirstOrDefault()))
                    {
                        var userRoles = await _dbContext.UserRoles.Where(x => x.UserId == user.Id).ToListAsync();

                        if (userRoles.Any())
                        {
                            foreach (var item in userRoles)
                            {
                                var role = await _roleManager.FindByIdAsync(item.RoleId);

                                if (role != null)
                                {
                                    await _userManager.RemoveFromRoleAsync(user, role.Name);
                                }
                            }
                        }

                        foreach (var role in model.Roles)
                        {
                            try
                            {
                                await _userManager.AddToRoleAsync(user, role.Trim().ToLower());
                            }
                            catch { }
                        }
                    }
                    await _dbContext.SaveChangesAsync();
                }

                return(isSucceed, message);
            }
            catch (Exception e)
            {
                return(false, e.Message);
            }
        }
コード例 #19
0
        public async Task <IActionResult> Administration(AdministrationViewModel model, string returnUrl = null)
        {
            ViewData["ReturnUrl"] = returnUrl;
            ViewData["UserName"]  = model.Username;

            var user = await _userManager.FindByNameAsync(model.Username);

            var allManagers = await _userManager.GetUsersInRoleAsync("Manager");

            allManagers = allManagers.Where(m => !m.IsDeleted).ToList();
            var managers          = _managerData.GetManagers(user.Id).Select(m => m.Id).ToList();
            var managerViewModels = new List <UserViewModel>();

            model.Managers   = managerViewModels;
            model.Roles      = _roleManager.GetRolesSelectList();
            model.ManagerIds = managers;
            if (model.IsBanned && model.BanEnd < DateTime.Now)
            {
                ModelState.AddModelError(String.Empty, "زمان وارد شده گذشته است.");
                return(View(model));
            }

            foreach (var manager in allManagers.Where(m => m.Id != user.Id).ToList())
            {
                managerViewModels.Add(new UserViewModel
                {
                    Id        = manager.Id,
                    FirstName = manager.FirstName,
                    LastName  = manager.LastName
                });
            }

            if (user != null)
            {
                user.IsBanned   = model.IsBanned;
                user.BanEndTime = model.BanEnd;
                //removing previous role and adding new one
                var role = _userManager.GetRolesAsync(user).Result.FirstOrDefault();
                if (role != null)
                {
                    await _userManager.RemoveFromRoleAsync(user, role);
                }
                if (model.Role != "Employee")
                {
                    _managerData.DeleteManagers(user.Id);
                }
                else if (model.Role == "Employee")
                {
                    _managerData.UpdateManagers(user.Id, model.ManagerIds);
                }
                await _userManager.AddToRoleAsync(user, model.Role);

                //applying user update
                var result = await _userManager.UpdateAsync(user);

                if (result.Succeeded)
                {
                    return(RedirectToAction("AccountInformation", new { userName = model.Username, returnUrl = returnUrl }));
                }
                ModelState.AddModelError(String.Empty, "مشکل در بروزرسانی اطلاعات کاربر.");
                return(View(model));
            }
            return(View(model));
        }
コード例 #20
0
 public Task <IdentityResult> DeleteRoleFromUserAsync(ApplicationUser user, string role)
 {
     return(_userManager.RemoveFromRoleAsync(user, role));
 }
コード例 #21
0
ファイル: UserController.cs プロジェクト: Rajab97/WEA
        public async Task <IActionResult> Save(UserViewModel model)
        {
            if (model.Id == Guid.Empty)
            {
                var user           = _mapper.Map <User>(model);
                var passwordResult = _accountServiceFacade.GenerateRandomPassword();
                if (!passwordResult.IsSucceed)
                {
                    return(AjaxFailureResult(passwordResult));
                }

                using (var scope = _unitOfWork.CreateScoppedTransaction())
                {
                    var result = await _userManager.CreateAsync(user, passwordResult.Data);

                    if (result.Succeeded)
                    {
                        StringBuilder roles = new StringBuilder();
                        foreach (var roleId in model.Roles[0].Split(','))
                        {
                            var role = await _roleManager.FindByIdAsync(roleId);

                            if (role.IsSuperAdmin)
                            {
                                user.IsAdmin = true;
                            }

                            var roleResult = await _userManager.AddToRoleAsync(user, role.Name);

                            if (!roleResult.Succeeded)
                            {
                                return(AjaxFailureResult(SharedKernel.Result.Failure($"{role.Name} adlı rol əlavə oluna bilmədi")));
                            }

                            roles.Append(role.Name + ", ");
                        }
                        user.DN_RoleNames = roles.ToString().Trim().Substring(0, roles.Length - 2);
                        var updateResult = await _userManager.UpdateAsync(user);

                        var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);

                        var base64String = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
                        var callBackUrl  = Url.Action(nameof(AccountController.EmailConfirmation), AccountController.Name, new { area = AccountController.Area, code = base64String, userId = user.Id }, Request.Scheme);
                        await _emailService.SendEmailAsync(user.Email, "WEA email təsdiqlə",
                                                           $"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callBackUrl)}'>clicking here</a>. Your password is {passwordResult.Data}.");

                        var fileResult = await _fileService.UploadAsync(new Presentation.Models.AttachmentViewModel()
                        {
                            ProductId    = user.Id,
                            Base64String = model.Base64String,
                            ContentType  = model.ContentType,
                            FileName     = model.FileName
                        });

                        if (fileResult.IsSucceed)
                        {
                            await _unitOfWork.CommitAsync();
                        }
                        else
                        {
                            return(AjaxFailureResult(fileResult));
                        }

                        /*if (_userManager.Options.SignIn.RequireConfirmedEmail)
                         * {
                         *  return RedirectToAction(nameof(AccountController.RequireConfirmedEmail), AccountController.Name, new { area = AccountController.Area });
                         * }
                         * else
                         * {
                         *  await _signInManager.SignInAsync(user, isPersistent: false);
                         *  return RedirectToAction(nameof(Index));
                         * }*/
                        return(RedirectToAction(nameof(Index)));
                    }
                }
            }
            else
            {
                var exUser = await _userManager.FindByIdAsync(model.Id.ToString());

                string previouseRoles = exUser.Roles;
                var    updatedValues  = _mapper.Map(model, exUser);
                if (previouseRoles != updatedValues.Roles)
                {
                    foreach (var roleName in await _userManager.GetRolesAsync(exUser))
                    {
                        var roleResult = await _userManager.RemoveFromRoleAsync(exUser, roleName);

                        if (!roleResult.Succeeded)
                        {
                            return(AjaxFailureResult(SharedKernel.Result.Failure($"{roleName} adlı rol silinə bilmədi")));
                        }
                    }
                    StringBuilder roles = new StringBuilder();
                    updatedValues.IsAdmin = false;
                    foreach (var roleId in model.Roles[0].Split(','))
                    {
                        var role = await _roleManager.FindByIdAsync(roleId);

                        if (role.IsSuperAdmin)
                        {
                            updatedValues.IsAdmin = true;
                        }
                        var roleResult = await _userManager.AddToRoleAsync(updatedValues, role.Name);

                        if (!roleResult.Succeeded)
                        {
                            return(AjaxFailureResult(SharedKernel.Result.Failure($"{role.Name} adlı rol əlavə oluna bilmədi")));
                        }

                        roles.Append(role.Name + ", ");
                    }
                    updatedValues.DN_RoleNames = roles.ToString().Trim().Substring(0, roles.Length - 2);
                }
                var result = await _userManager.UpdateAsync(updatedValues);

                if (result.Succeeded)
                {
                    return(RedirectToAction(nameof(Index)));
                }
            }

            return(Content("Error"));
        }
コード例 #22
0
        public async Task <IActionResult> Put(string id, [FromBody] string value)
        {
            string        databaseInnerExceptionMessage = "";
            var           userChangeInput = JsonConvert.DeserializeObject <dynamic>(value);
            List <object> messages        = new List <object>();
            bool          status          = true; //This variable is used to track the overall success of all the database operations
            object        response;
            //http://stackoverflow.com/questions/20444022/updating-user-data-asp-net-identity
            //Database is our database context set in this controller.
            //I used the following 2 lines of command to create a userStore which represents AspNetUser table in the DB.
            var userStore = new UserStore <ApplicationUser>(Database);
            //Then, I created a userManager instance that operates on the userStore.
            var userManager = new UserManager <ApplicationUser>(userStore, null, null, null, null, null, null, null, null);

            //To obtain the full name information, use student.FullName.value
            //To obtain the email information, use student.Email.value
            var oneUser = Database.Users
                          .Where(item => item.Id == id).Include(p => p.Roles).FirstOrDefault();


            //The following code to obtain the role name are asynchronous and not reliable.
            //Doing a bypass by leveraging on the client-side JavaScript.
            // var newRoleNameToAdd =  identityRoleManager.FindByIdAsync(user.RoleId.Value).Result;
            // var existingRoleNameToRemove =   identityRoleManager.FindByIdAsync(oneUser.Roles.First().RoleId).Result;



            oneUser.UserName = userChangeInput.userName;
            oneUser.FullName = userChangeInput.fullName.Value;
            oneUser.Email    = userChangeInput.email.Value;


            try {
                //Although the command below correct but violated foreign key constraint
                //Must let the UserManager instance, userManager do the job.
                //oneUser.Roles.FirstOrDefault().RoleId = user.roleId.Value;

                //All the following 3 method calls are asynchronous. Notice that I delcared the Put method as Asynchronous method too.
                //http://stackoverflow.com/questions/20444022/updating-user-data-asp-net-identity has some hints how to define the return
                //type of this Put method here. Also, notice that I applied a technique to make these 3 asynchronous calls to become synchronous.

                //Remove existing role from the user
                var removeRoleFromUserResult = userManager.RemoveFromRoleAsync(oneUser, userChangeInput.originalRoleName.Value).Result;
                //Add the new role to the user.
                var addRoleToUserResult = userManager.AddToRoleAsync(oneUser, userChangeInput.selectedRoleName.Value).Result;
                //Update the
                var updateUserResult = userManager.UpdateAsync(oneUser).Result;

                try
                {
                    //Changes are not persisted in the database until
                    //I use the following command.
                    userStore.Context.SaveChanges();
                }
                catch (DbUpdateException ex)
                {
                    databaseInnerExceptionMessage = ex.InnerException.Message;
                    status = false;
                    messages.Add(databaseInnerExceptionMessage);
                }



                if (removeRoleFromUserResult.Succeeded != true)
                {
                    status = false;
                    messages.Add(removeRoleFromUserResult);
                }
                if (addRoleToUserResult.Succeeded != true)
                {
                    status = false;
                    messages.Add(addRoleToUserResult);
                }
                if (updateUserResult.Succeeded != true)
                {
                    status = false;
                    messages.Add(updateUserResult);
                }
                if (status == true)
                {
                    response = new { status = "success", message = "Saved user record." };
                }
                else
                {
                    response = new { status = "fail", message = messages };
                }
            }catch (Exception outerException)
            {
                response = new { status = "fail", message = outerException.InnerException.Message };
            }
            return(new JsonResult(response));
        }//End of Put()
コード例 #23
0
 public async Task <IdentityResult> RemoveFromRoleAsync(string user, string roleName)
 {
     return(await manager.RemoveFromRoleAsync(user, roleName));
 }
コード例 #24
0
ファイル: AccountController.cs プロジェクト: rh24/paw-lease
        public async Task <IActionResult> EditProfile(RegisterAccount ra)
        {
            if (_signInManager.IsSignedIn(User))
            {
                // Get signed in user
                var user = await _userManager.GetUserAsync(HttpContext.User);

                // Remove all associated claims from current user's identity
                await _userManager.RemoveClaimsAsync(user, HttpContext.User.Claims);

                // Add newly updated claims and sign user back in
                if (ModelState.IsValid)
                {
                    // update user's info
                    user.UserName  = ra.Email;
                    user.FirstName = ra.FirstName;
                    user.LastName  = ra.LastName;
                    user.Email     = ra.Email;
                    user.Address   = ra.Address;
                    user.Birthday  = ra.Birthday;
                    user.LovesCats = ra.LovesCats;

                    // Reset password of user
                    string resetToken = await _userManager.GeneratePasswordResetTokenAsync(user);

                    await _userManager.ResetPasswordAsync(user, resetToken, ra.Password);

                    var updatedResult = await _userManager.UpdateAsync(user);

                    if (updatedResult.Succeeded)
                    {// Custom Claim type for full name
                        Claim fullNameClaim = new Claim("FullName", $"{user.FirstName} {user.LastName}");

                        // Custom claim type for loves cats
                        Claim lovesCatsClaim = new Claim("LovesCats", user.LovesCats.ToString().ToLower());

                        // claim type for birthday
                        Claim birthdayClaim = new Claim(
                            ClaimTypes.DateOfBirth,
                            new DateTime(user.Birthday.Year, user.Birthday.Month, user.Birthday.Day).ToString("u"), ClaimValueTypes.DateTime);

                        // claim type for email
                        Claim emailClaim = new Claim(ClaimTypes.Email, user.Email, ClaimValueTypes.Email);

                        // claim for  type address
                        Claim addressClaim = new Claim(ClaimTypes.StreetAddress, user.Address);

                        List <Claim> myclaims = new List <Claim>()
                        {
                            fullNameClaim,
                            birthdayClaim,
                            emailClaim,
                            addressClaim,
                            lovesCatsClaim
                        };

                        // adds the claims
                        await _userManager.AddClaimsAsync(user, myclaims);

                        // make admins if emails are these
                        if (ra.Email.ToLower() == "*****@*****.**" || ra.Email.ToLower() == "*****@*****.**" || ra.Email.ToLower() == "*****@*****.**")
                        {
                            await _userManager.AddToRoleAsync(user, UserRoles.Admin);
                        }
                        else
                        {
                            await _userManager.RemoveFromRoleAsync(user, UserRoles.Admin);
                        }
                        await _userManager.AddToRoleAsync(user, UserRoles.Member);

                        await _signInManager.RefreshSignInAsync(user);
                    }
                }
            }

            return(RedirectToAction("Index", "Home"));
        }
コード例 #25
0
        public async Task <IActionResult> EditUser(string id, EditUserViewModel model)
        {
            if (ModelState.IsValid)
            {
                AppUser applicationUser = await _userManager.FindByIdAsync(id);

                if (applicationUser != null && applicationUser.Email != "*****@*****.**")
                {
                    applicationUser.Email = model.Email;
                    List <SelectListItem> userClaims = new List <SelectListItem>();
                    try
                    {
                        IList <Claim> claims = await _userManager.GetClaimsAsync(applicationUser);

                        userClaims = model
                                     .UserClaims
                                     .Where(c => c.Selected && !claims
                                            .Any(u => u.Value == c.Value))
                                     .ToList();
                        List <Claim> userRemoveClaims = claims
                                                        .Where(c => model
                                                               .UserClaims
                                                               .Any(u => u.Value == c.Value && !u.Selected))
                                                        .ToList();
                        foreach (Claim claim in userRemoveClaims)
                        {
                            await _userManager.RemoveClaimAsync(applicationUser, claim);
                        }
                    }
                    catch
                    {
                        userClaims = model.UserClaims.Where(u => u.Selected).ToList();
                    }
                    foreach (var claim in userClaims)
                    {
                        applicationUser.Claims.Add(new IdentityUserClaim <string>
                        {
                            ClaimType  = claim.Value,
                            ClaimValue = claim.Value
                        });
                    }
                    IdentityResult result = await _userManager.UpdateAsync(applicationUser);

                    if (result.Succeeded)
                    {
                        try
                        {
                            string existingRole   = _userManager.GetRolesAsync(applicationUser).Result.Single();
                            string existingRoleId = _roleManager.Roles.Single(r => r.Name == existingRole).Id;
                            if (existingRoleId != model.AppRoleId)
                            {
                                IdentityResult roleResult = await _userManager.RemoveFromRoleAsync(applicationUser, existingRole);

                                if (roleResult.Succeeded)
                                {
                                    AppRole applicationRole = await _roleManager.FindByIdAsync(model.AppRoleId);

                                    if (applicationRole != null)
                                    {
                                        IdentityResult newRoleResult = await _userManager.AddToRoleAsync(applicationUser, applicationRole.Name);

                                        if (newRoleResult.Succeeded)
                                        {
                                            return(RedirectToAction("Index"));
                                        }
                                    }
                                }
                            }
                        }
                        catch
                        {
                            AppRole applicationRole = await _roleManager.FindByIdAsync(model.AppRoleId);

                            if (applicationRole != null)
                            {
                                IdentityResult newRoleResult = await _userManager.AddToRoleAsync(applicationUser, applicationRole.Name);

                                if (newRoleResult.Succeeded)
                                {
                                    return(RedirectToAction("Index"));
                                }
                            }
                        }
                    }
                }
            }
            return(RedirectToAction("Index"));
        }
コード例 #26
0
        public override async Task <IDisplayResult> UpdateAsync(User user, UpdateEditorContext context)
        {
            var model = new EditUserViewModel();

            if (!await context.Updater.TryUpdateModelAsync(model, Prefix))
            {
                return(Edit(user));
            }

            model.UserName = model.UserName?.Trim();
            model.Email    = model.Email?.Trim();

            if (await IsNewUser(model.Id))
            {
                if (model.Password != model.PasswordConfirmation)
                {
                    context.Updater.ModelState.AddModelError(nameof(model.PasswordConfirmation), T["Password and Password Confirmation do not match"]);
                }

                if (!context.Updater.ModelState.IsValid)
                {
                    return(Edit(user));
                }

                var roleNames = model.Roles.Where(x => x.IsSelected).Select(x => x.Role).ToArray();
                await _userService.CreateUserAsync(model.UserName, model.Email, roleNames, model.Password, (key, message) => context.Updater.ModelState.AddModelError(key, message));
            }
            else
            {
                var userWithSameName = await _userManager.FindByNameAsync(model.UserName);

                if (userWithSameName != null)
                {
                    var userWithSameNameId = await _userManager.GetUserIdAsync(userWithSameName);

                    if (userWithSameNameId != model.Id)
                    {
                        context.Updater.ModelState.AddModelError(string.Empty, T["The user name is already used."]);
                    }
                }

                var userWithSameEmail = await _userManager.FindByEmailAsync(model.Email);

                if (userWithSameEmail != null)
                {
                    var userWithSameEmailId = await _userManager.GetUserIdAsync(userWithSameEmail);

                    if (userWithSameEmailId != model.Id)
                    {
                        context.Updater.ModelState.AddModelError(string.Empty, T["The email is already used."]);
                    }
                }

                if (context.Updater.ModelState.IsValid)
                {
                    var roleNames = model.Roles.Where(x => x.IsSelected).Select(x => x.Role).ToList();
                    await _userManager.SetUserNameAsync(user, model.UserName);

                    await _userManager.SetEmailAsync(user, model.Email);

                    // Remove roles in two steps to prevent an iteration on a modified collection
                    var rolesToRemove = new List <string>();
                    foreach (var role in await _userManager.GetRolesAsync(user))
                    {
                        if (!roleNames.Contains(role))
                        {
                            rolesToRemove.Add(role);
                        }
                    }

                    foreach (var role in rolesToRemove)
                    {
                        await _userManager.RemoveFromRoleAsync(user, role);
                    }

                    // Add new roles
                    foreach (var role in roleNames)
                    {
                        if (!await _userManager.IsInRoleAsync(user, role))
                        {
                            await _userManager.AddToRoleAsync(user, role);
                        }
                    }

                    var result = await _userManager.UpdateAsync(user);

                    foreach (var error in result.Errors)
                    {
                        context.Updater.ModelState.AddModelError(string.Empty, error.Description);
                    }
                }
            }

            return(Edit(user));
        }
コード例 #27
0
        public async Task <IActionResult> EditAccount(EditViewModel model)
        {
            var result = true;
            var user   = await _userManager.FindByIdAsync(model.Id);

            model.Roles = new List <Role>();

            if (ModelState.IsValid)
            {
                user.Active         = model.Active;
                user.PhoneNumber    = model.PhoneNumber;
                user.EmailConfirmed = model.EmailConfirmed;

                // Password
                if (!string.IsNullOrEmpty(model.NewPassword))
                {
                    var validNewPassword = _passwordValidator.ValidateAsync(_userManager, user, model.NewPassword);
                    if (validNewPassword.Result.Succeeded)
                    {
                        user.PasswordHash = _passwordHasher.HashPassword(user, model.NewPassword);
                    }
                    else
                    {
                        var message = validNewPassword.Result.Errors.First().Description;
                        ModelState.AddModelError(nameof(model.NewPassword), message);
                        result = false;
                    }
                }

                // Roles
                var userRoles = await _userManager.GetRolesAsync(user);

                foreach (var role in userRoles)
                {
                    await _userManager.RemoveFromRoleAsync(user, role);
                }

                if (model.IdRolesToAdd != null)
                {
                    foreach (var role in model.IdRolesToAdd)
                    {
                        await _userManager.AddToRoleAsync(user, role);
                    }
                }

                // Usuario
                if (user.UserName != model.UserName || user.Email != model.Email)
                {
                    var copyUserName = user.UserName;
                    var copyEmail    = user.Email;

                    user.UserName = model.UserName;
                    user.Email    = model.Email;
                    var validUser = await _userValidator.ValidateAsync(_userManager, user);

                    if (!validUser.Succeeded)
                    {
                        result        = false;
                        user.UserName = copyUserName;
                        user.Email    = copyEmail;
                        _addErrorsFromResult(validUser);
                    }
                }

                if (result is true)
                {
                    await _userManager.UpdateAsync(user);

                    this.AddMessage("success", "Datos guardados con éxito");
                    return(RedirectToAction(nameof(Index)));
                }
            }
            await _setRolesInModelView(model, user);

            return(View(model));
        }
コード例 #28
0
ファイル: BookflixUser.cs プロジェクト: juampinp/Bookflix
        //Métodos

        public async Task ChangeRole(UserManager <BookflixUser> userManager, string newRole, string previousRole)
        {
            await userManager.RemoveFromRoleAsync(this, previousRole);

            await userManager.AddToRoleAsync(this, newRole);
        }
コード例 #29
0
        public async Task <IActionResult> OnPostAsync(string returnUrl = null)
        {
            returnUrl = returnUrl ?? Url.Content("~/");

            if (_signInManager.IsSignedIn(User))
            {
                return(LocalRedirect(returnUrl));
            }

            ExternalLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync()).ToList();
            if (ModelState.IsValid)
            {
                var user = new User
                {
                    isExternal  = false,
                    Email       = Input.Email,
                    UserName    = StringHelper.GetUntilOrEmpty(Input.Email, "@"),
                    PictureName = null
                };



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

                if (result.Succeeded)
                {
                    _logger.LogInformation("User created a new account with password.");

                    var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);

                    var email = await _userManager.GetEmailAsync(user);

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

                    await _senderService.SendEmailAsync(email,
                                                        "Потвърди емайл адрес",
                                                        $"<a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>Потвърждаване</a>.");

                    var count = await _userManager.Users.CountAsync().ConfigureAwait(false);

                    if (count == 1)
                    {
                        await CreateRole();

                        await _userManager.AddToRoleAsync(user, "Admin");

                        await _userManager.RemoveFromRoleAsync(user, "User");

                        user.profileConfirmed = true;
                        user.EmailConfirmed   = true;
                        user.Role             = Roles.Admin;
                    }
                    else
                    {
                        await _userManager.AddToRoleAsync(user, "User");

                        user.Role = Roles.User;
                    }


                    await _notifyService.Create("Моля попълнете личните си данни.", "identity/account/manage/editprofile", DateTime.Now, NotifyType.Information, "fas fa-edit", user);

                    _baseService.ToastNotify(ToastMessageState.Alert, "Детайли", "Моля попълнете личните си данни.", 9000);
                    _baseService.ToastNotify(ToastMessageState.Success, "Успешно", "се регистрирахте. Благодарим ви за отделеното време !", 5000);

                    if (_userManager.Options.SignIn.RequireConfirmedAccount)
                    {
                        return(RedirectToPage("RegisterConfirmation", new { email = Input.Email, returnUrl = returnUrl }));
                    }
                    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());
        }
コード例 #30
0
        public async Task <IActionResult> OnPostAsync()
        {
            bool error = false;

            if (AssignedRoles != null)
            {
                Dictionary <SiteUser, List <string> > assignments = new Dictionary <SiteUser, List <string> >();

                foreach (string str in AssignedRoles)
                {
                    string userId = str.Split(":")[0];
                    string roleId = str.Split(":")[1];

                    SiteUser user = await _userManager.FindByIdAsync(userId);

                    IdentityRole role = await _roleManager.FindByIdAsync(roleId);

                    if (!assignments.ContainsKey(user))
                    {
                        assignments.Add(user, new List <string>());
                    }

                    assignments[user].Add(role.Name);
                }

                IList <SiteUser> users = await _userManager.Users.ToListAsync();

                IList <IdentityRole> roles = await _roleManager.Roles.ToListAsync();

                foreach (var user in users)
                {
                    IList <string> existingRoles = await _userManager.GetRolesAsync(user);

                    List <string> assignedRoles = assignments.Keys.Contains(user) ? assignments[user] : new List <string>();
                    List <string> combined      = existingRoles.Union(assignedRoles).ToList();

                    foreach (var role in roles)
                    {
                        if (existingRoles.Contains(role.Name) && !assignedRoles.Contains(role.Name))
                        {
                            await _userManager.RemoveFromRoleAsync(user, role.Name);
                        }

                        if (assignedRoles.Contains(role.Name) && !existingRoles.Contains(role.Name))
                        {
                            await _userManager.AddToRoleAsync(user, role.Name);
                        }
                    }
                }
            }

            // TODO: Handle errors better.

            if (!error)
            {
                return(RedirectToPage("./Index"));
            }
            else
            {
                return(BadRequest());
            }
        }
コード例 #31
0
        public async Task RemoveARole(UserRolePairModel pairing)
        {
            var user = await userManager.FindByIdAsync(pairing.UserId);

            await userManager.RemoveFromRoleAsync(user, pairing.RoleName);
        }
コード例 #32
0
        public async Task UnAssignRole(string role, string username)
        {
            AppUser user = await userManager.Users.FirstOrDefaultAsync(x => x.UserName == username) as AppUser;

            var result = await userManager.RemoveFromRoleAsync(user, role);
        }
コード例 #33
0
 public async Task RemoveUserFromRoleAsync(User user, string roleName)
 {
     await _userManager.RemoveFromRoleAsync(user, roleName);
 }
コード例 #34
0
        public async Task <Result> RemoveRoleFromUserAsync(AppUser user, string role)
        {
            var result = await _userManager.RemoveFromRoleAsync(user, role);

            return(result.ToApplicationResult());
        }
コード例 #35
0
        public async Task<ActionResult> DeleteConfirmed(string id) {

            var roleStore = new RoleStore<IdentityRole>(db);
            var roleManager = new RoleManager<IdentityRole>(roleStore);

            var userStore = new UserStore<ApplicationUser>(db);
            var userManager = new UserManager<ApplicationUser>(userStore);

            if (ModelState.IsValid) {
                if (id == null) {
                    return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
                }

                var user = await userManager.FindByIdAsync(id);
                
                // ev. 3parts inloggningar
                var logins = user.Logins;
                foreach (var login in logins.ToList()) {
                    await userManager.RemoveLoginAsync(login.UserId, new UserLoginInfo(login.LoginProvider, login.ProviderKey));
                }

                var rolesForUser = await userManager.GetRolesAsync(id);

                if (rolesForUser.Count() > 0) {
                    foreach (var item in rolesForUser.ToList()) {
                        // item should be the name of the role
                        var result = await userManager.RemoveFromRoleAsync(user.Id, item);
                    }
                }

                if (user.Documents.Count() > 0) {
                    foreach (var doc in user.Documents.ToList()) {
                        db.Documents.Remove(doc);
                    }
                }

                await userManager.DeleteAsync(user);

                return RedirectToAction("Index");
            }
            else {
                return View();
            }
        }
コード例 #36
0
        //
        // GET: /Admin/RemoveUserRole:id [id = "roleName-userName"]
        public async Task <IActionResult> RemoveUserRole(string id)
        {
            if (id == null)
            {
                AddError("Error");
                return(RedirectToAction(nameof(AdminController.Index), "Admin"));
            }
            if (id.Length == 0)
            {
                AddError("Error");
                return(RedirectToAction(nameof(AdminController.Index), "Admin"));
            }
            var idParts = id.Split('-');

            //Se comprueba que la id este compuesta de dos partes desde un guión de división.
            if (idParts.Length != 2)
            {
                AddError("Error");
                return(RedirectToAction(nameof(AdminController.Index), "Admin"));
            }
            var roleName = idParts[0];
            var userName = idParts[1];

            if (roleName.Length == 0)
            {
                AddError("Error");
            }
            if (userName.Length == 0)
            {
                AddError("Error");
            }
            //Devuelve un usuario especifico a raiz de su nombre de usuario unico
            var user = _userManager.Users.FirstOrDefault(u => u.UserName == userName);

            if (user == null)
            {
                AddError("Error");
                return(RedirectToAction(nameof(AdminController.Index), "Admin"));
            }
            //Devuelve un rol especifico a raiz del nombre de este rol
            var role = _roleManager.Roles.FirstOrDefault(r => r.Name == roleName);

            if (role == null)
            {
                AddError("Error");
                return(RedirectToAction(nameof(AdminController.Index), "Admin"));
            }
            //Comprueba si el usuario esta en el rol especificado
            if (!await _userManager.IsInRoleAsync(user, role.Name))
            {
                AddError("Error");
                return(RedirectToAction(nameof(AdminController.Index), "Admin"));
            }
            //Eliminar al usuario del rol
            await _userManager.RemoveFromRoleAsync(user, roleName);

            //Cierra la sesión del usuario
            await CloseUserSession(userName);

            return(RedirectToAction(nameof(AdminController.DetailsRole) + $"/{idParts[0]}", "Admin"));
        }