コード例 #1
0
        public async Task Can_signup_user_and_change_password()
        {
            // Arrange
            var authenticationApiClient = new AuthenticationApiClient(new Uri(GetVariable("AUTH0_AUTHENTICATION_API_URL")));

            // Sign up the user
            var signupUserRequest = new SignupUserRequest
            {
                ClientId = clientId,
                Connection = connection.Name,
                Email = $"{Guid.NewGuid().ToString("N")}@nonexistingdomain.aaa",
                Password = "******"
            };
            var signupUserResponse = await authenticationApiClient.SignupUserAsync(signupUserRequest);
            signupUserResponse.Should().NotBeNull();
            signupUserResponse.Email.Should().Be(signupUserRequest.Email);

            // Change the user's Email address
            var changePasswordRequest = new ChangePasswordRequest
            {
                ClientId = signupUserRequest.ClientId,
                Connection = signupUserRequest.Connection,
                Email = signupUserRequest.Email,
                Password = "******"
            };
            string changePasswordResponse = await authenticationApiClient.ChangePasswordAsync(changePasswordRequest);
            changePasswordResponse.Should().Be("\"We've just sent you an Email to reset your password.\"");
        }
コード例 #2
0
        public async Task Can_signup_user_and_change_password()
        {
            // Arrange
            var authenticationApiClient = new AuthenticationApiClient(new Uri(GetVariable("AUTH0_AUTHENTICATION_API_URL")));

            // Sign up the user
            var signupUserRequest = new SignupUserRequest
            {
                ClientId   = GetVariable("AUTH0_CLIENT_ID"),
                Connection = connection.Name,
                Email      = $"{Guid.NewGuid().ToString("N")}@nonexistingdomain.aaa",
                Password   = "******"
            };
            var signupUserResponse = await authenticationApiClient.SignupUserAsync(signupUserRequest);

            signupUserResponse.Should().NotBeNull();
            signupUserResponse.Id.Should().NotBeNull();
            signupUserResponse.EmailVerified.Should().BeFalse();
            signupUserResponse.Email.Should().Be(signupUserRequest.Email);

            // Change the user's Email address
            var changePasswordRequest = new ChangePasswordRequest
            {
                ClientId   = signupUserRequest.ClientId,
                Connection = signupUserRequest.Connection,
                Email      = signupUserRequest.Email,
                Password   = "******"
            };
            string changePasswordResponse = await authenticationApiClient.ChangePasswordAsync(changePasswordRequest);

            changePasswordResponse.Should().Be("\"We've just sent you an email to reset your password.\"");
        }
コード例 #3
0
        public async Task Can_signup_user_and_change_password()
        {
            // Sign up the user
            var signupUserRequest = new SignupUserRequest
            {
                ClientId     = GetVariable("AUTH0_CLIENT_ID"),
                Connection   = _connection.Name,
                Email        = $"{Guid.NewGuid():N}@nonexistingdomain.aaa",
                Password     = Password,
                FamilyName   = "Surname",
                GivenName    = "Forename",
                Name         = "Full Name",
                Nickname     = "Nick",
                Picture      = new Uri("https://cdn.auth0.com/styleguide/components/1.0.8/media/logos/img/badge.png"),
                Username     = "******",
                UserMetadata = new
                {
                    a = "1",
                    b = "two"
                }
            };
            var signupUserResponse = await _authenticationApiClient.SignupUserAsync(signupUserRequest);

            signupUserResponse.Should().NotBeNull();
            signupUserResponse.Id.Should().NotBeNull();
            signupUserResponse.EmailVerified.Should().BeFalse();
            signupUserResponse.Email.Should().Be(signupUserRequest.Email);
            signupUserResponse.FamilyName.Should().Be(signupUserRequest.FamilyName);
            signupUserResponse.GivenName.Should().Be(signupUserRequest.GivenName);
            signupUserResponse.Name.Should().Be(signupUserRequest.Name);
            signupUserResponse.Nickname.Should().Be(signupUserRequest.Nickname);
            signupUserResponse.Picture.Should().Be(signupUserRequest.Picture);
        }
コード例 #4
0
        public User CreateUser(SignupUserRequest signupUserRequest)
        {
            var user = new User {
                NickName = signupUserRequest.NickName,
                Password = signupUserRequest.Password,
                Email    = signupUserRequest.Email
            };
            var result = _userRepository.AddUser(user);

            return(result);
        }
コード例 #5
0
        /// <inheritdoc/>
        public Task <SignupUserResponse> SignupUserAsync(SignupUserRequest request)
        {
            if (request == null)
            {
                throw new ArgumentNullException(nameof(request));
            }

            return(connection.SendAsync <SignupUserResponse>(
                       HttpMethod.Post,
                       BuildUri("dbconnections/signup"),
                       request));
        }
コード例 #6
0
 public async void SignUpUser(UserModel objuserModel, Auth0ConfigModel objAuth0Config)
 {
     var authenticationApi = new AuthenticationApiClient(objAuth0Config.Domain);
     SignupUserRequest signupUserRequest = new SignupUserRequest
     {
         ClientId   = objAuth0Config.ClientId,
         Connection = objAuth0Config.Connection,
         Email      = objuserModel.Email,
         Name       = objuserModel.FirstName,
         Password   = objuserModel.Password,
     };
     await authenticationApi.SignupUserAsync(signupUserRequest);
 }
コード例 #7
0
        public ActionResult Register(Models.RegisterModel model)
        {
            if (!ReCaptcha.Validate(DataUtils.GetConfig("reCaptcha:SecretKey")))
            {
                ModelState.AddModelError("", "Captcha cannot be empty");
            }

            if (ModelState.IsValid)
            {
                try
                {
                    var users = _auth0Helper.SearchAuth0UserByEmail(model.EmailAddress);
                    if (!users.Any())
                    {
                        var newUser = new SignupUserRequest();
                        newUser.ClientId     = Auth0Helper.Auth0ClientId;
                        newUser.Connection   = Auth0Helper.Connection;
                        newUser.Email        = model.EmailAddress;
                        newUser.Password     = model.Password;
                        newUser.UserMetadata = new { model.FirstName, model.LastName, model.PhoneNumber };

                        SignupUserResponse response = _client.SignupUserAsync(newUser).Result;

                        var customer = new AccountProfileModel(model.Content)
                        {
                            UserId       = $"auth0|{response.Id}",
                            EmailAddress = model.EmailAddress,
                            FirstName    = model.FirstName,
                            LastName     = model.LastName
                        };

                        MailController.Instance(Request, model.Content, CurrentUser.LanguageCode).RegistrationConfirmMail(customer).Send();
                        return(Redirect($"/{CurrentUser.LanguageCode}/account/confirm-your-email-address/"));
                    }
                    else
                    {
                        var unverifiedUser = users.FirstOrDefault(u => u.UserId.StartsWith("auth0") && u.EmailVerified == false);
                        if (unverifiedUser != null)
                        {
                            return(Redirect($"/{CurrentUser.LanguageCode}/account/resend-email-verification/?u={unverifiedUser.UserId}"));
                        }
                        ModelState.AddModelError("", "E-mail adress already exists");
                    }
                }
                catch (Exception e)
                {
                    HandleAuth0Exception(e);
                }
            }
            return(CurrentUmbracoPage());
        }
コード例 #8
0
ファイル: Signup.cs プロジェクト: Dynalon/Rainy
        public object Post(SignupUserRequest req)
        {
            if (!JsonConfig.Config.Global.AllowSignup)
                throw new Rainy.ErrorHandling.UnauthorizedException ();

            req.AdditionalData = "";
            req.Username = req.Username.ToLower ();

            // assert password is safe enough
            //if (!req.Password.IsSafeAsPassword ())
            //	throw new ValidationException () {ErrorMessage = "Password is unsafe"};

            // assert username is not already taken
            using (var db = connFactory.OpenDbConnection ()) {
                var user = db.FirstOrDefault<DBUser> (u => u.Username == req.Username);
                if (user != null)
                    throw new ConflictException () {ErrorMessage = "A user by that name already exists"};

                // assert email is not already registered
                user = db.FirstOrDefault<DBUser> (u => u.EmailAddress == req.EmailAddress);
                if (user != null)
                    throw new ConflictException () {ErrorMessage = "The emailaddress is already registered"};
            }

            // assert all required fields are filled

            var db_user = new DBUser ();
            db_user.PopulateWith (req);

            db_user.IsActivated = false;
            if (JsonConfig.Config.Global.RequireModeration == false)
                db_user.IsActivated = true;

            db_user.IsVerified = true;

            db_user.VerifySecret = Guid.NewGuid ().ToString ().Replace("-", "");

            db_user.CreateCryptoFields (req.Password);
            db_user.Password = "";

            // write user to db
            using (var db = connFactory.OpenDbConnection ()) {
                db.Insert<DBUser> (db_user);
            }

            return new HttpResult () {
                StatusCode = HttpStatusCode.OK
            };
        }
コード例 #9
0
        public async Task Signup_Response_Normalizes_Id_For_RegularDb()
        {
            // Sign up the user
            var signupUserRequest = new SignupUserRequest
            {
                ClientId   = GetVariable("AUTH0_CLIENT_ID"),
                Connection = "Username-Password-Authentication",
                Email      = $"{Guid.NewGuid():N}@nonexistingdomain.aaa",
                Password   = Password
            };
            var signupUserResponse = await _authenticationApiClient.SignupUserAsync(signupUserRequest);

            signupUserResponse.Should().NotBeNull();
            signupUserResponse.Id.Should().NotBeNull();
            signupUserResponse.Email.Should().Be(signupUserRequest.Email);
        }
コード例 #10
0
ファイル: Signup.cs プロジェクト: BooTeK/Rainy
        public object Post(SignupUserRequest req)
        {
            req.AdditionalData = "";
            req.Username = req.Username.ToLower ();

            // assert password is safe enough
            if (!req.Password.IsSafeAsPassword ())
                throw new ValidationException () {ErrorMessage = "Password is unsafe"};

            // assert username is not already taken
            using (var db = DbConfig.GetConnection ()) {
                var user = db.FirstOrDefault<DBUser> (u => u.Username == req.Username);
                if (user != null)
                    throw new ConflictException () {ErrorMessage = "A user by that name already exists"};
            }

            // assert email is not already registered
            using (var db = DbConfig.GetConnection ()) {
                var user = db.FirstOrDefault<DBUser> (u => u.EmailAddress == req.EmailAddress);
                if (user != null)
                    throw new ConflictException () {ErrorMessage = "The emailaddress is already registered"};
            }

            // assert all required fields are filled

            var db_user = new DBUser ();
            db_user.PopulateWith (req);

            db_user.IsActivated = false;
            db_user.IsVerified = false;

            db_user.VerifySecret = Guid.NewGuid ().ToString ().Replace("-", "");

            // write user to db
            using (var db = DbConfig.GetConnection ()) {
                db.Insert<DBUser> (db_user);
            }

            return new HttpResult () {
                StatusCode = HttpStatusCode.OK
            };
        }
コード例 #11
0
ファイル: Auth.cs プロジェクト: stackcollision/fleet-manager
        private async void RegisterUser(ANWI.Messaging.RegisterRequest reg)
        {
            logger.Info($"Registering new user {reg.username}");

            SignupUserRequest req = new SignupUserRequest()
            {
                ClientId   = Configuration.auth0Settings.client,
                Connection = Configuration.auth0Settings.connection,
                Email      = reg.email,
                Password   = reg.password
            };

            ANWI.Messaging.RegisterResponse.Code code
                = ANWI.Messaging.RegisterResponse.Code.OK;

            try {
                SignupUserResponse resp
                    = await auth0Client.SignupUserAsync(req);

                if (!CreateDatabaseUser(reg.username, "auth0|" + resp.Id))
                {
                    code = ANWI.Messaging.RegisterResponse.
                           Code.FAILED_SERVER_ERROR;
                }
            } catch (Auth0.Core.Exceptions.ApiException e) {
                logger.Error(
                    $"Failed to register email {reg.email}: {e.Message}");
                code = ANWI.Messaging.RegisterResponse.
                       Code.FAILED_ALREADY_EXISTS;
            } catch (Exception e) {
                logger.Error($"Other exception caught: {e.Message}");
                code = ANWI.Messaging.RegisterResponse.Code.FAILED_SERVER_ERROR;
            }

            ANWI.Messaging.Message confirm = new ANWI.Messaging.Message(
                0,
                new ANWI.Messaging.RegisterResponse(code));

            SendMessage(confirm);
        }
コード例 #12
0
        public async Task Can_signup_user_and_change_password()
        {
            // Arrange
            var authenticationApiClient =
                new AuthenticationApiClient(GetVariable("AUTH0_AUTHENTICATION_API_URL"));

            // Sign up the user
            var signupUserRequest = new SignupUserRequest
            {
                ClientId     = GetVariable("AUTH0_CLIENT_ID"),
                Connection   = _connection.Name,
                Email        = $"{Guid.NewGuid():N}@nonexistingdomain.aaa",
                Password     = Password,
                UserMetadata = new
                {
                    a = "1",
                    b = "two"
                }
            };
            var signupUserResponse = await authenticationApiClient.SignupUserAsync(signupUserRequest);

            signupUserResponse.Should().NotBeNull();
            signupUserResponse.Id.Should().NotBeNull();
            signupUserResponse.EmailVerified.Should().BeFalse();
            signupUserResponse.Email.Should().Be(signupUserRequest.Email);

            // Change the user's Email address
            var changePasswordRequest = new ChangePasswordRequest
            {
                ClientId   = signupUserRequest.ClientId,
                Connection = signupUserRequest.Connection,
                Email      = signupUserRequest.Email,
                Password   = Password2
            };
            Func <Task> changePasswordFunc = async() => await authenticationApiClient.ChangePasswordAsync(changePasswordRequest);

            changePasswordFunc.Should().Throw <ErrorApiException>().And.ApiError.Error.Should().Be("password is not allowed");
        }
コード例 #13
0
 public Task <SignupUserResponse> SignupUserAsync(SignupUserRequest request)
 {
     return(_inner.SignupUserAsync(request));
 }
コード例 #14
0
        public object Post(SignupUserRequest req)
        {
            if (!JsonConfig.Config.Global.AllowSignup)
            {
                throw new Rainy.ErrorHandling.UnauthorizedException();
            }

            req.AdditionalData = "";
            req.Username       = req.Username.ToLower();

            // assert password is safe enough
            //if (!req.Password.IsSafeAsPassword ())
            //	throw new ValidationException () {ErrorMessage = "Password is unsafe"};

            // assert username is not already taken
            using (var db = connFactory.OpenDbConnection()) {
                var user = db.FirstOrDefault <DBUser> (u => u.Username == req.Username);
                if (user != null)
                {
                    throw new ConflictException()
                          {
                              ErrorMessage = "A user by that name already exists"
                          }
                }
                ;

                // assert email is not already registered
                user = db.FirstOrDefault <DBUser> (u => u.EmailAddress == req.EmailAddress);
                if (user != null)
                {
                    throw new ConflictException()
                          {
                              ErrorMessage = "The emailaddress is already registered"
                          }
                }
                ;
            }

            // assert all required fields are filled

            var db_user = new DBUser();

            db_user.PopulateWith(req);

            db_user.IsActivated = false;
            if (JsonConfig.Config.Global.RequireModeration == false)
            {
                db_user.IsActivated = true;
            }

            db_user.IsVerified = true;

            db_user.VerifySecret = Guid.NewGuid().ToString().Replace("-", "");

            db_user.CreateCryptoFields(req.Password);
            db_user.Password = "";

            // write user to db
            using (var db = connFactory.OpenDbConnection()) {
                db.Insert <DBUser> (db_user);
            }

            return(new HttpResult()
            {
                StatusCode = HttpStatusCode.OK
            });
        }
コード例 #15
0
 /// <summary>
 /// Given the user credentials, the connection specified and the Auth0 account information, it will create a new user.
 /// </summary>
 /// <param name="request">The <see cref="SignupUserRequest" /> containing information of the user to sign up.</param>
 /// <returns>A <see cref="SignupUserResponse" /> with the information of the signed up user.</returns>
 public Task <SignupUserResponse> SignupUserAsync(SignupUserRequest request)
 {
     return(Connection.PostAsync <SignupUserResponse>("dbconnections/signup", request, null, null, null, null, null));
 }
コード例 #16
0
 public Task<SignupUserResponse> SignupUser(SignupUserRequest request)
 {
     return Connection.PostAsync<SignupUserResponse>("dbconnections/signup", request, null, null, null, null, null);
 }
コード例 #17
0
 public Task <SignupUserResponse> SignupUserAsync(SignupUserRequest request, CancellationToken cancellationToken = default)
 {
     return(_inner.SignupUserAsync(request, cancellationToken));
 }
コード例 #18
0
        public object Post(SignupUserRequest req)
        {
            req.AdditionalData = "";
            req.Username       = req.Username.ToLower();

            // assert password is safe enough
            if (!req.Password.IsSafeAsPassword())
            {
                throw new ValidationException()
                      {
                          ErrorMessage = "Password is unsafe"
                      }
            }
            ;

            // assert username is not already taken
            using (var db = DbConfig.GetConnection()) {
                var user = db.FirstOrDefault <DBUser> (u => u.Username == req.Username);
                if (user != null)
                {
                    throw new ConflictException()
                          {
                              ErrorMessage = "A user by that name already exists"
                          }
                }
                ;
            }

            // assert email is not already registered
            using (var db = DbConfig.GetConnection()) {
                var user = db.FirstOrDefault <DBUser> (u => u.EmailAddress == req.EmailAddress);
                if (user != null)
                {
                    throw new ConflictException()
                          {
                              ErrorMessage = "The emailaddress is already registered"
                          }
                }
                ;
            }

            // assert all required fields are filled

            var db_user = new DBUser();

            db_user.PopulateWith(req);

            db_user.IsActivated = false;
            db_user.IsVerified  = false;

            db_user.VerifySecret = Guid.NewGuid().ToString().Replace("-", "");

            // write user to db
            using (var db = DbConfig.GetConnection()) {
                db.Insert <DBUser> (db_user);
            }

            return(new HttpResult()
            {
                StatusCode = HttpStatusCode.OK
            });
        }
コード例 #19
0
        public User Signup([FromBody] SignupUserRequest signupUserRequest)
        {
            var result = _userService.CreateUser(signupUserRequest);

            return(result);
        }