Example #1
0
        private void AddAdministrator()
        => Task
        .Run(async() =>
        {
            var existingRole = await this.roleManager.FindByNameAsync(AdministratorRole);

            if (existingRole != null)
            {
                return;
            }

            var adminRole = new BlazorShopRole(AdministratorRole);

            await this.roleManager.CreateAsync(adminRole);

            var adminUser = new BlazorShopUser
            {
                FirstName     = "Admin",
                LastName      = "Admin",
                Email         = "*****@*****.**",
                UserName      = "******",
                SecurityStamp = "RandomSecurityStamp"
            };

            await this.userManager.CreateAsync(adminUser, "admin123456");
            await this.userManager.AddToRoleAsync(adminUser, AdministratorRole);
        })
        .GetAwaiter()
        .GetResult();
        public static List <Address> GetAddresses(int count, bool sameUser = true)
        {
            var user = new BlazorShopUser
            {
                Id       = TestUser.Identifier,
                UserName = TestUser.Username
            };

            var addresses = Enumerable
                            .Range(1, count)
                            .Select(i => new Address
            {
                Id          = i,
                Country     = $"Country {i}",
                State       = $"State {i}",
                City        = $"City {i}",
                Description = $"Description {i}",
                PostalCode  = $"{i}{i}{i}{i}",
                PhoneNumber = "0888888888",
                User        = sameUser ? user : new BlazorShopUser
                {
                    Id       = $"User Id {i}",
                    UserName = $"User {i}"
                }
            })
                            .ToList();

            return(addresses);
        }
        public async Task <string> GenerateJwtAsync(BlazorShopUser user)
        {
            var claims = new List <Claim>
            {
                new Claim(ClaimTypes.NameIdentifier, user.Id),
                new Claim(ClaimTypes.Email, user.Email),
                new Claim(ClaimTypes.Name, user.FirstName),
                new Claim(ClaimTypes.Surname, user.LastName)
            };

            var isAdministrator = await this.userManager.IsInRoleAsync(user, AdministratorRole);

            if (isAdministrator)
            {
                claims.Add(new Claim(ClaimTypes.Role, AdministratorRole));
            }

            var secret = Encoding.UTF8.GetBytes(this.applicationSettings.Secret);

            var token = new JwtSecurityToken(
                claims: claims,
                expires: DateTime.UtcNow.AddDays(7),
                signingCredentials: new SigningCredentials(
                    new SymmetricSecurityKey(secret),
                    SecurityAlgorithms.HmacSha256));

            var tokenHandler   = new JwtSecurityTokenHandler();
            var encryptedToken = tokenHandler.WriteToken(token);

            return(encryptedToken);
        }
Example #4
0
        public async Task <Result> RegisterAsync(RegisterRequestModel model)
        {
            var user = new BlazorShopUser
            {
                FirstName = model.FirstName,
                LastName  = model.LastName,
                Email     = model.Email,
                UserName  = model.Email
            };

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

            var errors = identityResult.Errors.Select(e => e.Description);

            return(identityResult.Succeeded
                ? Result.Success
                : Result.Failure(errors));
        }