public async Task SeedAsync(DataSeedContext context)
        {
            if (await roleRepository.GetCountAsync() == 1)
            {
                var existingRole = roleRepository.FirstOrDefault();
                await roleRepository.DeleteAsync(existingRole);

                var roles = new[] { "admin", "employee" };
                foreach (var role in roles)
                {
                    var newRole = new IdentityRole(guidGenerator.Create(), role);
                    await roleRepository.InsertAsync(newRole);
                }
            }
            if (await userRepository.GetCountAsync() == 1)
            {
                var existingAdmin = userRepository.FirstOrDefault();
                if (existingAdmin.Email == "*****@*****.**")
                {
                    await userManager.DeleteAsync(existingAdmin);

                    await userRepository.HardDeleteAsync(existingAdmin);

                    var admin = new IdentityUser(guidGenerator.Create(), "admin", "*****@*****.**");
                    await userManager.CreateAsync(admin, "Admin123!");

                    await userManager.AddToRoleAsync(admin, "admin");

                    var employee = new IdentityUser(guidGenerator.Create(), "employee", "*****@*****.**");
                    await userManager.CreateAsync(employee, "Employee123!");

                    await userManager.AddToRoleAsync(employee, "employee");
                }
            }
        }
示例#2
0
        public async void CreateRolesAsync(IContainer container)
        {
            IdentityRoleManager roleManager = container.Resolve <IdentityRoleManager>();

            IdentityUserManager userManager = container.Resolve <IdentityUserManager>();

            if (userManager.FindById(6) != null)
            {
                await userManager.AddToRoleAsync(6, Role.Admin.ToString());
            }

            if (userManager.FindById(7) != null)
            {
                await userManager.AddToRoleAsync(7, Role.Seller.ToString());
            }

            if (roleManager.FindByNameAsync(Role.Admin.ToString()).Result == null)
            {
                await roleManager.CreateAsync(new CustomRole(Role.Admin.ToString()));

                await userManager.AddToRoleAsync(1, Role.Admin.ToString());
            }
            if (roleManager.FindByNameAsync(Role.Seller.ToString()).Result == null)
            {
                await roleManager.CreateAsync(new CustomRole(Role.Seller.ToString()));
            }
            if (roleManager.FindByNameAsync(Role.Customer.ToString()).Result == null)
            {
                await roleManager.CreateAsync(new CustomRole(Role.Customer.ToString()));
            }
        }
示例#3
0
        public async Task <IdentityUser> CreateUser(IdentityUser user, string password)
        {
            var sameInfoUsers = userRepository
                                .Where(u => u.UserName.ToLower() == user.UserName.ToLower() || u.Email.ToLower() == user.Email.ToLower())
                                .ToList();

            foreach (var sameInfoUser in sameInfoUsers)
            {
                if (sameInfoUser.UserName.ToLower() == user.UserName.ToLower())
                {
                    throw new HttpStatusCodeException(HttpStatusCode.BadRequest, SaleManagementDomainErrorCodes.USERNAME_IS_TAKEN);
                }
                if (sameInfoUser.Email.ToLower() == user.Email.ToLower())
                {
                    throw new HttpStatusCodeException(HttpStatusCode.BadRequest, SaleManagementDomainErrorCodes.EMAIL_IS_TAKEN);
                }
            }

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

            if (!result.Succeeded)
            {
                throw new HttpStatusCodeException(HttpStatusCode.InternalServerError, SaleManagementDomainErrorCodes.CREATE_USER_FAILED);
            }

            result = await userManager.AddToRoleAsync(user, "employee");

            if (!result.Succeeded)
            {
                throw new HttpStatusCodeException(HttpStatusCode.InternalServerError, SaleManagementDomainErrorCodes.CREATE_USER_FAILED);
            }

            return(user);
        }
        private async Task CreateUserAsync(string userName, string name, string surname, DataSeedContext context)
        {
            await _identityOptions.SetAsync();

            if ((await _identityUserRepository.FindByNormalizedUserNameAsync(_lookupNormalizer.NormalizeName(userName))) != null)
            {
                return;
            }

            var user = new IdentityUser(
                _guidGenerator.Create(),
                userName,
                userName + "@abp.io",
                context.TenantId
                );

            user.Name    = name;
            user.Surname = surname;

            await _identityUserManager.CreateAsync(user,
                                                   "1q2w3E*"
                                                   );

            await _identityUserManager.AddToRoleAsync(user, "admin");
        }
示例#5
0
        public ActionResult CreateUser(UserFormViewModel model)
        {
            if (ModelState.IsValid)
            {
                var newUser = new User();

                newUser.UserName   = model.Email;
                newUser.CompanyId  = model.CompanyId;
                newUser.FullName   = model.FullName;
                newUser.Email      = model.Email;
                newUser.Disabled   = model.Disabled;
                newUser.CreateDate = DateTime.Now;

                var result = userManager.CreateAsync(newUser, model.Password).Result;

                if (result.Succeeded)
                {
                    result = userManager.AddToRoleAsync(newUser.Id, RoleNames.User).Result;

                    if (result.Succeeded)
                    {
                        return(Json(new { success = true }));
                    }
                }

                CollectIdentityErrors(result);
            }

            var m = new UserFormViewModel();

            m.Companies = companyService.GetAll().ToList().ToSelectListItems(r => r.Name, r => r.Id, true);

            return(PartialView(m));
        }
        public async Task SeedAsync(DataSeedContext context)
        {
            var userName = "******";
            var email    = userName + "@speedy.com";
            var phoneNo  = "0750000000";

            if ((await IdentityUserManager.FindByNameAsync(userName)) != null)
            {
                return;
            }

            var userE = new IdentityUser(GuidGenerator.Create(), userName, email)
            {
                Name    = userName,
                Surname = userName
            };

            await IdentityUserManager.CreateAsync(userE, "!QAZ2wsx");

            await IdentityUserManager.SetEmailAsync(userE, email);

            await IdentityUserManager.SetPhoneNumberAsync(userE, phoneNo);

            await IdentityUserManager.AddClaimAsync(userE, new System.Security.Claims.Claim("sub", userE.Id.ToString()));

            await IdentityUserManager.AddToRoleAsync(userE, RolesConsts.SuperAdmin);
        }
示例#7
0
        public async Task <ActionResult> ExternalLoginConfirmation(ExternalLoginConfirmationViewModel model, string returnUrl)
        {
            IAuthenticationManager authenticationManager = HttpContext.GetOwinContext().Authentication;
            IdentityUserManager    userManager           = HttpContext.GetOwinContext().GetUserManager <IdentityUserManager>();
            SignInManager          signInManager         = HttpContext.GetOwinContext().Get <SignInManager>();

            if (User.Identity.IsAuthenticated)
            {
                return(RedirectToAction("Index", "User"));
            }

            if (ModelState.IsValid)
            {
                // Get the information about the user from the external login provider
                var info = await authenticationManager.GetExternalLoginInfoAsync();

                if (info == null)
                {
                    return(View("ExternalLoginFailure"));
                }
                var user = new User
                {
                    UserName       = model.Email,
                    Email          = model.Email,
                    FirstName      = model.Firstname,
                    LastName       = model.Lastname,
                    Gender         = model.Gender,
                    DateOfBirth    = model.DateOfBirth,
                    ProfilePicture = model.ImageData
                };

                var result = await userManager.CreateAsync(user);

                if (result.Succeeded)
                {
                    result = await userManager.AddLoginAsync(user.Id, info.Login);

                    //Assign Role to user Here
                    await userManager.AddToRoleAsync(user.Id, "SuperAdmin");

                    //log activity
                    new SubplatformManager().LogActivity(ActivityType.RegisterActivity);

                    if (result.Succeeded)
                    {
                        await signInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);

                        return(RedirectToLocal(returnUrl));
                    }
                }

                AddErrors(result);
            }

            ViewBag.ReturnUrl = returnUrl;
            return(View(model));
        }
        public async Task <ApplicationUser> ProvisionNewAccount(string emailAddress, string domain)
        {
            var user = new ApplicationUser()
            {
                Email    = emailAddress,
                UserName = emailAddress,
            };

            using (var transaction = _dbContext.Database.BeginTransaction())
            {
                var createUserResult = await _userManager.CreateAsync(user);

                if (!createUserResult.Succeeded)
                {
                    _logger.Error(
                        $"Unable to create new User for {user.Email}/{user.UserName} - " +
                        $"{createUserResult.Errors.ToCommaDelimited()}");
                    return(null);
                }

                _logger.Info($"Created new User {user.Email}");

                var addToRoleResult = await _userManager.AddToRoleAsync(user.Id, SecurityConfig.UserRole);

                if (!addToRoleResult.Succeeded)
                {
                    _logger.Error(
                        $"Unable to add User {user.Email}/{user.UserName} to {SecurityConfig.UserRole} - " +
                        $"{createUserResult.Errors.ToCommaDelimited()}");
                    return(null);
                }

                _logger.Info($"Added User {user.Email} to Role {SecurityConfig.UserRole}");

                var login = new UserLoginInfo("Shopify", domain);

                var addLoginResult = await _userManager.AddLoginAsync(user.Id, login);

                if (!addLoginResult.Succeeded)
                {
                    _logger.Error(
                        $"Unable to add Login for User {user.Email}/{user.UserName} - " +
                        $"{addLoginResult.Errors.StringJoin(";")}");
                    return(null);
                }

                _logger.Info($"Added User {user.Email} Login {login.LoginProvider} / {login.ProviderKey}");

                transaction.Commit();
            }

            return(user);
        }
示例#9
0
        public async Task <ActionResult> Register(RegisterViewModel model)
        {
            IdentityUserManager userManager   = HttpContext.GetOwinContext().GetUserManager <IdentityUserManager>();
            SignInManager       signInManager = HttpContext.GetOwinContext().Get <SignInManager>();

            if (User.Identity.IsAuthenticated)
            {
                return(RedirectToAction("Index", "User"));
            }

            if (ModelState.IsValid)
            {
                var user = new User
                {
                    UserName         = model.Email,
                    Email            = model.Email,
                    FirstName        = model.Firstname,
                    LastName         = model.Lastname,
                    Gender           = model.Gender,
                    DateOfBirth      = model.DateOfBirth,
                    IsActive         = true,
                    AlertsViaWebsite = true
                };
                var result = await userManager.CreateAsync(user, model.Password);

                if (result.Succeeded)
                {
                    //Send an email with this link
                    string code = await userManager.GenerateEmailConfirmationTokenAsync(user.Id);

                    var callbackUrl = Url.Action("ConfirmEmail", "User", new { userId = user.Id, code = code },
                                                 protocol: Request.Url.Scheme);
                    await userManager.SendEmailAsync(user.Id, Resources.ConfirmAccount,
                                                     "<a href=\"" + callbackUrl + "\">" + Resources.ConfirmAccountClickingHere + "</a>");

                    //Assign Role to user
                    await userManager.AddToRoleAsync(user.Id, "User");

                    //Log activity
                    new SubplatformManager().LogActivity(ActivityType.RegisterActivity);

                    //Login
                    await signInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);

                    return(RedirectToAction("Index", "User"));
                }

                AddErrors(result);
            }

            return(View(model));
        }
示例#10
0
        private async Task CreateHostUserAsync(DataSeedContext context)
        {
            var user = await _userRepository.FindByNormalizedUserNameAsync("HostUser");

            if (user == null)
            {
                user = new IdentityUser(
                    _guidGenerator.Create(),
                    "HostUser",
                    "*****@*****.**",
                    context.TenantId
                    );

                user.SetProperty("IsHostUser", true);

                await _userManager.CreateAsync(user, "1q2w3E*");

                await _userManager.AddToRoleAsync(user, "admin");
            }
        }
示例#11
0
        public async Task <ActionResult> CreateNewUser(CreateUserViewModel model)
        {
            try
            {
                var user = new IdentityUser
                {
                    Audit          = new Audit(default(Guid)),
                    UserFullName   = model.UserFullName,
                    Email          = model.Email,
                    PhoneNumber    = model.PhoneNumber,
                    UserName       = model.Email,
                    EmailConfirmed = false,
                };
                var userresult = await UserManager.CreateAsync(user, "@123456");

                if (userresult.Succeeded)
                {
                    var RoleResult = await UserManager.AddToRoleAsync(user.Id, model.RoleName);

                    string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);

                    var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
                    await UserManager.SendEmailAsync(user.Id, "Confirm your account", "Please confirm your account by clicking <a href=\"" + callbackUrl + "\">here</a>");

                    return(RedirectToAction("UserIndex", "Account"));
                }
                else
                {
                    return(Json(userresult.Errors));
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }