Example #1
0
        public async Task <RegistrationResultDTO> RegisterAsync(RegistrationDTO registrationDto)
        {
            var registrationResult = new RegistrationResultDTO();

            var user   = Mapper.Map <RegistrationDTO, User>(registrationDto);
            var result = await _unitOfWork.UserManager.CreateAsync(user, registrationDto.Password);

            registrationResult.Succeded = result.Succeeded;
            if (result.Succeeded)
            {
                var code = await _unitOfWork.UserManager.GenerateEmailConfirmationTokenAsync(user);

                code = HttpUtility.UrlEncode(code);
                var callbackUrl = $"email/verify/{user.UserName}/{code}";

                var htmlMessage = $"Please confirm your account by clicking this link: <a href='http://localhost:3000/{callbackUrl}'>Confirm</a>";
                await _emailSender.SendEmailAsync(registrationDto.Email, "Confirm your email", htmlMessage);

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

                await _unitOfWork.SignInManager.SignInAsync(user, false);

                user.RefreshToken = _tokenService.GenerateRefreshToken();

                registrationResult.Token = await _tokenService.GenerateJwtToken(user.UserName, user.Id);

                registrationResult.Token.RefreshToken = user.RefreshToken;

                await _unitOfWork.SaveAsync();
            }

            return(registrationResult);
        }
Example #2
0
        public async Task <IActionResult> Register([FromBody] RegisterCustomerViewModel model)
        {
            model.rememberMe = false;

            try
            {
                if (!ModelState.IsValid)
                {
                    var query = from state in ModelState.Values
                                from error in state.Errors
                                select error.ErrorMessage;

                    var errorList = query.ToList();

                    return(BadRequest(new RegistrationResultDTO {
                        Status = "fail",
                        ResponseCode = "01",
                        ResponseMessage = "User Registration Failed",
                        UserSignInResult = null,
                        ErrorList = errorList
                    }));
                }
                else
                {
                    var registrationResult = await _identityService.RegisterAsync(model.email, model.Password, model.rememberMe, model.lastname, model.firstname, model.phonenumber);

                    if (registrationResult.Status == "success")
                    {
                        return(Ok(registrationResult));
                    }
                    else
                    {
                        return(BadRequest(registrationResult));
                    }
                }
            }
            catch (Exception ex)
            {
                var OtherErrors = new RegistrationResultDTO
                {
                    Status           = "fail",
                    ResponseCode     = "02",
                    ResponseMessage  = ex.Message.ToString(),
                    UserSignInResult = null,
                    ErrorList        = null
                };

                return(StatusCode(500, OtherErrors));
            }
        }
Example #3
0
        public async Task <RegistrationResultDTO> RegisterAsync(
            string email, string password, bool rememberMe, string lastname, string firstname, string phonenumber)
        {
            var isAccountExisting = await this.VerifyAccountExist(email);

            if (isAccountExisting)
            {
                RegistrationResultDTO registrationResultDTO = new RegistrationResultDTO
                {
                    Status           = "fail",
                    ResponseCode     = "01",
                    ResponseMessage  = "User registration failed. User already exists",
                    UserSignInResult = null,
                    ErrorList        = null
                };

                return(registrationResultDTO);
            }

            ApplicationUser user = new ApplicationUser();

            user.UserName       = email;
            user.Email          = email;
            user.FirstName      = firstname;
            user.LastName       = lastname;
            user.EmailConfirmed = true;
            user.PhoneNumber    = phonenumber;
            IdentityResult result = _userManager.CreateAsync(user, password).Result;

            if (result.Succeeded)
            {
                UserSignInResultDTO userSignInResult = new UserSignInResultDTO
                {
                    firstname = firstname,
                    lastname  = lastname,
                    email     = email,
                    phone     = phonenumber
                };

                _userManager.AddToRoleAsync(user, "Customer").Wait();

                var signInResult = await _signInManager.PasswordSignInAsync(email, password, rememberMe, lockoutOnFailure : false);

                if (signInResult.Succeeded)
                {
                    string secret = _appSettings.Secret;
                    string token  = IdentityUtil.generateJwtToken(user, secret);

                    userSignInResult.token = token;

                    RegistrationResultDTO registrationResultDTO = new RegistrationResultDTO
                    {
                        Status           = "success",
                        ResponseCode     = "00",
                        ResponseMessage  = "User registered successfully",
                        UserSignInResult = userSignInResult,
                        ErrorList        = null
                    };

                    return(registrationResultDTO);
                }
                else
                {
                    RegistrationResultDTO registrationResultDTO = new RegistrationResultDTO
                    {
                        Status           = "success",
                        ResponseCode     = "00",
                        ResponseMessage  = "User Registration Successful. Login to retrieve token",
                        UserSignInResult = userSignInResult,
                        ErrorList        = null
                    };

                    return(registrationResultDTO);
                }
            }
            else
            {
                RegistrationResultDTO registrationResultDTO = new RegistrationResultDTO
                {
                    Status           = "fail",
                    ResponseCode     = "01",
                    ResponseMessage  = "User Registration Failed. Please try again later",
                    UserSignInResult = null,
                    ErrorList        = null
                };

                return(registrationResultDTO);
            }
        }