public async Task <ActionResult> SignUp(AccountSignUpViewModel model, string returnUrl)
        {
            if (ModelState.IsValid)
            {
                var adminUser = new AppUserEntity
                {
                    FullName    = model.Name,
                    Email       = model.Email,
                    CultureId   = User.Culture.Name,
                    UICultureId = User.UICulture.Name,
                    TimeZoneId  = User.TimeZone.Id
                };

                //
                adminUser.SetDefaultUserName();

                //
                adminUser.Realms.Add(Realm.AdminWebsite);

                //
                adminUser.Roles.Add(Role.Basic);

                //
                var result = await _appUserManager.CreateAsync(adminUser, model.Password);

                if (result.Succeeded)
                {
                    var isPersistent = false;

                    _signInManager.InitialPersistenceState = isPersistent;

                    await _signInManager.SignInAsync(
                        adminUser,
                        isPersistent,
                        rememberBrowser : false
                        );

                    return(RedirectToLocal(returnUrl));
                }

                ModelState.AddModelError(string.Empty, GetLocalizedString <AreaResources>("DefaultErrorMessage"));
            }

            ViewBag.ReturnUrl = returnUrl;

            return(View(model));
        }
        public async Task <IActionResult> SignUp(AccountSignUpViewModel model)
        {
            string returnUrl = Url.Content("~/");

            if (!ModelState.IsValid)
            {
                return(View(model));
            }

            var user = new User {
                UserName = model.Email, Email = model.Email
            };
            var result = await UserManager.CreateAsync(user, model.Password);

            if (result.Succeeded)
            {
                Logger.LogInformation("User created a new account with password.");

                var code = await UserManager.GenerateEmailConfirmationTokenAsync(user);

                code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
                var callbackUrl = Url.Action(
                    "ConfirmEmail", "Account",
                    values: new { area = "Identity", userId = user.Id, code = code },
                    protocol: Request.Scheme);

                await EmailSender.SendEmailAsync(model.Email, "Confirm your email",
                                                 $"Please confirm your account by <a href='{ HtmlEncoder.Default.Encode(callbackUrl) }'>clicking here</a>.");

                if (UserManager.Options.SignIn.RequireConfirmedAccount)
                {
                    return(RedirectToAction("SignUpConfirmation", new { email = model.Email }));
                }
                else
                {
                    await SignInManager.SignInAsync(user, isPersistent : false);

                    return(Redirect(returnUrl));
                }
            }
            foreach (var error in result.Errors)
            {
                ModelState.AddModelError(string.Empty, error.Description);
            }

            return(View(model));
        }
Ejemplo n.º 3
0
        public IActionResult SignUp(AccountSignUpViewModel accountSignUpViewModel)
        {
            if (!ModelState.IsValid)
            {
                return(Redirect("/site/vertical/pages-register.html"));
            }

            var json   = JsonConvert.SerializeObject(accountSignUpViewModel);
            var data   = new StringContent(json, Encoding.UTF8, "application/json");
            var result = _client.PostAsync("api/accounts", data).Result;

            if (result.StatusCode == System.Net.HttpStatusCode.OK)
            {
                return(Redirect("/site/vertical/pages-login.html"));
            }

            return(Redirect("/site/vertical/pages-register.html"));
        }
Ejemplo n.º 4
0
        /// <summary>
        /// Authenticates a user account returned from the Web Account Manager service.
        /// </summary>
        /// <param name="wi">Web account info object instance representing an authenticated WAM user.</param>
        /// <param name="ct">Cancellation token.</param>
        /// <returns>Response object from the server.</returns>
        public async Task <UserResponse> AuthenticateAsync(Services.WebAccountManager.WebAccountInfo wi, CancellationToken ct)
        {
            // This logic below should be server side. Token should be used to retrieve MSA and then check to see if MediaAppSample account exists else register new account.

            switch (wi.Type)
            {
            case Services.WebAccountManager.WebAccountTypes.Microsoft:
            {
                // Retrieve MSA profile data
                MicrosoftAccountDetails msa = null;
                using (var api = new MicrosoftApi())
                {
                    msa = await api.GetUserProfile(wi.Token, ct);
                }

                if (msa == null)
                {
                    throw new Exception("Could not retrieve Microsoft account profile data!");
                }

                var response = await this.IsMicrosoftAccountRegistered(msa.id, ct);

                if (response != null)
                {
                    // User account exists, return response
                    return(response);
                }
                else
                {
                    // No account exists, use MSA profile to register user
                    AccountSignUpViewModel vm = new AccountSignUpViewModel();

                    // Set all the MSA data to the ViewModel
                    vm.Populate(msa);

                    // Call the registration API to create a new account and return
                    return(await this.RegisterAsync(vm, ct));
                }
            }

            default:
                throw new NotImplementedException(wi.Type.ToString());
            }
        }
Ejemplo n.º 5
0
        //[Route("~/[controller]/[action]")]
        public async Task <IActionResult> SignUp(string returnUrl)
        {
            if (this._signInManager.IsSignedIn(User))
            {
                return(RedirectToAction("Index", "Home"));
            }

            var model = new AccountSignUpViewModel()
            {
                DateOfBirth    = DateTime.Now,
                ExternalLogins = new ExternalLoginsViewModel()
                {
                    ReturnUrl      = returnUrl,
                    ExternalLogins = (await this._signInManager.GetExternalAuthenticationSchemesAsync()).ToList()
                }
            };

            return(View(model));
        }
Ejemplo n.º 6
0
        public ActionResult SignUp(bool?isdialog, SocialType social = SocialType.None, string returnUrl = null)
        {
            var model = new AccountSignUpViewModel
            {
                SocialType    = social,
                ConnectSocial = true,
                ReturnUrl     = returnUrl
            };

            if (isdialog.HasValue)
            {
                if (isdialog.Value)
                {
                    return(View("SignUp", "_LightLayout", model));
                }
            }


            return(View(model));
        }
Ejemplo n.º 7
0
        /// <summary>
        /// Performs account creation for the application.
        /// </summary>
        /// <param name="vm">Sign up view model instance containing all the user's registration information.</param>
        /// <returns>Login response and authorization information if the account creation process was successful.</returns>
        public async Task <UserResponse> RegisterAsync(AccountSignUpViewModel vm, CancellationToken ct)
        {
            var response = new UserResponse()
            {
                AccessToken = "0987654321", RefreshToken = "qrstuvwxwyz", ID = vm.Username, Email = vm.Username, FirstName = vm.FirstName, LastName = vm.LastName
            };
            await Task.Delay(2000, ct);

            return(response);

            //var dic = new Dictionary<string, string>();
            //dic.Add("grant_type", "password");
            //dic.Add("username", vm.Username);
            //dic.Add("password", vm.Password1);
            //dic.Add("scope", "streaming");
            //var contents = new HttpFormUrlEncodedContent(dic);

            //HttpStringContent content = new HttpStringContent(message.Stringify(), UnicodeEncoding.Utf8, "application/json");

            //return await this.PostAsync<UserResponse, HttpFormUrlEncodedContent>(URL_ACCOUNT_SIGNUP, contents);
        }
Ejemplo n.º 8
0
        public async Task <ActionResult> SignUp(AccountSignUpViewModel viewModel)
        {
            if (ModelState.IsValid)
            {
                var existingUser = await _userManager.FindByEmailAsync(viewModel.Email);

                if (existingUser != null)
                {
                    ModelState.AddModelError("Email", "The provided email address has already been used.");
                }
                else
                {
                    var user = new User {
                        UserName = viewModel.Email, Email = viewModel.Email
                    };

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

                    if (result.Succeeded)
                    {
                        var userProfile = new UserProfile {
                            FullName = viewModel.FullName, JoinDate = DateTime.Today, UserId = user.Id
                        };
                        _userProfileRepository.Add(userProfile);

                        await _signInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);

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

                    foreach (var error in result.Errors)
                    {
                        ModelState.AddModelError("", error);
                    }
                }
            }
            return(View(viewModel));
        }
Ejemplo n.º 9
0
        public async Task <IActionResult> SignUp(AccountSignUpViewModel model)
        {
            model.DateOfBirth = (model.DateOfBirth.Year == 1 ? DateTime.Now : model.DateOfBirth);

            model.ExternalLogins
            .ExternalLogins = (await this._signInManager.GetExternalAuthenticationSchemesAsync()).ToList();

            if (ModelState.IsValid)
            {
                var user = new AppUser
                {
                    UserName    = model.Email,
                    FirstName   = model.FirstName,
                    LastName    = model.LastName,
                    Gendre      = model.Gendre,
                    DateOfBirth = model.DateOfBirth,
                    Email       = model.Email
                };

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

                if (result.Succeeded)
                {
                    // isPersistent if true keeps us signed in even when close the browser
                    await this._signInManager.SignInAsync(user, isPersistent : false);

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

                foreach (var error in result.Errors)
                {
                    ModelState.AddModelError("", error.Description);
                }
            }
            return(View(model));
        }
Ejemplo n.º 10
0
        public async Task <IActionResult> ExternalLoginCallback(string returnUrl = null, string remoteError = null)
        {
            returnUrl = returnUrl ?? Url.Content("~/");
            var login = new AccountSignUpViewModel()
            {
                ExternalLogins = new ExternalLoginsViewModel()
                {
                    ReturnUrl      = returnUrl,
                    ExternalLogins = (await this._signInManager.GetExternalAuthenticationSchemesAsync()).ToList()
                }
            };

            if (remoteError != null)
            {
                ModelState.AddModelError(string.Empty, $"Error from External Provider: {remoteError}");
                return(View(nameof(SignIn), login));
            }

            var info = await this._signInManager.GetExternalLoginInfoAsync();

            if (info == null)
            {
                ModelState.AddModelError(string.Empty, "Error Loading External Login Information.");
                return(View(nameof(SignIn), login));
            }

            var     email = info.Principal.FindFirstValue(ClaimTypes.Email);
            AppUser user  = null;

            if (email != null)
            {
                user = await this._userManager.FindByEmailAsync(email);
            }

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

            if (signInResult.Succeeded)
            {
                return(LocalRedirect(returnUrl));
            }
            else
            {
                if (email != null)
                {
                    if (user == null)
                    {
                        var firstName = info.Principal.FindFirstValue(ClaimTypes.GivenName);
                        var lastName  = info.Principal.FindFirstValue(ClaimTypes.Surname);
                        var name      = info.Principal.FindFirstValue(ClaimTypes.Name);
                        var gendre    = info.Principal.FindFirstValue(ClaimTypes.Gender);
                        user = new AppUser
                        {
                            UserName  = email,
                            Email     = email,
                            FirstName = firstName == null ? "User" : firstName,
                            LastName  = lastName == null ? "User" : lastName,
                            Gendre    = gendre == null ? "unset" : gendre
                        };

                        var generatedUserPassword = GenerateRandomPassword();

                        var result = await this._userManager.CreateAsync(user, generatedUserPassword);

                        if (!result.Succeeded)
                        {
                            return(RedirectToAction(nameof(SignUp), login));
                        }

                        var token = await this._userManager.GenerateEmailConfirmationTokenAsync(user);

                        var confirmationLink = Url.Action(
                            "ConfirmEmail",
                            "Account",
                            new { userId = user.Id, token = token },
                            Request.Scheme
                            );
                        this._logger.LogWarning
                        (
                            $"\n\n\n" +
                            $"\nUser: {email}" +
                            $"\nGenerated Password: \"{generatedUserPassword}\"" +
                            $"\nGenerated Email Confirmation: \"{confirmationLink}\"" +
                            $"\n\n\n"
                        );
                    }

                    await this._userManager.AddLoginAsync(user, info);

                    await this._signInManager.SignInAsync(user, isPersistent : true);

                    return(LocalRedirect(returnUrl));
                }

                var modl = new StatusResultViewModel();
                modl.Title   = $"Email claim not received from: {info.LoginProvider}";
                modl.Message = "Please contact support on [email protected]";

                return(View("../Error/NotFound", modl));
            }
        }
Ejemplo n.º 11
0
        public ActionResult SignUp(AccountSignUpViewModel model, bool?isdialog)
        {
            if (ModelState.IsValid)
            {
                var phone = UserService.NormalizePhoneNumber(model.PhoneNumber);

                var encryptedPhoneNumber = CryptographyService.EncryptPhone(phone);
                var usersWithSamePhone   = DataService.PerThread.BaseUserSet.OfType <User>().Count(u => u.EncryptedPhoneNumber == encryptedPhoneNumber);
                if (usersWithSamePhone != 0)
                {
                    throw new ValidationException("Пользователь с таким номером телефона уже зарегистрирован");
                }

                var encryptedEmail     = CryptographyService.EncryptEmail(model.Email);
                var usersWithSameEmail = DataService.PerThread.BaseUserSet.OfType <User>().Count(u => u.EncryptedEmail == encryptedEmail);
                if (usersWithSameEmail != 0)
                {
                    throw new ValidationException("Пользователь с такой электропочтой уже зарегистрирован");
                }

                var user = (User)AccountService.SignUp(model.Email, model.Email, model.Password, false);
                user.FirstName       = model.Name;
                user.SurName         = model.SurName;
                user.Patronymic      = model.Patronymic;
                user.PhoneNumber     = phone;
                user.Sex             = ValueAnalizer.GetGenderFromString(model.Gender);
                user.IsPhoneVerified = false;
                user.IsEmailVerified = false;
                user.IsOutdated      = true;

                UserService.NormalizePhoneNumber(user);

                if (model.ConnectSocial && HttpContext.Session["social_type"] != null && HttpContext.Session["social_id"] != null && HttpContext.Session["social_link"] != null)
                {
                    var socialType = (SocialType)HttpContext.Session["social_type"];
                    var socialLink = HttpContext.Session["social_link"].ToString();
                    var socialKey  = HttpContext.Session["social_id"].ToString();

                    var usersWithSameSocial = DataService.PerThread.SocialAccountSet.Count(u => u.SocialId == socialKey && u.SocialType == (byte)socialType);
                    if (usersWithSameSocial != 0)
                    {
                        throw new ValidationException("Пользователь с таким аккаунтом " + model.SocialType.ToString() + " уже зарегистрирован");
                    }

                    AccountService.ConnectSocialAccount(user, socialType, socialLink, socialKey);
                    HttpContext.Session.Remove("social_id");
                    HttpContext.Session.Remove("social_type");
                    HttpContext.Session.Remove("social_link");
                }

                DataService.PerThread.SaveChanges();

                //var code = AccountService.GenerateSecretCode(user.Id);
                //var sms = "Ваш секретный код для верификации на Демократии2: " + code;
                //SmsService.SendMessage("+7" + telephone, sms);

                //var smtp = new SmtpClient();
                //var link = ConstHelper.AppUrl + Url.Action("codeVerification", new { id = user.Id });
                //var message = new MailMessage
                //{
                //    Subject = "Ввод кода подтверждения на Демократии2",
                //    Body = "<p>Если вы еще не ввели код подтверждения, пришедший вам по смс, перейдите по ссылке: <a href='" + link + "'>" + link + "</a>.</p>" +
                //        "<p>Если вам не пришло смс, напишите на <a href='mailto:[email protected]'>[email protected]</a></p>",
                //    IsBodyHtml = true
                //};

                //message.To.Add(user.Email);

                //smtp.Send(message);
                //smtp.Dispose();

                AccountService.SendEmailVerification(user.Id);
                AccountService.TrySignIn(model.Email, model.Password, true, HttpContext.Request.UserHostAddress);

                MonitoringService.AsynchLogUserRegistration(user.Id, HttpContext.Request.UserHostAddress);

                if (string.IsNullOrWhiteSpace(model.ReturnUrl))
                {
                    return(RedirectToAction("index", "user"));
                }

                return(Redirect(model.ReturnUrl));
            }

            if (isdialog.HasValue)
            {
                if (isdialog.Value)
                {
                    return(View("SignUp", "_LightLayout", model));
                }
            }

            return(View(model));
        }