Пример #1
0
        public IHttpActionResult MakeUserAdmin(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 allready admin", user.UserName));
            }

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

            this.Data.SaveChanges();

            return this.Ok(string.Format("user: {0} is admin", user.UserName));

        }
Пример #2
0
        // ASPNET identity gives us a userManager
        public static async Task SeedUsers(UserManager <AppUser> userManager,
                                           RoleManager <AppRole> roleManager)
        {
            // don't seed the db if it already has users
            if (await userManager.Users.AnyAsync())
            {
                return;
            }

            var userData = await System.IO.File.ReadAllTextAsync("Data/UserSeedData.json");

            var users = JsonSerializer.Deserialize <List <AppUser> >(userData);

            if (users == null)
            {
                return;
            }

            // prepare to apply roles to the seeded users.
            var roles = new List <AppRole>
            {
                new AppRole {
                    Name = "Member"
                },
                new AppRole {
                    Name = "Admin"
                },
                new AppRole {
                    Name = "Moderator"
                },
            };

            // create these roles and save them to db
            foreach (var role in roles)
            {
                await roleManager.CreateAsync(role);
            }
            ;

            // note that this is just seed data for development purposes
            // now create the users and also assign them a role as member.
            foreach (var user in users)
            {
                // set the initial photo to approved for seed users
                user.Photos.First().IsApproved = true;
                user.UserName = user.UserName.ToLower();

                // tell entity framework to track this new user (refactored to include userManager from ASPNET identity which takes care of saving it to the db)
                // await context.Users.AddAsync(user);

                // EF tracks and saves to DB here under ASPNET identity
                await userManager.CreateAsync(user, "Pa$$w0rd");

                await userManager.AddToRoleAsync(user, "Member");
            }
            // now we async save this to the db. (refactored to include userManager from ASPNET identity which takes care of saving it to the db)
            // await context.SaveChangesAsync();

            // now, for dev purposes, seed an admin.
            var admin = new AppUser
            {
                UserName = "******"
            };

            // save the admin to the db. Then given them the role of Admin and Moderator.
            await userManager.CreateAsync(admin, "Pa$$w0rd");

            await userManager.AddToRolesAsync(admin, new[] { "Admin", "Moderator" });
        }
Пример #3
0
        /// <summary>Seeds the users.</summary>
        /// <param name="userManager">The user manager.</param>
        /// <param name="roleManager">The role manager.</param>
        public static async Task SeedUsers(UserManager <AppUser> userManager, RoleManager <AppRole> roleManager)
        {
            // fetch-uje sve korisnike
            if (await userManager.Users.AnyAsync())
            {
                return;
            }

            // cita sve iz JSON-a
            var userData = await System.IO.File.ReadAllTextAsync("Data/UserSeedData.json");

            // prebacuje u AppUser oblik
            var users = JsonSerializer.Deserialize <List <AppUser> >(userData);

            if (users == null)
            {
                return;
            }

            var roles = new List <AppRole>
            {
                new AppRole {
                    Name = "Member"
                },
                new AppRole {
                    Name = "Admin"
                },
                new AppRole {
                    Name = "Moderator"
                }
            };

            foreach (var role in roles)
            {
                await roleManager.CreateAsync(role);
            }

            foreach (var user in users)
            {
                // prebacuje username u mala slova
                user.UserName = user.UserName.ToLower();

                // dodaje korisnika
                // await context.Users.AddAsync(user);
                await userManager.CreateAsync(user, "Passw0rd");

                await userManager.AddToRoleAsync(user, "Member");
            }

            var admin = new AppUser
            {
                UserName = "******"
            };

            await userManager.CreateAsync(admin, "Passw0rd");

            await userManager.AddToRolesAsync(admin, new[] { "Admin", "Moderator" });

            //// cuva u bazi
            //// await context.SaveChangesAsync();
        }
        public static async Task SeedUsersAsync(UserManager <AppUser> userManager, RoleManager <AppRole> roleManager)
        {
            if (await userManager.Users.AnyAsync())
            {
                return;
            }

            #region seed roles
            var roles = new List <AppRole>
            {
                new AppRole {
                    Name = "Member"
                },
                new AppRole {
                    Name = "Admin"
                },
                new AppRole {
                    Name = "Moderator"
                },
            };

            foreach (var role in roles)
            {
                await roleManager.CreateAsync(role);
            }

            #endregion


            #region seed users
            // get list of users to seed into DB
            var userRawData = await System.IO.File.ReadAllTextAsync("Data/UserSeedData.json");

            var users = JsonSerializer.Deserialize <List <AppUser> >(userRawData);

            if (users == null)
            {
                return;
            }


            foreach (var user in users)
            {
                user.UserName = user.UserName.ToLower();

                // add password for each user, and add them to DBContext one by one
                await userManager.CreateAsync(user, "P@ssw0rd");

                // add current user to named role
                await userManager.AddToRoleAsync(user, "Member");
            }

            #endregion


            #region seed admin
            var admin = new AppUser
            {
                UserName = "******",
            };

            await userManager.CreateAsync(admin, "P@ssw0rd");

            await userManager.AddToRolesAsync(admin, new List <string> {
                "Admin", "Moderator"
            });

            #endregion
        }
        public async Task <ActionResult> Create(RegisterViewModel userViewModel, HttpPostedFileBase filename, params string[] selectedRoles)
        {
            if (!IsLoggedIn())
            {
                return(RedirectToAction("login", "account"));
            }
            if (ModelState.IsValid)
            {
                var user = new ApplicationUser();
                if (!System.IO.Directory.Exists(AppDomain.CurrentDomain.BaseDirectory + "/Images/UserProfileImage/"))
                {
                    System.IO.Directory.CreateDirectory(AppDomain.CurrentDomain.BaseDirectory + "/Images/UserProfileImage/");
                }
                if (!System.IO.Directory.Exists(AppDomain.CurrentDomain.BaseDirectory + "/Images/UserProfileImage/deleted"))
                {
                    System.IO.Directory.CreateDirectory(AppDomain.CurrentDomain.BaseDirectory + "/Images/UserProfielImage/deleted");
                }
                var postedFile = Request.Files[0];
                if (postedFile.ContentLength > 0)
                {
                    if (postedFile.ContentType.ToLower() != "image/jpg" && postedFile.ContentType.ToLower() != "image/png" && postedFile.ContentType.ToLower() != "image/gif" && postedFile.ContentType.ToLower() != "image/jpeg")
                    {
                        ModelState.AddModelError("customer.profileimage", "Sorry, file format must be jpg or jpeg or png or gif");
                    }

                    if (ModelState.IsValid)
                    {
                        var imagapath        = ConfigurationManager.AppSettings["userimagepath"].ToString();
                        var deletedimagepath = ConfigurationManager.AppSettings["deleteduserimagepath"].ToString();
                        var oldfile          = user.ProfileImage;
                        var oldfileExt       = Path.GetExtension(oldfile);
                        var fileExt          = Path.GetExtension(postedFile.FileName);
                        var oldfileName      = user.ProfileImage;
                        var oldpath          = Path.Combine(Server.MapPath(imagapath) + oldfileName + oldfileExt);
                        var fileName         = user.Id;
                        var deleltedfielname = fileName + DateTime.Now.ToString("yyyyMMddHHmmssfff");
                        var path             = Path.Combine(Server.MapPath(imagapath) + fileName + fileExt);
                        deletedimagepath = Path.Combine(Server.MapPath(deletedimagepath + deleltedfielname + fileExt));
                        if (System.IO.File.Exists(oldpath))
                        {
                            System.IO.File.Move(oldpath, deletedimagepath);
                        }
                        postedFile.SaveAs(path);
                        user.ProfileImage = fileName + fileExt;
                    }
                }
                user = new ApplicationUser {
                    UserName = userViewModel.Email, Email = userViewModel.Email, FirstName = userViewModel.FirstName, LastName = userViewModel.LastName, Address = userViewModel.Address, City = userViewModel.City, StateId = userViewModel.StateId, CountryId = userViewModel.CountryId, Zip = userViewModel.Zip, Phone = userViewModel.Phone, Mobile = userViewModel.Mobile, isactive = true
                };
                var adminresult = await UserManager.CreateAsync(user, userViewModel.Password);

                //Add User to the selected Roles
                if (adminresult.Succeeded)
                {
                    if (selectedRoles != null)
                    {
                        var result = await UserManager.AddToRolesAsync(user.Id, selectedRoles);

                        if (!result.Succeeded)
                        {
                            ModelState.AddModelError("", result.Errors.First());
                            ViewBag.RoleId = new SelectList(await RoleManager.Roles.ToListAsync(), "Name", "Name");
                            return(View());
                        }
                    }
                }
                else
                {
                    ViewBag.countrylist = new SelectList(db.Country, "id", "nicename");
                    ViewBag.statelist   = new SelectList(db.State, "id", "name");
                    ModelState.AddModelError("", adminresult.Errors.First());
                    ViewBag.RoleId = new SelectList(RoleManager.Roles, "Name", "Name");

                    return(View());
                }
                return(RedirectToAction("Index"));
            }
            ViewBag.countrylist = new SelectList(db.Country, "id", "nicename");
            ViewBag.statelist   = new SelectList(db.State, "id", "name");
            ViewBag.RoleId      = new SelectList(RoleManager.Roles, "Name", "Name");

            return(View());
        }
Пример #6
0
        public async Task <bool> CreateUserGroupnUserRole(User user, string groupName, bool IshallBeGpAdmin)
        {
            Group grp = new Group();


            //check if group already exists
            bool grpAlreadyExist = _dataContext.Groups.Any(kk => kk.Name == groupName);

            if (grpAlreadyExist)
            {
                grp = await _dataContext.Groups.FirstOrDefaultAsync(kk => kk.Name == groupName);

                //return grp;
            }
            else
            {
                grp.Name = groupName;
            }

            // add user to groups
            // create User Group and then add to group

            UserGroup userGroup = new UserGroup();

            userGroup.User    = user;
            userGroup.UserId  = user.Id;
            userGroup.GroupId = grp.Id;
            userGroup.Group   = grp;

            RoleGroup roleGroup = new RoleGroup();

            roleGroup.UserId  = user.Id;
            roleGroup.GroupId = grp.Id;
            roleGroup.Group   = grp;


            int  roleId;
            Role role = new Role();

            // create role _Gp_Admin

            if (IshallBeGpAdmin)
            {
                role = await _roleManager.FindByNameAsync("_Gp_Admin");

                roleId = role.Id;
            }
            else
            {
                role = await _roleManager.FindByNameAsync("_Gp_Member");

                roleId = role.Id;
            }
            var currentUserRoles = await _userManager.GetRolesAsync(user);

            if (!currentUserRoles.Contains(role.Name))
            {
                IList <string> newrole = new List <string>();
                newrole.Add(role.Name);
                var result = await _userManager.AddToRolesAsync(user, newrole);
            }

            //add role to rolegroup

            roleGroup.Role   = role;
            roleGroup.RoleId = roleId;
            _dataContext.UserGroups.AddAsync(userGroup).Wait();
            _dataContext.RoleGroups.AddAsync(roleGroup).Wait();

            grp.GroupRoles.Add(roleGroup);
            grp.GroupUsers.Add(userGroup);

            // if group already exist then it has to be updated
            if (!grpAlreadyExist)
            {
                _dataContext.Groups.AddAsync(grp).Wait();
            }
            else
            {
                _dataContext.Groups.Update(grp);
            }

            await _dataContext.SaveChangesAsync();

            user.UserGroups.Add(userGroup);

            //user.Groups.Add(grp);


            _userManager.UpdateAsync(user).Wait();


            return(true);
        }
Пример #7
0
        public async Task <CommandResult <AppUserViewModelinUserService> > ExecuteAsync(AppUserViewModelinUserService userVm)
        {
            var userId   = _httpContextAccessor.HttpContext.User.Identity.Name;
            var userName = _userManager.FindByIdAsync(userId).Result.UserName;

            try
            {
                if (await _checkUserIsAdminQuery.ExecuteAsync(userId) ||
                    await _getPermissionActionQuery.ExecuteAsync(userId, ConstantFunctions.USER, ActionSetting.CanUpdate))
                {
                    var user = await _userManager.FindByIdAsync(userVm.Id.ToString());

                    user.FullName    = userVm.FullName;
                    user.Status      = userVm.Status;
                    user.Email       = userVm.Email;
                    user.PhoneNumber = userVm.PhoneNumber;
                    user.Avatar      = userVm.Avatar;
                    user.UserName    = userVm.UserName;
                    var         userRoles = _userManager.GetRolesAsync(user);
                    List <Guid> roleId    = new List <Guid>();
                    foreach (var item in userRoles.Result.ToList())
                    {
                        var getId = _roleRepository.FindByNameAsync(item).Result.Id;
                        roleId.Add(getId);
                    }
                    foreach (var item in roleId)
                    {
                        _userRoleRepository.DeleteUserRole(user.Id, item);
                    }
                    var selectedRole = userVm.NewRoles.ToArray();
                    selectedRole = selectedRole ?? new string[] { };

                    await _userManager.AddToRolesAsync(user, selectedRole.Except(userRoles.Result).ToArray());

                    //var userRoles1 = await _userManager.GetRolesAsync(user);
                    await _userManager.UpdateAsync(user);

                    await Logging <UpdateUserAsyncCommand> .InformationAsync(ActionCommand.COMMAND_UPDATE, userName, JsonConvert.SerializeObject(user));

                    return(new CommandResult <AppUserViewModelinUserService>
                    {
                        isValid = true,
                        myModel = new AppUserViewModelinUserService
                        {
                            FullName = userVm.FullName,
                            Email = userVm.Email,
                            PhoneNumber = userVm.PhoneNumber,
                            Id = userVm.Id,
                            Avatar = userVm.Avatar,
                            DateCreated = user.DateCreated,
                            UserName = user.UserName,
                            Roles = userVm.Roles.ToList()
                        }
                    });
                }
                else
                {
                    await Logging <UpdateUserAsyncCommand> .
                    WarningAsync(ActionCommand.COMMAND_UPDATE, userName, ErrorMessageConstant.ERROR_UPDATE_PERMISSION);

                    return(new CommandResult <AppUserViewModelinUserService>
                    {
                        isValid = false,
                        errorMessage = ErrorMessageConstant.ERROR_UPDATE_PERMISSION
                    });
                }
            }
            catch (Exception ex)
            {
                await Logging <UpdateUserAsyncCommand> .
                ErrorAsync(ex, ActionCommand.COMMAND_UPDATE, userName, "Has error");

                return(new CommandResult <AppUserViewModelinUserService>
                {
                    isValid = false,
                    errorMessage = ex.InnerException.ToString()
                });
            }
        }
Пример #8
0
        public static async Task SeedUsers(UserManager <AppUser> userManager,
                                           RoleManager <AppRole> roleManager)
        {
            if (await userManager.Users.AnyAsync())
            {
                return;
            }

            var userData = await System.IO.File.ReadAllTextAsync("Data/UserSeedData.json");

            var users = JsonSerializer.Deserialize <List <AppUser> >(userData);

            if (users == null)
            {
                return;
            }

            var roles = new List <AppRole>
            {
                new AppRole {
                    Name = "Member"
                },
                new AppRole {
                    Name = "Admin"
                },
                new AppRole {
                    Name = "Moderator"
                },
            };

            foreach (var role in roles)
            {
                await roleManager.CreateAsync(role);
            }

            foreach (var user  in users)
            {
                user.Photos.First().IsApproved = true;

                // using var hmac = new HMACSHA512();---------------Identity

                user.UserName = user.UserName.ToLower();
                // user.PasswordHash = hmac.ComputeHash(Encoding.UTF8.GetBytes("Pa$$w0rd"));---------------Identity
                // user.PasswordSalt = hmac.Key;---------------Identity

                // context.Users.Add(user);--------------Identity
                await userManager.CreateAsync(user, "Pa$$w0rd");

                await userManager.AddToRoleAsync(user, "Member");
            }

            var admin = new AppUser
            {
                UserName = "******"
            };

            await userManager.CreateAsync(admin, "Pa$$w0rd");

            await userManager.AddToRolesAsync(admin, new[] { "Admin", "Moderator" });

            // await context.SaveChangesAsync();-----------Identity
        }
Пример #9
0
        public async Task <IActionResult> OnPostAsync(string returnUrl = null)
        {
            returnUrl ??= Url.Content("~/");
            if (ModelState.IsValid)
            {
                if (
                    await _context.Users.AnyAsync(p => p.Email == Input.Email)
                    )
                {
                    ModelState.AddModelError(nameof(Input.Email), _localizer["Email is register"]);
                    return(Page());
                }

                if (
                    !await _roleManager.RoleExistsAsync(X_DOVEValues.ROLE_SUPERUSER_String)
                    )
                {
                    await _roleManager.CreateAsync(
                        new IdentityRole {
                        Name           = X_DOVEValues.ROLE_SUPERUSER_String,
                        NormalizedName = X_DOVEValues.ROLE_SUPERUSER_String
                    }
                        );
                }

                if (
                    !await _roleManager.RoleExistsAsync(X_DOVEValues.ROLE_ADMINISTRATOR_String)
                    )
                {
                    await _roleManager.CreateAsync(
                        new IdentityRole {
                        Name           = X_DOVEValues.ROLE_ADMINISTRATOR_String,
                        NormalizedName = X_DOVEValues.ROLE_ADMINISTRATOR_String
                    }
                        );
                }

                if (
                    !await _roleManager.RoleExistsAsync(X_DOVEValues.ROLE_USER_String)
                    )
                {
                    await _roleManager.CreateAsync(
                        new IdentityRole {
                        Name           = X_DOVEValues.ROLE_USER_String,
                        NormalizedName = X_DOVEValues.ROLE_USER_String
                    }
                        );
                }

                var _SuperUser = new IdentityUser {
                    Email          = Input.Email,
                    UserName       = Input.UserName,
                    PhoneNumber    = Input.PhoneNumber ?? "",
                    EmailConfirmed = true,
                };

                await _userManager.CreateAsync(
                    _SuperUser,
                    Input.Password
                    );

                await _userManager.AddToRolesAsync(
                    _SuperUser,
                    new string[] { X_DOVEValues.ROLE_SUPERUSER_String, X_DOVEValues.ROLE_ADMINISTRATOR_String }
                    );

                return(Redirect(returnUrl));
            }

            return(Page());
        }
Пример #10
0
        static async Task <IList <User> > SeedUsers(DataContext context, UserManager <User> userManager, string defaultPassword, IList <City> cities, IConfiguration configuration, IHostEnvironment environment, ILogger logger)
        {
            UserFaker usersFaker = new UserFaker(cities)
            {
                // random specified genders cannot exceed 100 because the max random number for user image is 99
                MaxSpecifiedGender = 100
            };
            IList <User> users = usersFaker.Generate(USERS_COUNT);
            IDictionary <Genders, IDictionary <string, string> > images = await DownloadUserImages(users, configuration, environment, logger);

            User admin = users[0];

            admin.UserName             = "******";
            admin.Email                = "*****@*****.**";
            admin.EmailConfirmed       = true;
            admin.PhoneNumberConfirmed = true;
            admin.LockoutEnabled       = false;
            logger?.LogInformation("Adding users data.");

            int usersAdded = 0;

            for (int i = 0; i < users.Count; i++)
            {
                User user     = users[i];
                User userInDb = await userManager.FindByNameAsync(user.UserName);

                if (userInDb != null)
                {
                    users[i] = userInDb;
                    continue;
                }

                bool userIsAdmin = user.UserName.IsSame("administrator");
                user.Created    = DateTime.UtcNow;
                user.Modified   = DateTime.UtcNow;
                user.LastActive = DateTime.UtcNow;
                logger?.LogInformation($"Adding '{user.UserName}' user data.");
                IdentityResult result = await userManager.CreateAsync(user, defaultPassword);

                if (!result.Succeeded)
                {
                    if (userIsAdmin)
                    {
                        throw new DataException(result.Errors.Aggregate(new StringBuilder($"Could not add admin user '{user.UserName}'."),
                                                                        (builder, error) => builder.AppendWithLine(error.Description),
                                                                        builder => builder.ToString()));
                    }

                    continue;
                }

                logger?.LogInformation($"Added '{user.UserName}' user data.");
                usersAdded++;
                result = userIsAdmin
                                                        ? await userManager.AddToRolesAsync(user, new[]
                {
                    Role.Administrators,
                    Role.Members
                })
                                                        : await userManager.AddToRoleAsync(user, Role.Members);

                logger?.LogInformation($"Adding '{user.UserName}' to roles.");

                if (!result.Succeeded)
                {
                    throw new DataException(result.Errors.Aggregate(new StringBuilder($"Could not add user '{user.UserName}' to role."),
                                                                    (builder, error) => builder.AppendWithLine(error.Description),
                                                                    builder => builder.ToString()));
                }

                logger?.LogInformation($"Added '{user.UserName}' to roles.");
                if (images == null ||
                    user.Gender == Genders.Unspecified ||
                    !images.TryGetValue(user.Gender, out IDictionary <string, string> files) ||
                    !files.TryGetValue(user.Id, out string photoUrl))
                {
                    continue;
                }

                Photo photo = new Photo
                {
                    UserId    = user.Id,
                    Url       = photoUrl,
                    IsDefault = true,
                    DateAdded = user.Created
                };
                await context.Photos.AddAsync(photo);

                user.Photos.Add(photo);
                logger?.LogInformation($"Assigned '{user.UserName}' a default image '{photo.Url}'.");
            }

            await context.SaveChangesAsync();

            logger?.LogInformation($"Added {usersAdded} users.");
            return(users);
        }
Пример #11
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"));
        }
        public async Task <IActionResult> Patch(string key, [FromBody] JObject data)
        {
            var user = await userManager.FindByIdAsync(key);

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

            EntityPatch.Apply(user, data);

            var roles = data.GetValue("RoleNames").ToObject <IEnumerable <string> >();

            OnUserUpdated(user);

            IdentityResult result = null;

            if (roles != null)
            {
                result = await userManager.RemoveFromRolesAsync(user, await userManager.GetRolesAsync(user));

                if (!result.Succeeded)
                {
                    return(IdentityError(result));
                }

                if (roles.Any())
                {
                    result = await userManager.AddToRolesAsync(user, roles);
                }

                if (!result.Succeeded)
                {
                    return(IdentityError(result));
                }
            }

            var password = data.GetValue("Password", StringComparison.OrdinalIgnoreCase).ToObject <string>();

            if (password != null)
            {
                result = await userManager.RemovePasswordAsync(user);

                if (!result.Succeeded)
                {
                    return(IdentityError(result));
                }

                result = await userManager.AddPasswordAsync(user, password);

                if (!result.Succeeded)
                {
                    return(IdentityError(result));
                }
            }

            result = await userManager.UpdateAsync(user);

            if (!result.Succeeded)
            {
                return(IdentityError(result));
            }

            return(new NoContentResult());
        }
Пример #13
0
        private async Task <SignInResult> ExternalLoginSignInAsync(IUser user, ExternalLoginInfo info)
        {
            var claims    = info.Principal.GetSerializableClaims();
            var userRoles = await _userManager.GetRolesAsync(user);

            var context = new UpdateRolesContext(user, info.LoginProvider, claims, userRoles);

            string[] rolesToAdd    = new string[0];
            string[] rolesToRemove = new string[0];

            var loginSettings = (await _siteService.GetSiteSettingsAsync()).As <LoginSettings>();

            if (loginSettings.UseScriptToSyncRoles)
            {
                try
                {
                    var jsonSerializerSettings = new JsonSerializerSettings()
                    {
                        ContractResolver = new CamelCasePropertyNamesContractResolver()
                    };
                    var     script           = $"js: function syncRoles(context) {{\n{loginSettings.SyncRolesScript}\n}}\nvar context={JsonConvert.SerializeObject(context, jsonSerializerSettings)};\nsyncRoles(context);\nreturn context;";
                    dynamic evaluationResult = _scriptingManager.Evaluate(script, null, null, null);
                    rolesToAdd    = (evaluationResult.rolesToAdd as object[]).Select(i => i.ToString()).ToArray();
                    rolesToRemove = (evaluationResult.rolesToRemove as object[]).Select(i => i.ToString()).ToArray();
                }
                catch (Exception ex)
                {
                    _logger.LogError(ex, "Error Syncing Roles From External Provider {0}", info.LoginProvider);
                }
            }
            else
            {
                foreach (var item in _externalLoginHandlers)
                {
                    try
                    {
                        await item.UpdateRoles(context);
                    }
                    catch (Exception ex)
                    {
                        _logger.LogError(ex, "{externalLoginHandler} - IExternalLoginHandler.UpdateRoles threw an exception", item.GetType());
                    }
                }
                rolesToAdd    = context.RolesToAdd;
                rolesToRemove = context.RolesToRemove;
            }

            await _userManager.AddToRolesAsync(user, rolesToAdd.Distinct());

            await _userManager.RemoveFromRolesAsync(user, rolesToRemove.Distinct());

            var result = await _signInManager.ExternalLoginSignInAsync(info.LoginProvider, info.ProviderKey, isPersistent : false, bypassTwoFactor : true);

            if (result.Succeeded)
            {
                var identityResult = await _signInManager.UpdateExternalAuthenticationTokensAsync(info);

                if (!identityResult.Succeeded)
                {
                    _logger.LogError("Error updating the external authentication tokens.");
                }
            }

            return(result);
        }
Пример #14
0
 private static async Task CreateUserSync(UserManager<ApplicationUser> userManager, UserTemplate userTemplate, ApplicationUser user)
 {
     await userManager.CreateAsync(user, userTemplate.Password);
     await userManager.AddToRolesAsync(user, userTemplate.Roles);
 }
Пример #15
0
        public async Task <IActionResult> Edit(EditPsychologistView model, List <string> roles)
        {
            if (ModelState.IsValid)
            {
                Psychologist psychologist = await unitOfWork.Psychologists.Get(model.Id);

                ApplicationUser user = await userManager.FindByEmailAsync(psychologist.Email);

                if (user != null && psychologist != null)
                {
                    if (roles.Contains("manager") && model.UnMakePsychologist)
                    {
                        roles.Remove("manager");
                    }
                    user.Email      = model.Email;
                    user.UserName   = model.Email;
                    user.UpdateTime = DateTime.Now;

                    var userRoles = await userManager.GetRolesAsync(user);

                    var allRoles = roleManager.Roles.ToList();

                    var addedRoles   = roles.Except(userRoles);
                    var removedRoles = userRoles.Except(roles);

                    await userManager.AddToRolesAsync(user, addedRoles);

                    await userManager.RemoveFromRolesAsync(user, removedRoles);

                    if (model.UnMakePsychologist)
                    {
                        var customer = new Customer
                        {
                            Name        = model.FirstName,
                            Surname     = model.SecondName,
                            BirthDate   = psychologist.BirthDate,
                            Email       = model.Email,
                            PhoneNumber = model.Phone
                        };

                        await unitOfWork.Customers.Create(customer);

                        await unitOfWork.Psychologists.Delete(psychologist.PsychologistId);

                        await unitOfWork.SaveAsync();
                    }
                    else
                    {
                        psychologist.Name        = model.FirstName;
                        psychologist.Surname     = model.SecondName;
                        psychologist.PhoneNumber = model.Phone;
                        psychologist.Email       = model.Email;

                        unitOfWork.Psychologists.Update(psychologist);
                        await unitOfWork.SaveAsync();

                        var result = await userManager.UpdateAsync(user);

                        if (result.Succeeded)
                        {
                            return(RedirectToAction("Index"));
                        }
                        else
                        {
                            foreach (var error in result.Errors)
                            {
                                ModelState.AddModelError(string.Empty, error.Description);
                            }
                        }
                    }
                }
            }

            return(RedirectToAction("Index", "Psychologist"));
        }
        private static void AddUsersToRoles(UserManager<ApplicationUser> users, RoleManager<ApplicationRole> roleManager)
        {
            var admin = users.FindByEmailAsync("*****@*****.**").Result;
            var esthetician = users.FindByEmailAsync("*****@*****.**").Result;

            Task.FromResult(users.AddToRolesAsync(admin, new[] { "Admin", "Esthetician" }).Result);
            Task.FromResult(users.AddToRoleAsync(esthetician, "Esthetician").Result);
        }
Пример #17
0
        public async Task <Response> UpsertUser(UpsertUserCmd request)
        {
            /////
            var department = await _context.Departments
                             .FirstOrDefaultAsync(x => x.Id == request.DepartmentId);

            if (department == null)
            {
                throw new BusinessLogicException("دپارتمان مورد تایید نمی باشد");
            }

            //////


            if (!string.IsNullOrEmpty(request.Id))
            {
                var user = await _userManager.FindByIdAsync(request.Id);

                if (user == null)
                {
                    throw new BusinessLogicException("کاربری برای ویرایش موجود نمی باشد");
                }
                user            = _mapper.Map(request, user);
                user.Department = department;

                // update user role
                var roles = await _userManager.GetRolesAsync(user);

                await _userManager.RemoveFromRolesAsync(user, roles);

                await _userManager.AddToRolesAsync(user, request.Roles);

                // removing all user claims
                var userClaims = await _userManager.GetClaimsAsync(user);

                var removeClaim = await _userManager.RemoveClaimsAsync(user, userClaims);

                if (!removeClaim.Succeeded)
                {
                    throw new BusinessLogicException("خطای ناشناخته ای رخ داده است claims");
                }

                // add claims to user
                var claims = ClaimStore.AllClaims.Where(x => request.Claims.Contains(x.Type)).ToList();
                foreach (var claim in claims)
                {
                    var resultAddition = await _userManager.AddClaimAsync(user, claim);

                    if (!resultAddition.Succeeded)
                    {
                        throw new BusinessLogicException("user خطای ناشناخته ای رخ داده است");
                    }
                }



                var result = await _userManager.UpdateAsync(user);

                if (!result.Succeeded)
                {
                    throw new Exception();
                }
            }
            else
            {
                var user = new ApplicationUser();

                var existingUser = await _userManager.FindByNameAsync(request.UserName);

                if (existingUser != null)
                {
                    throw new BusinessLogicException("این نام کاربری استفاده شده است. نام کاربری دیگری را امتحان کنید");
                }
                // user = await result.ProjectTo<ApplicationUser>(_mapper.ConfigurationProvider).First();
                //user = _mapper.Map<ApplicationUser>(request);
                //  user = _mapper.Map(request, user);
                user.FirstName = request.FirstName;
                user.Code      = request.Code;
                user.LastName  = request.LastName;

                await _userManager.AddToRolesAsync(user, request.Roles);

                user.Department = department;
                user.Id         = Guid.NewGuid().ToString();
                // user.UserName = request.UserName;
                // user.PasswordHash = request.Password;

                // add claims to user
                var claims = ClaimStore.AllClaims.Where(x => request.Claims.Contains(x.Type)).ToList();
                foreach (var claim in claims)
                {
                    var resultAddition = await _userManager.AddClaimAsync(user, claim);

                    if (!resultAddition.Succeeded)
                    {
                        throw new BusinessLogicException("خطای ناشناخته ای رخ داده است claims");
                    }
                }


                var res = await _userManager.CreateAsync(user, request.Password);

                if (!res.Succeeded)
                {
                    throw new BusinessLogicException("خطای ناشناخته");
                }
                await _userManager.AddToRolesAsync(user, request.Roles);
            }

            return(new Response
            {
                Status = true,
                Message = "success"
            });
        }
Пример #18
0
        public async Task <ActionResult> Edit([Bind(Include = "Email,Id")] EditUserViewModel editUser, params string[] selectedRole)
        {
            if (ModelState.IsValid)
            {
                string username = User.Identity.Name;
                db.Configuration.ProxyCreationEnabled = false;
                var user = await UserManager.FindByIdAsync(editUser.Id);

                IdentityUser oldUser = new IdentityUser();
                oldUser.Id    = user.Id;
                oldUser.Email = user.Email;
                if (user == null)
                {
                    return(HttpNotFound());
                }


                //user.UserName = editUser.Email;
                user.Email = editUser.Email;
                IdentityUser newUser = new IdentityUser();
                newUser.Id    = user.Id;
                newUser.Email = user.Email;

                var userRoles = await UserManager.GetRolesAsync(user.Id);

                selectedRole = selectedRole ?? new string[] { };

                var result = await UserManager.AddToRolesAsync(user.Id, selectedRole.Except(userRoles).ToArray <string>());

                if (!result.Succeeded)
                {
                    ModelState.AddModelError("", result.Errors.First());
                    return(View(new EditUserViewModel()
                    {
                        Id = user.Id,
                        Email = user.Email,
                        RolesList = RoleManager.Roles.ToList().Select(x => new SelectListItem()
                        {
                            Selected = userRoles.Contains(x.Name),
                            Text = x.Name,
                            Value = x.Name
                        })
                    }));
                }
                result = await UserManager.RemoveFromRolesAsync(user.Id, userRoles.Except(selectedRole).ToArray <string>());

                if (!result.Succeeded)
                {
                    ModelState.AddModelError("", result.Errors.First());
                    return(View(new EditUserViewModel()
                    {
                        Id = user.Id,
                        Email = user.Email,
                        RolesList = RoleManager.Roles.ToList().Select(x => new SelectListItem()
                        {
                            Selected = userRoles.Contains(x.Name),
                            Text = x.Name,
                            Value = x.Name
                        })
                    }));
                }
                auditTransact.CreateAuditTrail("Update", 1, "User", oldUser, newUser, username);
                TempData["message"] = "User Admin successfully updated!";
                return(RedirectToAction("Index"));
            }
            ModelState.AddModelError("", "Something failed.");
            return(View());
        }
Пример #19
0
        public async Task <IActionResult> RegisterAdmin(RegisterAdmin model)
        {
            //checking if user exists or not
            var userExist = await userManager.FindByNameAsync(model.UserName);

            if (userExist != null)
            {
                TempData["message"] = "User Already Exists";
            }

            //checking age valid
            int age = 0;

            age = DateTime.Now.Year - model.Dob.Year;
            if (DateTime.Now.DayOfYear < model.Dob.DayOfYear)
            {
                age = age - 1;
            }
            if (age >= 0 && age < 18)
            {
                TempData["message"] = "You Are below 18 years, So Your Account Cannot be created";
                return(RedirectToAction("Index"));
            }
            else if (age < 0 || age > 100)
            {
                TempData["message"] = "You have Entered false Date of birth";
                return(RedirectToAction("Index"));
            }

            //creating user
            ApplicationUser user = new ApplicationUser
            {
                UserName      = model.UserName,
                PhoneNumber   = model.PhoneNumber,
                FirstName     = model.FirstName,
                LastName      = model.LastName,
                Dob           = model.Dob,
                Gender        = model.Gender,
                FathersName   = model.FathersName,
                MothersName   = model.MothersName,
                Address       = model.Address,
                Pincode       = model.Pincode,
                Status        = "admin",
                SecurityStamp = Guid.NewGuid().ToString(),
            };

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

            if (!result.Succeeded)
            {
                TempData["message"] = $"{result.Errors.ToList()[0].Description}";
            }
            else
            {
                //adding role
                if (!await roleManager.RoleExistsAsync(UserRoles.Admin))
                {
                    await roleManager.CreateAsync(new IdentityRole(UserRoles.Admin));
                }

                if (!await roleManager.RoleExistsAsync(UserRoles.User))
                {
                    await roleManager.CreateAsync(new IdentityRole(UserRoles.User));
                }

                if (await roleManager.RoleExistsAsync(UserRoles.Admin))
                {
                    await userManager.AddToRolesAsync(user, new List <string>() { UserRoles.Admin });
                }
                TempData["message"] = "Admin User Registered Successfuly. You Can LogIn Into Your Account using your Email and Password";
            }

            return(RedirectToAction("Index"));
        }
Пример #20
0
        public async Task <AdminUserDetailsVM> Create(RegisterAdminUser10 user)
        {
            try
            {
                var admin = await _userManager.FindByIdAsync(user.AdminId);

                if (admin == null)
                {
                    throw new Exception("Could not find the active user.");
                }

                var adminResult = await _userManager.VerifyUserTokenAsync(admin, "Default", "authentication-backend", user.AdminToken);

                if (!adminResult)
                {
                    throw new Exception("Could not verify the active user.");
                }

                if (_userManager.FindByNameAsync(user.UserName).Result != null)
                {
                    throw new Exception("This username is already in use.");
                }

                if (user.Password != user.ComparePassword)
                {
                    throw new Exception("The passwords does not match.");
                }

                var appUser = new AppUser10
                {
                    UserName      = user.UserName,
                    FirstName     = user.FirstName,
                    LastName      = user.LastName,
                    Age           = user.Age,
                    Email         = user.Email,
                    SecurityStamp = user.SecurityStamp,
                    IsAdmin       = user.IsAdmin
                };

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

                if (result.Succeeded)
                {
                    var roles = await _roleManager.Roles.ToListAsync();

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

                    roles.ForEach(x => roleNames.Add(x.Name));

                    var newUser = await _userManager.FindByNameAsync(user.UserName);

                    _ = user.IsAdmin == true ? await _userManager.AddToRolesAsync(newUser, roleNames)
                        : await _userManager.AddToRoleAsync(newUser, "NormalUser");

                    AdminUserDetailsVM userVM = new AdminUserDetailsVM
                    {
                        AdminId       = admin.Id,
                        FrontEndToken = VerificationToken(),
                        AdminToken    = await UserToken(admin),
                        User          = new DetailsVM
                        {
                            UserId    = newUser.Id,
                            UserName  = newUser.UserName,
                            FirstName = newUser.FirstName,
                            LastName  = newUser.LastName,
                            Age       = newUser.Age,
                            Email     = newUser.Email,
                            Roles     = new List <string>(roleNames),
                            IsAdmin   = newUser.IsAdmin
                        }
                    };

                    return(userVM);
                }
                else
                {
                    throw new Exception("Something went wrong. Please check all inputs and then try again.");
                }
            }
            catch (Exception ex)
            {
                AdminUserDetailsVM userVM = new AdminUserDetailsVM
                {
                    ErrorMessage = ex.Message
                };

                return(userVM);
            }
        }
Пример #21
0
        // PUT: api/Account/5
        public async Task <ApiResponse> Update([FromBody] UserInfoDto userInfo)
        {
            if (!ModelState.IsValid)
            {
                return(new ApiResponse(400, "User Model is Invalid"));
            }

            // retrieve full user object for updating
            var appUser = await _userManager.FindByIdAsync(userInfo.UserId.ToString()).ConfigureAwait(true);

            //update values
            appUser.UserName  = userInfo.UserName;
            appUser.FirstName = userInfo.FirstName;
            appUser.LastName  = userInfo.LastName;
            appUser.Email     = userInfo.Email;

            try
            {
                var result = await _userManager.UpdateAsync(appUser).ConfigureAwait(true);
            }
            catch
            {
                return(new ApiResponse(500, "Error Updating User"));
            }

            if (userInfo.Roles != null)
            {
                try
                {
                    List <string> rolesToAdd       = new List <string>();
                    List <string> rolesToRemove    = new List <string>();
                    var           currentUserRoles = (List <string>)(await _userManager.GetRolesAsync(appUser).ConfigureAwait(true));
                    foreach (var newUserRole in userInfo.Roles)
                    {
                        if (!currentUserRoles.Contains(newUserRole))
                        {
                            rolesToAdd.Add(newUserRole);
                        }
                    }
                    await _userManager.AddToRolesAsync(appUser, rolesToAdd).ConfigureAwait(true);

                    //HACK to switch to claims auth
                    foreach (var role in rolesToAdd)
                    {
                        await _userManager.AddClaimAsync(appUser, new Claim($"Is{role}", "true")).ConfigureAwait(true);
                    }

                    foreach (var role in currentUserRoles)
                    {
                        if (!userInfo.Roles.Contains(role))
                        {
                            rolesToRemove.Add(role);
                        }
                    }
                    await _userManager.RemoveFromRolesAsync(appUser, rolesToRemove).ConfigureAwait(true);

                    //HACK to switch to claims auth
                    foreach (var role in rolesToRemove)
                    {
                        await _userManager.RemoveClaimAsync(appUser, new Claim($"Is{role}", "true")).ConfigureAwait(true);
                    }
                }
                catch
                {
                    return(new ApiResponse(500, "Error Updating Roles"));
                }
            }
            return(new ApiResponse(200, "User Updated"));
        }
Пример #22
0
        public static void SeedUsers(UserManager <User> userManager, RoleManager <Role> roleManager)
        {
            if (!userManager.Users.Any())
            {
                var userData = System.IO.File.ReadAllText("Data/UserSeedData.json");
                var users    = JsonConvert.DeserializeObject <List <User> >(userData); // convert json data to User Class data to loop on it

                // Create some role

                var roles = new List <Role>
                {
                    new Role {
                        Name = "Admin"
                    },
                    new Role {
                        Name = "Moderator"
                    },
                    new Role {
                        Name = "VIP"
                    },
                    new Role {
                        Name = "Member"
                    },
                };

                foreach (var role in roles)
                {
                    roleManager.CreateAsync(role).Wait();
                }

                foreach (var user in users)
                {
                    userManager.CreateAsync(user, "password").Wait();
                    userManager.AddToRoleAsync(user, "Member").Wait();

                    // byte[] passwordHash, passwordSalt;
                    // CreatePasswordHash("password", out passwordHash, out passwordSalt); // password ==> is hard code password i created it when generating json data

                    // user.PasswordHash = passwordHash;
                    // user.PasswordSalt = passwordSalt;
                    // user.UserName = user.UserName.ToLower();

                    // context.Users.Add(user);
                }

                // Create admin user
                var adminUser = new User
                {
                    UserName = "******"
                };
                var results = userManager.CreateAsync(adminUser, "password").Result;

                if (results.Succeeded)
                {
                    var admin = userManager.FindByNameAsync("Admin").Result;
                    userManager.AddToRolesAsync(admin, new[] { "Admin", "Moderator", "VIP" });
                }

                // context.SaveChanges();
            }
        }
Пример #23
0
        // public static void SeedUsers(DataContext context)
        public static void SeedUsers(UserManager <User> userManager, RoleManager <Role> roleManager)
        {
            // if (!context.Users.Any())
            if (!userManager.Users.Any())
            {
                var userData = System.IO.File.ReadAllText("Data/UserSeedData.json");
                var users    = JsonConvert.DeserializeObject <List <User> >(userData);

                // Create some roles
                var roles = new List <Role>
                {
                    new Role {
                        Name = "Member"
                    },
                    new Role {
                        Name = "Admin"
                    },
                    new Role {
                        Name = "Moderator"
                    },
                    new Role {
                        Name = "VIP"
                    }
                };

                foreach (var role in roles)
                {
                    roleManager.CreateAsync(role).Wait();
                }

                foreach (var user in users)
                {
                    userManager.CreateAsync(user, "password").Wait();
                    userManager.AddToRoleAsync(user, "Member").Wait();

                    // byte[] passwordHash, passwordSalt;
                    // CreatePasswordHash("password", out passwordHash, out passwordSalt);

                    // user.PasswordHash = passwordHash;
                    // user.PasswordSalt = passwordSalt;
                    // user.UserName = user.UserName.ToLowerInvariant();

                    // context.Users.Add(user);
                }

                var adminUser = new User
                {
                    UserName = "******"
                };

                userManager.CreateAsync(adminUser, "password").Wait();
                var admin = userManager.FindByNameAsync("Admin").Result;

                userManager.AddToRolesAsync(admin, new[] { "Admin", "Moderator" }).Wait();


                // var result = userManager.CreateAsync(adminUser, "password").Result;

                // if (result.Succeeded)
                // {
                //     var admin = userManager.FindByNameAsync("Admin").Result;
                //     userManager.AddToRolesAsync(admin, new[] { "Admin", "Moderator" });
                // }

                // context.SaveChanges();
            }
        }
        public async Task <ActionResult> Edit([Bind(Include = "Email,Id,FirstName,LastName,Address,City,StateId,CountryId,Levelid,Zip,Phone,Mobile,Designation,ProfileImage,Skypeid,isactive")] EditUserViewModel editUser, HttpPostedFileBase filename, params string[] selectedRole)
        {
            if (!IsLoggedIn())
            {
                return(RedirectToAction("login", "account"));
            }
            if (ModelState.IsValid)
            {
                var user = await UserManager.FindByIdAsync(editUser.Id);

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

                user.UserName  = editUser.Email;
                user.Email     = editUser.Email;
                user.FirstName = editUser.FirstName;
                user.LastName  = editUser.LastName;
                user.Address   = editUser.Address;
                user.City      = editUser.City;
                user.StateId   = editUser.StateId;
                user.CountryId = editUser.CountryId;

                user.Zip    = editUser.Zip;
                user.Phone  = editUser.Phone;
                user.Mobile = editUser.Mobile;


                user.isactive = editUser.isactive;
                if (!System.IO.Directory.Exists(AppDomain.CurrentDomain.BaseDirectory + "/Images/UserProfileImage/"))
                {
                    System.IO.Directory.CreateDirectory(AppDomain.CurrentDomain.BaseDirectory + "/Images/UserProfileImage/");
                }
                if (!System.IO.Directory.Exists(AppDomain.CurrentDomain.BaseDirectory + "/Images/UserProfileImage/deleted"))
                {
                    System.IO.Directory.CreateDirectory(AppDomain.CurrentDomain.BaseDirectory + "/Images/UserProfileImage/deleted");
                }
                if (Request.Files.Count > 0)
                {
                    var postedFile = Request.Files[0];
                    if (postedFile.ContentLength > 0)
                    {
                        if (postedFile.ContentType.ToLower() != "image/jpg" && postedFile.ContentType.ToLower() != "image/png" && postedFile.ContentType.ToLower() != "image/gif" && postedFile.ContentType.ToLower() != "image/jpeg")
                        {
                            ModelState.AddModelError("user.ProfileImage", "Sorry, file format must be jpg or jpeg or png or gif");
                        }

                        if (ModelState.IsValid)
                        {
                            var imagapath        = ConfigurationManager.AppSettings["userimagepath"].ToString();
                            var deletedimagepath = ConfigurationManager.AppSettings["deleteduserimagepath"].ToString();
                            var oldfile          = user.ProfileImage;
                            var oldfileExt       = Path.GetExtension(oldfile);
                            var fileExt          = Path.GetExtension(postedFile.FileName);
                            var oldfileName      = user.ProfileImage;
                            var oldpath          = Path.Combine(Server.MapPath(imagapath) + oldfileName + oldfileExt);
                            var fileName         = user.Id;
                            var deleltedfielname = fileName + DateTime.Now.ToString("yyyyMMddHHmmssfff");
                            var path             = Path.Combine(Server.MapPath(imagapath) + fileName + fileExt);
                            deletedimagepath = Path.Combine(Server.MapPath(deletedimagepath + deleltedfielname + fileExt));
                            if (System.IO.File.Exists(oldpath))
                            {
                                System.IO.File.Move(oldpath, deletedimagepath);
                            }
                            postedFile.SaveAs(path);
                            user.ProfileImage = fileName + fileExt;
                        }
                    }
                }
                var updateuser = await UserManager.UpdateAsync(user);

                string ismyprofile = Request.Form["myprofileid"].ToString();
                if (ismyprofile == "yes")
                {
                    return(RedirectToAction("myprofile", "home"));
                }
                else
                {
                    var userRoles = await UserManager.GetRolesAsync(user.Id);

                    selectedRole = selectedRole ?? new string[] { };

                    var result = await UserManager.AddToRolesAsync(user.Id, selectedRole.Except(userRoles).ToArray <string>());

                    if (!result.Succeeded)
                    {
                        ViewBag.countrylist = new SelectList(db.Country, "id", "nicename");
                        ViewBag.statelist   = new SelectList(db.State, "id", "name");
                        ModelState.AddModelError("", result.Errors.First());
                        return(View());
                    }
                    result = await UserManager.RemoveFromRolesAsync(user.Id, userRoles.Except(selectedRole).ToArray <string>());

                    if (!result.Succeeded)
                    {
                        ViewBag.countrylist = new SelectList(db.Country, "id", "nicename");
                        ViewBag.statelist   = new SelectList(db.State, "id", "name");


                        ModelState.AddModelError("", result.Errors.First());
                        return(View());
                    }
                    if (result.Succeeded)
                    {
                    }
                    return(RedirectToAction("Index"));
                }
            }
            string Ismyprofile = Request.Form["myprofileid"].ToString();

            if (Ismyprofile == "yes")
            {
                ModelState.AddModelError("", "All Fields with * are required.");
                return(RedirectToAction("myprofile", "home"));
            }
            else
            {
                ViewBag.countrylist = new SelectList(db.Country, "id", "nicename");
                ViewBag.statelist   = new SelectList(db.State, "id", "name");

                ModelState.AddModelError("", "Something failed.");
                return(View());
            }
        }
Пример #25
0
        public async Task <ActionResult> Edit(ApplicationUserViewModel editUser)
        {
            if (ModelState.IsValid)
            {
                var user = await UserManager.FindByIdAsync(editUser.Id);

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

                user.FirstName = editUser.FirstName;
                user.LastName  = editUser.LastName;
                user.UserName  = editUser.Email;
                user.Email     = editUser.Email;

                if (editUser.SelectedRoles == null)
                {
                    editUser.SelectedRoles = new string[] { }
                }
                ;

                var userRoles = await UserManager.GetRolesAsync(user.Id);

                var rolesToAdd = editUser.SelectedRoles.Except(userRoles);

                foreach (var roleToAdd in rolesToAdd)
                {
                    var result = await UserManager.AddToRolesAsync(user.Id, roleToAdd);

                    if (!result.Succeeded)
                    {
                        ModelState.AddModelError("", result.Errors.First());
                        return(View());
                    }
                }

                var rolesToRemove = userRoles.Except(editUser.SelectedRoles);

                foreach (var roleToRemove in rolesToRemove)
                {
                    var result = await UserManager.RemoveFromRoleAsync(user.Id, roleToRemove);

                    if (!result.Succeeded)
                    {
                        ModelState.AddModelError("", result.Errors.First());
                        return(View());
                    }
                }

                var updateUserResult = await UserManager.UpdateAsync(user);

                if (updateUserResult.Succeeded)
                {
                    TempData["success"] = "User " + user.Email + " details edited successfully.";
                }
                else
                {
                    TempData["error"] = "User " + user.Email + " details were not edited.";
                }

                return(RedirectToAction("Index"));
            }

            TempData["error"] = "Something failed";
            return(View());
        }
Пример #26
0
        private static async Task CreateUserSync(UserManager <ApplicationUser> userManager, UserTemplate userTemplate, ApplicationUser user)
        {
            await userManager.CreateAsync(user, userTemplate.Password);

            await userManager.AddToRolesAsync(user, userTemplate.Roles);
        }
Пример #27
0
        /// <summary>
        /// 保存用户资料
        /// </summary>
        /// <param name="boVM">用户的视图模型</param>
        /// <returns></returns>
        public async Task <IActionResult> SaveEditApplicationUser([Bind("Id,RoleId,IsNew,RoleItemIdCollection,UserName,Name,MobileNumber,EMail,Password,ConfirmPassword,Description")] ApplicationUserForEditVM boVM)
        {
            var validateMessage = new ValidateMessage();

            if (ModelState.IsValid)
            {
                if (boVM.RoleItemIdCollection == null)
                {
                    boVM.RoleItemIdCollection = new List <string>();
                }
                var user = await _UserManager.FindByIdAsync(boVM.Id.ToString());

                #region 1.用户基本资料更新
                user.FirstName       = "";
                user.ChineseFullName = boVM.Name;
                user.Email           = boVM.EMail;
                user.MobileNumber    = boVM.MobileNumber;
                await _UserManager.UpdateAsync(user);

                #endregion

                #region 2.归属角色组的处理
                var roleCollection = _RoleManager.Roles;
                var addRoles       = new List <string>();
                var removeRoles    = new List <string>();
                foreach (var roleItem in roleCollection)
                {
                    // 当前的用户是否归属角色组:roleItem
                    var h = await _UserManager.IsInRoleAsync(user, roleItem.Name);

                    if (!h)
                    {
                        // 不归属,但前端已经选择了相应的角色组,则将当前用户加入相应的角色组。
                        if (boVM.RoleItemIdCollection.Contains(roleItem.Id))
                        {
                            addRoles.Add(roleItem.Name);
                        }
                    }
                    else
                    {
                        // 归属,但前端并未选择相应的角色组,则将当前用户从相关的组中移除。
                        if (!boVM.RoleItemIdCollection.Contains(roleItem.Id))
                        {
                            removeRoles.Add(roleItem.Name);
                        }
                    }
                }
                await _UserManager.AddToRolesAsync(user, addRoles);

                await _UserManager.RemoveFromRolesAsync(user, removeRoles);

                #endregion
                var resultRoleId = "";
                if (boVM.RoleId.ToString() != "00000000-0000-0000-0000-000000000000")
                {
                    resultRoleId = boVM.RoleId.ToString();
                }
                validateMessage.IsOK = true;
                validateMessage.ValidateMessageItems.Add(
                    new ValidateMessageItem
                {
                    IsPropertyName = false,
                    MessageName    = "",
                    Message        = resultRoleId
                });

                return(Json(validateMessage));
            }
            else
            {
                #region 处理用户归属的用户组的数据
                #region 1.待选择的用户组数据
                var user = await _UserManager.FindByIdAsync(boVM.Id.ToString());

                var role      = _RoleManager.Roles;
                var roleItems = new List <PlainFacadeItem>();
                foreach (var item in _RoleManager.Roles.OrderBy(x => x.SortCode))
                {
                    var rItem = new PlainFacadeItem()
                    {
                        Id = item.Id, Name = item.Name, DisplayName = item.DisplayName, SortCode = item.SortCode
                    };
                    roleItems.Add(rItem);
                }
                boVM.RoleItemColection = roleItems;
                #endregion
                #region 2.已经归属的用户组部分
                boVM.RoleItemIdCollection = (
                    from roleItem in _RoleManager.Roles
                    where roleItem.Users.Select(x => x.UserId).Contains(user.Id)
                    select roleItem.Id
                    ).ToList();;

                #endregion
                #endregion

                validateMessage.IsOK = false;
                var errCollection = from errKey in ModelState.Keys
                                    from errMessage in ModelState[errKey].Errors
                                    where ModelState[errKey].Errors.Count > 0
                                    select(new { errKey, errMessage.ErrorMessage });
                foreach (var errItem in errCollection)
                {
                    var vmItem = new ValidateMessageItem()
                    {
                        IsPropertyName = true,
                        MessageName    = errItem.errKey,
                        Message        = errItem.ErrorMessage
                    };
                    validateMessage.ValidateMessageItems.Add(vmItem);
                }
                return(Json(validateMessage));
            }
        }
Пример #28
0
        public async Task <Response> UpsertUser(UpsertUserCmd request)
        {
            /////
            var department = await _context.Departments
                             .FirstOrDefaultAsync(x => x.Id == request.DepartmentId);

            if (department == null)
            {
                throw new BusinessLogicException("دپارتمان مورد تایید نمی باشد");
            }

            //////


            if (!string.IsNullOrEmpty(request.Id))
            {
                var user = await _userManager.FindByIdAsync(request.Id);

                if (user == null)
                {
                    throw new BusinessLogicException("کاربری برای ویرایش موجود نمی باشد");
                }
                user            = _mapper.Map(request, user);
                user.Department = department;

                // update user role
                var roles = await _userManager.GetRolesAsync(user);

                await _userManager.RemoveFromRolesAsync(user, roles);

                await _userManager.AddToRolesAsync(user, request.Roles);

                var result = await _userManager.UpdateAsync(user);

                if (!result.Succeeded)
                {
                    throw new Exception();
                }
            }
            else
            {
                var user = new ApplicationUser();

                var existingUser = await _userManager.FindByNameAsync(request.UserName);

                if (existingUser != null)
                {
                    throw new BusinessLogicException("این نام کاربری قبلن استفاده شده است. نام کاربری دیگری را امتحان کنید");
                }
                // user = await result.ProjectTo<ApplicationUser>(_mapper.ConfigurationProvider).First();
                user = _mapper.Map <ApplicationUser>(request);
                // user = _mapper.Map(request, user);
                user.Department = department;
                user.Id         = Guid.NewGuid().ToString();
                //  user.UserName = request.UserName;
                // user.PasswordHash = request.Password;
                var res = await _userManager.CreateAsync(user, request.Password);

                if (!res.Succeeded)
                {
                    throw new BusinessLogicException("خطای ناشناخته");
                }
                await _userManager.AddToRolesAsync(user, request.Roles);
            }

            return(new Response
            {
                Status = true,
                Message = "success"
            });
        }
        public async Task <ActionResult> Create2(CreateUserFormViewModel2 viewModel)
        {
            // selectedRole is the name of the checkbox list on the html form

            // HERE WE ARE USING SAME FORM & VIEWMODEL FOR ADD & EDIT
            // BUT BOTH SCENARIOS ARE DIFFERENT,
            // ADD NEED PASSWORD & CONFIRM PASSWORD IN VIEW & VIEWMODEL & THEY ARE MANDATORY
            // WITH THEM MODEL WILL BE NOT VALIDATED
            // EDIT DO NOT NEED PASSWORD & CONFIRM PASSWORD IN VIEW & VIEWMODEL
            // MODEL VALIDATION WILL STOP US FROM EDITING USER AND WILL ASK FOR PASSWORKD & CONFIRM PASSWORD
            // SPLIT VIEWS & VIEWMODELS FOR ADD & EDIT

            IdentityResult  result = null;
            ApplicationUser user   = null;


            if (!ModelState.IsValid)
            {
                // Invalid Model, all Model Errors will be auto shown, no need to add yourself
                // Model has those Error Messages in it & Shown Automatically.
                ModelState.AddModelError("", "Something failed.");

                viewModel.AllRolesList = RoleManager.Roles.ToList().Select(x => new UserRole()
                {
                    IsSelected = false,
                    RoleId     = x.Id,
                    RoleName   = x.Name
                }).ToList();


                viewModel.AllClaimsList = ClaimsStore.AllClaims.Select(x => new UserClaim()
                {
                    IsSelected = false,
                    ClaimType  = x.Type,
                }).ToList();

                return(View("CreateUserForm2", viewModel));
            }

            // New User
            user = new ApplicationUser
            {
                UserName       = viewModel.Email,
                Email          = viewModel.Email,
                DrivingLicense = viewModel.DrivingLicense,
                Phone          = viewModel.Phone,
            };


            result = await UserManager.CreateAsync(user, viewModel.Password);

            if (!result.Succeeded)
            {
                // Error occures while Adding New User
                foreach (var error in result.Errors)
                {
                    ModelState.AddModelError("", error);
                }

                viewModel.AllRolesList = RoleManager.Roles.ToList().Select(x => new UserRole()
                {
                    IsSelected = false,
                    RoleId     = x.Id,
                    RoleName   = x.Name
                }).ToList();


                viewModel.AllClaimsList = ClaimsStore.AllClaims.Select(x => new UserClaim()
                {
                    IsSelected = false,
                    ClaimType  = x.Type,
                    ClaimValue = x.Value,
                }).ToList();

                return(View("CreateUserForm2", viewModel));
            }


            // New User Added Successfully now add it roles
            if (viewModel.IsAnyRoleSelected() == false)
            {
                ViewBag.Message = "Record(s) addded successfully.";
                return(List());
            }

            // If some roles are selected for New User, Add those roles
            result = await UserManager.AddToRolesAsync(user.Id, viewModel.GetSelectedRoles());

            // Errors occurs while adding Roles to New user
            if (!result.Succeeded)
            {
                // Error occurs while adding roles
                foreach (var error in result.Errors)
                {
                    ModelState.AddModelError("", error);
                }

                viewModel.AllRolesList = RoleManager.Roles.ToList().Select(x => new UserRole()
                {
                    IsSelected = false,
                    RoleId     = x.Id,
                    RoleName   = x.Name
                }).ToList();


                viewModel.AllClaimsList = ClaimsStore.AllClaims.Select(x => new UserClaim()
                {
                    IsSelected = false,
                    ClaimType  = x.Type,
                    ClaimValue = x.Value,
                }).ToList();

                return(View("CreateUserForm2", viewModel));
            }

            List <Claim> selectedClaimsOnForm = viewModel.GetSelectedClaims();

            // Adding Claim Array
            foreach (var claim in selectedClaimsOnForm)
            {
                result = await UserManager.AddClaimAsync(user.Id, claim);
            }


            if (!result.Succeeded)
            {
                // Error occurs while adding roles
                foreach (var error in result.Errors)
                {
                    ModelState.AddModelError("", error);
                }

                viewModel.AllRolesList = RoleManager.Roles.ToList().Select(x => new UserRole()
                {
                    IsSelected = false,
                    RoleId     = x.Id,
                    RoleName   = x.Name,
                }).ToList();


                viewModel.AllClaimsList = ClaimsStore.AllClaims.Select(x => new UserClaim()
                {
                    IsSelected = false,
                    ClaimType  = x.Type,
                    ClaimValue = x.Value,
                }).ToList();

                return(View("CreateUserForm2", viewModel));
            }

            ViewBag.Message = "Record(s) addded successfully.";
            return(List());
        }
Пример #30
0
        public async Task <IActionResult> CreateUser(UserCreateModel model, string[] selectedRoles)
        {
            ViewBag.Roles = _roleManager.Roles;
            if (!ModelState.IsValid)
            {
                ModelState.AddModelError("", "Girdiğiniz bilgiler kriterlere uymuyor!");
                ViewBag.kullanıcılar = "active";
                return(View(model));
            }

            var user = new User
            {
                UserName             = model.UserName,
                Email                = model.Email,
                EmailConfirmed       = model.EmailConfirmed,
                FirstName            = model.FirstName,
                LastName             = model.LastName,
                PhoneNumber          = model.PhoneNumber,
                PhoneNumberConfirmed = model.PhoneNumberConfirmed
            };

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

            if (result.Succeeded)
            {
                await _userManager.AddToRolesAsync(user, selectedRoles);

                if (!user.EmailConfirmed)
                {
                    var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);

                    var callbackUrl = Url.Action("ConfirmEmail", "Account", new
                    {
                        userId = user.Id,
                        token  = code
                    });
                    try
                    {
                        await _emailSender.SendEmailAsync(model.Email, "Hesabınızı Onaylayınız.", $"Lütfen email hesabınızı onaylamak için linke <a href='http://localhost:5000{callbackUrl}'>tıklayınız.</a>");

                        TempData.Put("message", new AlertType()
                        {
                            Title   = "Kullanıcı oluşturuldu",
                            Message = "Kullanıcı başarılı bir şekilde oluşturuldu",
                            Alert   = "success"
                        }
                                     );
                    }
                    catch (System.Exception)
                    {
                        TempData.Put("message", new AlertType()
                        {
                            Title   = "Hata!",
                            Message = "E-mail onay maili gönderilirken bir hata oluştu!",
                            Alert   = "danger"
                        }
                                     );
                        return(View(model));
                    }
                }
                return(RedirectToAction("UserList"));
            }


            ModelState.AddModelError("", "Bir hata oluştu!Bunun sebebi; kullanımda olan bir e-mail veya kullanıcı adı girmeniz, veya şifrenizin kriterlere uymaması olabilir!");
            return(View(model));
        }
        public async Task <ActionResult> Edit2(EditUserFormViewModel2 viewModel)
        {
            // selectedRole is the name of the checkbox list on the html form

            // HERE WE ARE USING SAME FORM & VIEWMODEL FOR ADD & EDIT
            // BUT BOTH SCENARIOS ARE DIFFERENT,
            // ADD NEED PASSWORD & CONFIRM PASSWORD IN VIEW & VIEWMODEL & THEY ARE MANDATORY
            // WITH THEM MODEL WILL BE NOT VALIDATED
            // EDIT DO NOT NEED PASSWORD & CONFIRM PASSWORD IN VIEW & VIEWMODEL
            // MODEL VALIDATION WILL STOP US FROM EDITING USER AND WILL ASK FOR PASSWORKD & CONFIRM PASSWORD
            // SPLIT VIEWS & VIEWMODELS FOR ADD & EDIT

            //var user = UserManager.Users.FirstOrDefault(u => u.Id == viewModel.Id);

            // If SelectedRoles is null, then add Empty String
            //selectedRoles = selectedRoles ?? new string[] { };

            // not needed as by default initized in constructor
            //selectedClaims = selectedClaims ?? new string[] { };

            //IEnumerable<SelectListItem> SelectedRolesList = RoleManager.Roles.ToList().Select(x => new SelectListItem()
            //{
            //    Selected = userRoles.Contains(x.Name),
            //    Text = x.Name,
            //    Value = x.Name
            //});

            //IEnumerable<SelectListItem> SelectedClaimsList = ClaimsStore.AllClaims.Select(x => new SelectListItem()
            //{
            //    Selected = userClaims.Any(uc => uc.Value == x.Value),
            //    Text = x.Type,
            //    Value = x.Value
            //});

            IdentityResult result    = null;
            IList <string> userRoles = await UserManager.GetRolesAsync(viewModel.Id);

            IList <Claim> userClaims = await UserManager.GetClaimsAsync(viewModel.Id);

            if (!ModelState.IsValid)
            {
                // Add Error
                ModelState.AddModelError("", "Something failed.");
                return(View("EditUserForm2", viewModel));
            }

            ApplicationUser user = await UserManager.FindByIdAsync(viewModel.Id);

            if (user == null)
            {
                ViewBag.ErrorMessage = $"User with Id = {viewModel.Email} cannot be found";
                return(View("NotFound"));
                //return HttpNotFound();
            }

            user.UserName       = viewModel.Email;
            user.Email          = viewModel.Email;
            user.DrivingLicense = viewModel.DrivingLicense;
            user.Phone          = viewModel.Phone;

            result = await UserManager.UpdateAsync(user);

            // Error Occurs While Updating User, no need to add Roles & Claims
            if (!result.Succeeded)
            {
                ViewBag.Message = "Error occurred while updating Record(s)";
                foreach (var error in result.Errors)
                {
                    ModelState.AddModelError("", error);
                }

                return(View("EditUserForm2", viewModel));
            }

            // Only add newly added roles, do not add already added roles.
            result = await UserManager.AddToRolesAsync(user.Id, viewModel.GetSelectedRoles().Except(userRoles).ToArray <string>());


            // Error occurs while adding roles array, but user edited
            if (!result.Succeeded)
            {
                // Add error
                ViewBag.Message = "Error occurred while adding Record(s)";
                foreach (var error in result.Errors)
                {
                    ModelState.AddModelError("", error);
                }

                return(View("EditUserForm2", viewModel));
            }

            // Remove all roles other than selected roles.
            result = await UserManager.RemoveFromRolesAsync(user.Id, userRoles.Except(viewModel.GetSelectedRoles()).ToArray <string>());

            // Error occurs while removing roles, but user edited, role added, not removed
            if (!result.Succeeded)
            {
                ViewBag.Message = "Error occurred while updating Record(s)";
                foreach (var error in result.Errors)
                {
                    ModelState.AddModelError("", error);
                }

                return(View("EditUserForm2", viewModel));
            }

            // Removing Claim Array
            foreach (var claim in userClaims)
            {
                result = await UserManager.RemoveClaimAsync(user.Id, claim);
            }


            if (!result.Succeeded)
            {
                ViewBag.Message = "Error occurred while updating Record(s)";
                foreach (var error in result.Errors)
                {
                    ModelState.AddModelError("", error);
                }

                return(View("EditUserForm2", viewModel));
            }

            //IList<Claim> selectedClaimsOnForm = new List<Claim>();

            List <Claim> selectedClaimsOnForm = CompareClaimValues(viewModel.AllClaimsList);

            // Adding Claim Array
            foreach (var claim in selectedClaimsOnForm)
            {
                result = await UserManager.AddClaimAsync(user.Id, claim);
            }


            if (!result.Succeeded)
            {
                ViewBag.Message = "Error occurred while updating Record(s)";
                foreach (var error in result.Errors)
                {
                    ModelState.AddModelError("", error);
                }

                return(View("EditUserForm2", viewModel));
            }

            // User Added, Role Added, Role Removed Successfully. Show List Role
            ViewBag.Message = "Record(s) updated successfully.";
            return(List());
        }
Пример #32
0
        public void SeedUsers()
        {
            if (!_userManager.Users.Any())
            {
                var userData = System.IO.File.ReadAllText("Data/UserSeedData.json");
                var users    = JsonConvert.DeserializeObject <List <User> >(userData);

                // Add user Roles
                var roles = new List <Role>
                {
                    new Role {
                        Name = "Member"
                    },
                    new Role {
                        Name = "Admin"
                    },
                    new Role {
                        Name = "Moderator"
                    },
                    new Role {
                        Name = "VIP"
                    }
                };


                foreach (var role in roles)
                {
                    _roleManager.CreateAsync(role).Wait();
                }


                foreach (var user in users)
                {
                    user.Photos.SingleOrDefault().IsApproved = true;
                    _userManager.CreateAsync(user, "password").Wait();
                    _userManager.AddToRoleAsync(user, "Member").Wait();
                }


                var adminUser = new User
                {
                    UserName = "******",
                    Gender   = "male",
                    Photos   = new List <Photo>
                    {
                        new Photo
                        {
                            Url         = "https://randomuser.me/api/portraits/men/20.jpg",
                            IsMain      = true,
                            Description = "Lorem proident nostrud adipisicing do.",
                            IsApproved  = true
                        }
                    }
                };

                var result = _userManager.CreateAsync(adminUser, "password").Result;

                if (result.Succeeded)
                {
                    var admin = _userManager.FindByNameAsync("Admin").Result;
                    _userManager.AddToRolesAsync(admin, new[] { "Admin", "Moderator" }).Wait();
                }
            }
        }
Пример #33
0
        public static async Task Initialize(SensateSqlContext ctx, RoleManager <SensateRole> roles, UserManager <SensateUser> manager)
        {
            if (ctx == null)
            {
                throw new ArgumentNullException(nameof(ctx));
            }

            if (manager == null)
            {
                throw new ArgumentNullException(nameof(manager));
            }

            if (roles == null)
            {
                throw new ArgumentNullException(nameof(roles));
            }

            SensateUser user;
            await ctx.Database.EnsureCreatedAsync().ConfigureAwait(false);

            IEnumerable <string> adminroles = new List <string> {
                "Administrators", "Users"
            };

            if (ctx.Roles.Any() || ctx.Users.Any() || ctx.UserRoles.Any())
            {
                return;
            }

            var uroles = new[] {
                new SensateRole {
                    Name        = UserRoles.Administrator,
                    Description = "System administrators",
                },

                new SensateRole {
                    Name        = UserRoles.NormalUser,
                    Description = "Normal users"
                },

                new SensateRole {
                    Name        = UserRoles.Banned,
                    Description = "Banned users"
                }
            };

            foreach (var role in uroles)
            {
                await roles.CreateAsync(role).AwaitBackground();
            }

            user = new SensateUser {
                Email                = "*****@*****.**",
                FirstName            = "System",
                LastName             = "Administrator",
                PhoneNumber          = "0600000000",
                PhoneNumberConfirmed = true,
                EmailConfirmed       = true
            };

            user.UserName       = user.Email;
            user.EmailConfirmed = true;
            await manager.CreateAsync(user, "Root1234#xD").AwaitBackground();

            await ctx.SaveChangesAsync().ConfigureAwait(false);

            user = await manager.FindByEmailAsync("*****@*****.**").AwaitBackground();

            await manager.AddToRolesAsync(user, adminroles).AwaitBackground();
        }