示例#1
0
        private static void SeedAdministrator(IUserService userService)
        {
            Task.Run(async() =>
            {
                string adminName = RoleType.Administrator.ToString();

                UserEf adminUser = await userService.FindByNameAsync(adminName);

                if (adminUser is null)
                {
                    adminUser = new UserEf()
                    {
                        UserName       = adminName,
                        Email          = "*****@*****.**",
                        EmailConfirmed = true,
                        FirstName      = "Mp3MusicZone",
                        LastName       = adminName,
                        Birthdate      = new DateTime(1990, 4, 16),
                        Genre          = GenreType.Male,
                    };

                    await userService.CreateAsync(adminUser, "Test12");

                    await userService.AddToRoleAsync(adminUser, adminName);
                }
            })
            .GetAwaiter()
            .GetResult();
        }
示例#2
0
        public async Task <IActionResult> EditProfile(EditProfileViewModel model)
        {
            UserEf user = await this.userService.GetUserAsync(User);

            if (user is null)
            {
                return(RedirectToAction(nameof(HomeController.Index), "Home")
                       .WithErrorMessage($"Unable to load user with ID '{this.userService.GetUserId(User)}'."));
            }

            user.FirstName = model.FirstName;
            user.LastName  = model.LastName;
            user.Genre     = model.Genre;
            user.Birthdate = model.Birthdate;

            IdentityResult updateUserResult = await this.userService.UpdateAsync(user);

            if (!updateUserResult.Succeeded)
            {
                string errors = this.GetErrorsDescription(updateUserResult);

                return(View(model)
                       .WithErrorMessage(errors));
            }

            return(RedirectToAction(nameof(Profile))
                   .WithSuccessMessage("Your profile has been successfully updated."));
        }
示例#3
0
        private async Task SendEmailConfirmationToken(UserEf user)
        {
            string code = await this.userService.GenerateEmailConfirmationTokenAsync(user);

            string callbackUrl = Url.EmailConfirmationLink(user.Id, code, Request.Scheme);

            await emailSender.SendEmailConfirmationAsync(user.Email, callbackUrl);
        }
示例#4
0
        private FilteredUser ConvertFrom_Entity_To_FilteredUser(UserEf entity, FilteredUser model)
        {
            var instance = model ?? new FilteredUser();

            instance.Id       = entity.Id;
            instance.Email    = entity.Email;
            instance.FullName = $"{entity.Name} {entity.LastName}";

            return(instance);
        }
示例#5
0
        private static UserAccount ConvertFrom_Entity_To_Model(UserEf entity, UserAccount model)
        {
            var instance = model ?? new UserAccount();

            instance.Email    = entity.Email;
            instance.FullName = $"{entity.Name} {entity.LastName}";
            instance.Image    = entity.ImagePath.ToImage();

            return(instance);
        }
        private static InvitationEmail ConvertFrom_UserEf_To_InvitationEmail(UserEf entity, InvitationEmail model)
        {
            var instance = model ?? new InvitationEmail();

            instance.Email       = entity.Email;
            instance.UserName    = entity.Name;
            instance.Password    = entity.Password;
            instance.Residential = entity.Residential?.Name;

            return(instance);
        }
示例#7
0
        public async Task <IActionResult> Register(
            RegisterViewModel model,
            string returnUrl = null)
        {
            ViewData["ReturnUrl"] = returnUrl;

            UserEf user = await this.userService.FindByEmailAsync(model.Email);

            if (user != null)
            {
                return(View(model)
                       .WithErrorMessage($"E-mail address '{model.Email}' is already taken."));
            }

            user = new UserEf()
            {
                UserName  = model.Username,
                Email     = model.Email,
                FirstName = model.FirstName,
                LastName  = model.LastName,
                Genre     = model.Genre,
                Birthdate = model.Birthdate
            };

            IdentityResult createUserResult =
                await this.userService.CreateAsync(user, model.Password);

            IdentityResult addRoleResult = await this.userService.AddToRoleAsync(
                user,
                RoleType.RegularUser.ToString());

            if (createUserResult.Succeeded && addRoleResult.Succeeded)
            {
                logger.LogInformation("User created a new account with password.");

                await this.SendEmailConfirmationToken(user);

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

                if (returnUrl is null)
                {
                    return(View()
                           .WithSuccessMessage($"The registration is successfull. Please, verify your e-mail address {model.Email} before proceeding."));
                }

                return(this.RedirectToLocal(returnUrl));
            }

            string errors = this.GetErrorsDescription(createUserResult);

            // If we got this far, something failed, redisplay form
            return(View(model)
                   .WithErrorMessage(errors));
        }
示例#8
0
        private static User ConvertFrom_Entity_To_Model(UserEf entity, User model)
        {
            var instance = model ?? new User();

            instance.Id        = entity.Id;
            instance.Name      = entity.Name;
            instance.Email     = entity.Email;
            instance.LastName  = entity.LastName;
            instance.RoleNames = string.Join(", ", entity.UserRoles.Select(x => x.Role.Name).ToArray());

            return(instance);
        }
示例#9
0
        private async Task SendForgotPasswordToken(UserEf user)
        {
            string code = await this.userService.GeneratePasswordResetTokenAsync(user);

            string callbackUrl =
                Url.ResetPasswordCallbackLink(user.Id, code, Request.Scheme);

            callbackUrl += $"&email={user.Email}";

            await emailSender.SendEmailAsync(user.Email, "Reset Password",
                                             $"Please reset your password by clicking here: <a href='{callbackUrl}'>link</a>");
        }
        private UserLogin ConvertFrom_Entity_To_Model(UserEf entity, UserLogin model)
        {
            var instance = model ?? new UserLogin();

            instance.Id       = entity.Id;
            instance.Name     = entity.Name;
            instance.Email    = entity.Email;
            instance.LastName = entity.LastName;
            instance.Image    = entity.ImagePath.ToImage();
            instance.RoleIds  = entity?.UserRoles.Select(x => x.RoleId).ToList();

            return(instance);
        }
示例#11
0
        public async Task <IActionResult> ResendEmailConfirmation(string email)
        {
            UserEf user = await this.userService.FindByEmailAsync(email);

            if (user == null)
            {
                return(RedirectToAction(nameof(HomeController.Index), "Home")
                       .WithErrorMessage($"Unable to find user with email {email}."));
            }

            await this.SendEmailConfirmationToken(user);

            return(RedirectToAction(nameof(this.Login))
                   .WithSuccessMessage($"A verification link has been sent to email address {email}. Please verify your email."));
        }
示例#12
0
        public async Task <IActionResult> ForgotPassword(ForgotPasswordViewModel model)
        {
            UserEf user = await this.userService.FindByEmailAsync(model.Email);

            if (user == null || !(await this.userService.IsEmailConfirmedAsync(user)))
            {
                return(View()
                       .WithErrorMessage($"Invalid Email address."));
            }

            await SendForgotPasswordToken(user);

            return(View()
                   .WithSuccessMessage("Please check your email to reset your password."));
        }
示例#13
0
        private static UserToUpdate ConvertFrom_Entity_To_UserToUpdate(UserEf entity, UserToUpdate model)
        {
            var instance = model ?? new UserToUpdate();

            instance.Id        = entity.Id;
            instance.Name      = entity.Name;
            instance.Email     = entity.Email;
            instance.Password  = entity.Password;
            instance.LastName  = entity.LastName;
            instance.CellPhone = entity.CellPhone;
            instance.LandPhone = entity.LandPhone;

            instance.Roles = entity?.UserRoles.Select(x => x.RoleId).ToList();

            return(instance);
        }
示例#14
0
        public async Task SendInvitationAsync(UserEf user)
        {
            var invitation = Mapper.Map <InvitationEmail>(user);

            invitation.Url = EmailConfiguration.Url;

            var          residentialId = user.ResidentialId.Value;
            const string subjet        = "Bienvenido a Smart Residential";

            var htmlEmail = await CreateHtmlEmailAsync(residentialId, subjet);

            htmlEmail.Title   = invitation.Residential;
            htmlEmail.Content = invitation.ToHtmlContent(ContentRootPath);

            Send(htmlEmail, user.Email);
        }
示例#15
0
        public async Task <IActionResult> ChangePassword()
        {
            UserEf user = await this.userService.GetUserAsync(User);

            if (user is null)
            {
                return(RedirectToAction(nameof(HomeController.Index), "Home")
                       .WithErrorMessage($"Unable to load user with ID '{this.userService.GetUserId(User)}'."));
            }

            ChangePasswordViewModel model = new ChangePasswordViewModel
            {
                StatusMessage = StatusMessage
            };

            return(View(model));
        }
示例#16
0
        private static UserLogin ConvertFrom_Entity_To_Model(UserEf entity, UserLogin model)
        {
            var instance = model ?? new UserLogin();

            instance.Id            = entity.Id;
            instance.Name          = entity.Name;
            instance.Email         = entity.Email;
            instance.LastName      = entity.LastName;
            instance.CellPhone     = entity.CellPhone;
            instance.LandPhone     = entity.LandPhone;
            instance.ResidentialId = entity.ResidentialId;
            instance.Residential   = entity.Residential?.Name;
            instance.RoleIds       = entity.UserRoles.Select(x => x.Role.Id).ToList();
            instance.Roles         = entity.UserRoles.Select(x => x.Role?.Name).ToList();

            return(instance);
        }
示例#17
0
        private static UserEf ConvertFrom_UserToAdd_To_Entity(UserToAdd model, UserEf entity)
        {
            var instance = entity ?? new UserEf();

            instance.Name          = model.Name.RemoveSpace();
            instance.Email         = model.Email.RemoveSpace();
            instance.Password      = model.Password.RemoveSpace();
            instance.LastName      = model.LastName.RemoveSpace();
            instance.CellPhone     = model.CellPhone.RemoveSpace();
            instance.LandPhone     = model.LandPhone.RemoveSpace();
            instance.ResidentialId = model.ResidentialId;

            instance.UserRoles = model.Roles.Select(roleId => new UserRoleEf {
                RoleId = roleId
            }).ToList();

            return(instance);
        }
        public async Task Should_GetUserAsync_ResturnsALoginUserModelById()
        {
            //Arrange

            const int    userId   = 1;
            const string password = "******";
            const string email    = "*****@*****.**";

            var userEntity = new UserEf
            {
                Id       = userId,
                Email    = email,
                Password = password
            };

            var userModel = new UserLogin
            {
                Id    = userId,
                Email = email
            };

            _repositoryMock.Setup(x => x.GetUserAsync(userId))
            .ReturnsAsync(userEntity);

            _mapperMock.Setup(x => x.Map <UserLogin>(userEntity))
            .Returns(userModel);

            _manager = new UserLoginManager(_mapperMock.Object, _repositoryMock.Object);

            //Act

            var model = await _manager.GetUserAsync(userId);

            //Assert

            _repositoryMock.Verify(x => x.GetUserAsync(userId), Times.Once);
            _mapperMock.Verify(x => x.Map <UserLogin>(userEntity), Times.Once);

            Assert.NotNull(model.Email);
            Assert.Equal(userId, model.Id);
            Assert.Equal(email, model.Email);
        }
示例#19
0
        public async Task <IActionResult> EditProfile()
        {
            UserEf user = await this.userService.GetUserAsync(User);

            if (user is null)
            {
                return(RedirectToAction(nameof(HomeController.Index), "Home")
                       .WithErrorMessage($"Unable to load user with ID '{this.userService.GetUserId(User)}'."));
            }

            EditProfileViewModel model = new EditProfileViewModel()
            {
                FirstName = user.FirstName,
                LastName  = user.LastName,
                Birthdate = user.Birthdate,
                Genre     = user.Genre
            };

            return(View(model));
        }
示例#20
0
        public async Task <IActionResult> UploadProfilePicture(IFormFile file)
        {
            UserEf user = await this.userService.GetUserAsync(User);

            if (user is null)
            {
                return(RedirectToAction(nameof(HomeController.Index), "Home")
                       .WithErrorMessage($"Unable to load user with ID '{this.userService.GetUserId(User)}'."));
            }

            string messageType = string.Empty;
            string messageText = string.Empty;

            if (!file.IsImage() || file.Length > ProfileImageMaxLength)
            {
                messageType = ErrorsMessageType;
                messageText = $"Your submission should be a image file and no more than 5 MBs in size!";
            }
            else
            {
                user.ProfileImage = file.ToByteArray();

                IdentityResult result = await this.userService.UpdateAsync(user);

                if (result.Succeeded)
                {
                    messageType = SuccessMessageType;
                    messageText = "Profile Picture uploaded successfully.";
                }
                else
                {
                    messageType = ErrorsMessageType;
                    messageText = "We're sorry, something went wrong. Please try again later.";
                }
            }

            return(RedirectToAction(nameof(Profile))
                   .WithMessage(messageType, messageText));
        }
示例#21
0
        public async Task <IActionResult> Login(LoginViewModel model,
                                                string returnUrl = null)
        {
            ViewData["ReturnUrl"] = returnUrl;

            UserEf user = await this.userService.FindByNameAsync(model.Username);

            if (user != null)
            {
                bool isEmailConfirmed = await this.userService
                                        .IsEmailConfirmedAsync(user);

                if (!isEmailConfirmed)
                {
                    return(View(model)
                           .WithErrorMessage($"Please, confirm your email address, to activate your account. If you cannot find your confirmation email <a href=\"/account/resendemailconfirmation?email={user.Email}\">click here to resend it.</a>"));
                }
            }

            // This doesn't count login failures towards account lockout
            // To enable password failures to trigger account lockout, set lockoutOnFailure: true
            var result = await this.signInService
                         .PasswordSignInAsync(
                model.Username,
                model.Password,
                model.RememberMe,
                lockoutOnFailure : false);

            if (result.Succeeded)
            {
                logger.LogInformation("User logged in.");
                return(this.RedirectToLocal(returnUrl));
            }

            // If we got this far, something failed, redisplay form

            return(View(model)
                   .WithErrorMessage("Invalid login attempt."));
        }
示例#22
0
        public async Task <IActionResult> ConfirmEmail(string userId, string code)
        {
            if (User.Identity.IsAuthenticated)
            {
                return(RedirectToAction(nameof(HomeController.Index), "Home")
                       .WithErrorMessage("User already logged in."));
            }

            if (userId == null || code == null)
            {
                return(RedirectToAction(nameof(HomeController.Index), "Home"));
            }

            UserEf user = await this.userService.FindByIdAsync(userId);

            if (user == null)
            {
                throw new ApplicationException($"Unable to load user with ID '{userId}'.");
            }


            if (user.EmailConfirmed)
            {
                return(RedirectToAction(nameof(HomeController.Index), "Home")
                       .WithErrorMessage($"Email address {user.Email} is already confirmed."));
            }

            IdentityResult result = await this.userService.ConfirmEmailAsync(user, code);

            if (!result.Succeeded)
            {
                return(RedirectToAction(nameof(this.Login))
                       .WithErrorMessage("Oops! Something went wrong. Please try again."));
            }

            return(RedirectToAction(nameof(this.Login))
                   .WithSuccessMessage("Thank you for verifying your email. You can now log in."));
        }
示例#23
0
        public async Task ExecuteAsync(OnStartupNullObject command)
        {
            string adminName = "Administrator";

            UserEf adminUser = this.userService.FindByNameAsync(adminName).Result;

            if (adminUser is null)
            {
                adminUser = new UserEf()
                {
                    UserName       = adminName,
                    Email          = "*****@*****.**",
                    EmailConfirmed = true,
                    FirstName      = "Mp3MusicZone",
                    LastName       = adminName,
                    Birthdate      = new DateTime(1990, 4, 16),
                    Genre          = GenreType.Male,
                };

                await userService.CreateAsync(adminUser, "Test12");

                await userService.AddToRoleAsync(adminUser, adminName);
            }
        }
示例#24
0
        public async Task <IActionResult> ChangePassword(ChangePasswordViewModel model)
        {
            if (!ModelState.IsValid)
            {
                return(View(model));
            }

            UserEf user = await this.userService.GetUserAsync(User);

            if (user is null)
            {
                return(RedirectToAction(nameof(HomeController.Index), "Home")
                       .WithErrorMessage($"Unable to load user with ID '{this.userService.GetUserId(User)}'."));
            }

            IdentityResult changePasswordResult = await this.userService
                                                  .ChangePasswordAsync(user, model.OldPassword, model.NewPassword);

            if (!changePasswordResult.Succeeded)
            {
                string errors = this.GetErrorsDescription(changePasswordResult);

                return(View(model)
                       .WithErrorMessage(errors));
            }

            await signInService.SignInAsync(user, isPersistent : false);

            logger.LogInformation("User changed their password successfully.");
            StatusMessage = "Your password has been changed.";

            //this.TempData.AddSuccessMessage("Your password has been successfully changed.");

            return(RedirectToAction(nameof(Profile))
                   .WithSuccessMessage("Your password has been successfully changed."));
        }
示例#25
0
        public async Task <IActionResult> ResetPassword(ResetPasswordViewModel model)
        {
            UserEf user = await this.userService.FindByEmailAsync(model.Email);

            if (user == null)
            {
                return(this.RedirectToAction(nameof(HomeController.Index), "Home")
                       .WithErrorMessage("A valid email must be supplied for password reset."));
            }

            IdentityResult result = await this.userService
                                    .ResetPasswordAsync(user, model.Code, model.Password);

            if (result.Succeeded)
            {
                return(RedirectToAction(nameof(Login))
                       .WithSuccessMessage("Your password has been reset successfully."));
            }

            string errors = this.GetErrorsDescription(result);

            return(View()
                   .WithErrorMessage(errors));
        }