public async Task <IActionResult> Register([FromBody] UserRegistrationRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(new AuthFailedResponse {
Errors = ModelState.Values
.SelectMany(e => e.Errors
.Select(er => er.ErrorMessage))
}));
}
var authResponse = await _identityService
.RegisterAsync(request.Email, request.Password);
if (!authResponse.Success)
{
return(BadRequest(new AuthFailedResponse
{
Errors = authResponse.Errors
}));
}
return(Ok(new AuthSuccessResponse
{
Token = authResponse.Token,
RefreshToken = authResponse.RefreshToken
}));
}
public async Task <IActionResult> Register([FromBody] UserRegistrationRequest user)
{
var existingUser = await _userManager.FindByEmailAsync(user.Email);
if (existingUser is not null)
{
return(BadRequest(new BadRequestResponse {
Message = "User already exists."
}));
}
var newUser = new IdentityUser()
{
Email = user.Email, UserName = user.Email,
};
var isCreated = await _userManager.CreateAsync(newUser, user.Password);
if (isCreated.Succeeded)
{
var jwtToken = GenerateJwtToken(newUser);
return(Ok(new UserRegistrationResponse {
Token = jwtToken
}));
}
return(BadRequest(isCreated.Errors.Select(x => x.Description).ToList()));
}
public IActionResult Register([FromForm] UserRegistrationRequest register)
{
// Open DB connection
if (authUnit.Users.GetUserByUsername(register.Username) != null)
{
return(Conflict("User already exists"));
}
// Write user info
var user = mapper.Map <UserModel>(register);
// Hash password
user.Password = cryptoService.Compute(register.Password);
user.PasswordSalt = cryptoService.Salt;
user.JoinDate = DateTime.Now;
user.DisplayName = register.Username;
// Save/close DB
authUnit.Users.AddUser(user);
authUnit.Complete();
var userDto = mapper.Map <UserProfileResponse>(user);
return(CreatedAtRoute(nameof(GetUser), new { username = userDto.Username }, userDto));
}
public async Task <IActionResult> TenantRegister([FromBody] UserRegistrationRequest request)
{
AuthenticationResult authResponse = await _identityService.TenantRegisterAsync(request.Email, request.Password);
if (!authResponse.Success)
{
if (authResponse.Errors.Count() > 1)
{
return(BadRequest(new AuthenticationFailedResponse
{
Errors = authResponse.Errors
}));
}
else
{
return(BadRequest(authResponse.Errors.ToList()[0]));
}
}
return(Ok(new AuthenticationSuccessResponse
{
//Id = authResponse.Id,
Token = authResponse.Token
}));
}
// Helper Functions
public UserAuth ToUserAuth(UserRegistrationRequest request)
{
var to = request.ConvertTo <UserAuth>();
to.PrimaryEmail = request.Email;
return(to);
}
public RegisterStepOnePage(RetailerList objRetailerList)
{
InitializeComponent();
NavigationPage.SetBackButtonTitle(this, "");
XFLblTAC.Text = $"T&C";
_objGetDetailsFromZipcodeResponse = new GetDetailsFromZipcodeResponse();
_baseUrl = Domain.Url + Domain.GetDetailsByZipCode;
_objHeaderModel = new HeaderModel();
_apiService = new RestApi();
_objRetailerList = new RetailerList();
if (Settings.IsLoggedIn)
{
xfGridPass.IsVisible = false;
}
if (objRetailerList != null)
{
_objRetailerList = objRetailerList;
imgCompanyLogo.Source = objRetailerList.imagePath;
XFLBLCompanyRate.Text = $"{objRetailerList.rate:0.00}" + "c";
XFBTN_Duration.Text = objRetailerList.duration + " Months";
}
_objUserRegistrationRequest = new UserRegistrationRequest();
GetDeatailsFromZipCode();
}
static void Main(string[] args)
{
var userService = new UserService();
var registrationSpecificationFactory = new RegistrationSpecificationFactory();
var controller = new UserController(userService, registrationSpecificationFactory);
var user = new UserRegistrationRequest("shairhem", "*****@*****.**", "password", "password");
controller.RegisterUser(user);
var user1 = new UserRegistrationRequest("", "*****@*****.**", "password", "password");
controller.RegisterUser(user1);
var user2 = new UserRegistrationRequest("shairhem", "shairhem.com", "password", "password");
controller.RegisterUser(user2);
var user3 = new UserRegistrationRequest("shairhem", "shairhem.com", "password", "");
controller.RegisterUser(user3);
var user4 = new UserRegistrationRequest("shairhem", "shairhem.com", "", "");
controller.RegisterUser(user4);
}
public IActionResult Registration(UserRegistrationRequest userDetails)
{
try
{
if (!ValidateRegistrationRequest(userDetails))
{
return(BadRequest(new { Message = "Enter Proper Data" }));
}
var data = _userBusiness.Registration(userDetails);
if (data == null)
{
message = "No Data Provided";
return(Ok(new { success, message }));
}
else
{
success = true;
message = "User Account Created Successfully";
return(Ok(new { success, message, data }));
}
}
catch (Exception e)
{
return(BadRequest(new { e.Message }));
}
}
public async Task <IActionResult> Register([FromBody] UserRegistrationRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(new AuthFailedResponse
{
Errors = ModelState.Values.SelectMany(x => x.Errors.Select(a => a.ErrorMessage))
}));
}
var authResponse = await _identityService.RegisterAsync(request);
if (!authResponse.Success)
{
return(BadRequest(new AuthFailedResponse
{
Errors = authResponse.Errors
}));
}
return(Ok(new AuthSuccessResponse
{
Token = authResponse.Token,
UserType = request.UserType
}));
}
public async Task <IActionResult> Register([FromBody] UserRegistrationRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(new AutherizationFailedResponse
{
Errors = ModelState.Values.SelectMany(x => x.Errors.Select(xx => xx.ErrorMessage))
}));
}
var authResponse = await _identityService.RegisterAsync(request.Email, request.Password);
if (authResponse.Errors != null)
{
return(BadRequest(new AutherizationFailedResponse
{
Errors = authResponse.Errors
}));
}
return(Ok(new AutherizationSuccessResponse
{
JwtToken = authResponse.Token
}));
}
public async Task <AuthenticationResult> RegisterAsync(UserRegistrationRequest request)
{
if (datacontext.Users.AsNoTracking().Any(x => x.UserName == request.UserName))
{
return new AuthenticationResult
{
Errors = new[] { "O username que inseriu já se encontra em Uso" }
}
}
;
byte[] passwordHash, passwordSalt;
CreatePasswordHash(request.Password, out passwordHash, out passwordSalt);
var newUser = new User
{
Email = request.Email,
UserName = request.UserName,
PasswordHash = passwordHash,
PasswordSalt = passwordSalt,
Role = "User"
};
datacontext.Users.Add(newUser);
datacontext.SaveChanges();
return(GenerateAuthenticationResult(newUser));
}
public async Task <IActionResult> Register([FromBody] UserRegistrationRequest request)
{
if (request.Email == null ||
request.Password == null ||
request.UserName == null)
{
return(BadRequest("data cann't be empty for registration"));
}
_logger.LogInformation($"New registration request {request.Email} {request.Password}");
if (!ModelState.IsValid)
{
return(BadRequest(new AuthFailedResponse
{
Errors = ModelState.Values.SelectMany(x => x.Errors.Select(xx => xx.ErrorMessage))
}));
}
var authResponse = await _identityService.RegisterAsync(request);
if (!authResponse.Success)
{
return(BadRequest(new AuthFailedResponse
{
Errors = authResponse.Errors
}));
}
return(Ok(new AuthSuccessResponse
{
Token = authResponse.Token,
RefreshToken = authResponse.RefreshToken
}));
}
public async Task <IActionResult> Register([FromBody] UserRegistrationRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(new AuthFailedResponse
{
Errors = ModelState.Values.SelectMany(entry => entry.Errors.Select(error => error.ErrorMessage))
}));
}
var authResponse = await _identityService.RegisterAsync(request.Email, request.Password, request.FirstName,
request.LastName, request.BirthDay, request.Gender, request.UserName);
if (authResponse.Success == false)
{
return(BadRequest(new AuthFailedResponse
{
Errors = authResponse.Errors
}));
}
return(Ok(new AuthSuccessResponse
{
Token = authResponse.Token,
RefreshToken = authResponse.RefreshToken
}));
}
public IHttpActionResult Register([FromBody] UserRegistrationRequest user)
{
try
{
if (user == null || user.RequiredFieldsAreNullOrBlank)
{
return(BadRequest("Some or all of the data required for user registration is blank or missing."));
}
if (user.PasswordsDoNotMatch)
{
return(BadRequest("Your passwords do not match. Please try again."));
}
if (_users.FindUserByEmail(user.email) != null)
{
return(BadRequest("A user with this email already exists. Please try again."));
}
var u = _userFactory.CreateUser(user, ref _users);
var result = _users.Register(u);
if (result.Status == RepositoryActionStatus.Created)
{
var newUser = _userFactory.CreateAuthenticatedUser(result.Entity);
var response = _responseFactory.CreateResponse(newUser);
return(Ok(response));
}
return(BadRequest());
}
catch (Exception ex)
{
return(InternalServerError());
}
}
public ActionResult Register(RegisterModel model, string returnUrl)
{
//如果当前用户再注册别的用户，就让他先退出，加入一个Guest角色用户进来准备。
var user = _service.InsertGuestUser();
if (ModelState.IsValid)
{
if (model.UserName != null)
{
model.UserName = model.UserName.Trim();
}
var isApprove = true;
var registerRequest = new UserRegistrationRequest(user, model.Email, model.Mobile, model.UserName, model.Password, PasswordFormat.Encrypted, isApprove);
var registrationResult = _accountService.RegisterUser(registerRequest);
if (registrationResult.Success)
{
if (isApprove)
{
AuthenticationService.SignIn(user, true);
}
if (String.IsNullOrEmpty(returnUrl) || !Url.IsLocalUrl(returnUrl))
{
return(RedirectToAction("Index", "Home", new { Area = "Admin" }));
}
return(Redirect(returnUrl));
}
foreach (var error in registrationResult.Errors)
{
ModelState.AddModelError("", error);
}
}
return(View(model));
}
public async Task <AuthenticationResult> RegisterAsync(UserRegistrationRequest request)
{
var existingUser = await _userManager.FindByEmailAsync(request.Email);
if (existingUser != null)
{
return(new AuthenticationResult
{
Errors = new[] { "User with this email address already exists" }
});
}
var newUserId = Guid.NewGuid();
var newUser = new CustomUser
{
Id = newUserId.ToString(),
Email = request.Email,
UserName = request.UserName,
EmailConfirmed = true
};
var createdUser = await _userManager.CreateAsync(newUser, request.Password);
if (!createdUser.Succeeded)
{
return(new AuthenticationResult
{
Errors = createdUser.Errors.Select(x => x.Description)
});
}
return(await GenerateAuthenticationResultForUserAsync(newUser));
}
public async Task <AuthenticationResult> RegisterAsync(UserRegistrationRequest request)
{
var user = await _userManager.FindByNameAsync(request.Username);
if (user != null)
{
return(new AuthenticationResult
{
Errors = new[] { "Username already exists!" }
});
}
var newUsr = new IdentityUser
{
UserName = request.Username,
Email = request.Email
};
var createdUser = await _userManager.CreateAsync(newUsr, request.Password);
if (!createdUser.Succeeded)
{
return(new AuthenticationResult
{
Errors = createdUser.Errors.Select(x => x.Description)
});
}
return(GenerateAuthenticationResult(newUsr));
}
public RegistrationResponse Registration(UserRegistrationRequest userDetails)
{
try
{
RegistrationResponse responseData = null;
userDetails.Password = EncodeDecode.EncodePasswordToBase64(userDetails.Password);
var userData = new Users
{
FirstName = userDetails.FirstName,
LastName = userDetails.LastName,
Email = userDetails.Email,
Password = userDetails.Password,
IsActive = true,
UserRole = _user,
CreatedDate = DateTime.Now,
ModifiedDate = DateTime.Now
};
_appDBContext.Add(userData);
_appDBContext.SaveChanges();
responseData = ResponseData(userData);
return(responseData);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public void can_assign_roles()
{
var createRequest = new UserRegistrationRequest
{
Email = "*****@*****.**",
Password = "******",
AutoLogin = false
};
var createResponse = RestClient.Post <UserRegistrationResponse>(createRequest);
Assert.IsNotNull(createResponse);
Assert.IsTrue(createResponse.UserId.Length > 0);
//login an admin
var checkLoginStatus = RestClient.Post <AuthenticateResponse>(new Authenticate {
provider = "credentials", UserName = DefaultAdmin.Email, Password = DefaultAdmin.Password
});
Assert.IsNotNull(checkLoginStatus);
Assert.AreEqual(DefaultAdmin.Email, checkLoginStatus.UserName);
var response = RestClient.Post(
new AssignRoles
{
UserName = "******",
Roles = { "Role1", "Role2" },
Permissions = { "Permission1", "Permission2" }
});
Assert.That(response.AllRoles, Is.EquivalentTo(new[] { "Role1", "Role2" }));
Assert.That(response.AllPermissions, Is.EquivalentTo(new[] { "Permission1", "Permission2" }));
}
public async Task <IActionResult> Register([FromBody] UserRegistrationRequest request)
{
string erro;
if (!ValidatePassword(request.Password, out erro))
{
return(BadRequest(erro.ToString()));
}
if (!IsValidEmail(request.Email) || request.Email == string.Empty)
{
return(BadRequest(new FailedResponse
{
Errors = new[] { "Introduza um Email Válido" }
}));
}
var authResponse = await identityService.RegisterAsync(request);
if (!authResponse.Success)
{
return(BadRequest(new FailedResponse
{
Errors = authResponse.Errors
}));
}
return(Ok(new SucessResponse
{
Token = authResponse.Token
}));
}
public async Task <ResponseState> RegisterValidator(UserRegistrationRequest model)
{
var response = ValidateRole(model.Role);
if (!response.IsValid)
{
return(response);
}
response = await ValidatePassword(model.Password, model.ConfirmPassword);
if (!response.IsValid)
{
return(response);
}
response = await ValidateExistingUser(model.Email);
if (!response.IsValid)
{
return(response);
}
return(response);
}
public ActionResult AddUserToRegistered([FromBody] UserRegistrationRequest userRegistrationRequest)
{
_registeredUsersStorage.AddUser(userRegistrationRequest.Login,
userRegistrationRequest.Password);
return(new OkResult());
}
public async Task <IActionResult> Register([FromBody] UserRegistrationRequest request)
{
if (!ModelState.IsValid)
{
List <string> errors = new List <string>();
foreach (var errorEntry in ModelState.Values)
{
foreach (var singleError in errorEntry.Errors)
{
errors.Add(singleError.ErrorMessage);
}
}
return(BadRequest(new AuthFailedResponse
{
Errors = errors
}));
}
var authResponse = await _identityService.RegisterAsync(request.Email, request.Password);
if (!authResponse.Success)
{
return(BadRequest(new AuthFailedResponse
{
Errors = authResponse.Errors
}));
}
return(Ok(new AuthSuccessResponse {
Token = authResponse.Token,
RefreshToken = authResponse.RefreshToken
}));
}
public async Task <AuthenticationResult> RegisterAsync(UserRegistrationRequest request)
{
var user = await this.userManager.FindByEmailAsync(request.Email);
if (user != null)
{
return(new AuthenticationResult
{
Errors = new[] { "User with this email address already exist" }
});
}
var newUser = new User
{
FirstName = request.FirstName,
LastName = request.LastName,
Email = request.Email,
UserName = request.Email
};
var createdUser = await this.userManager.CreateAsync(newUser, request.Password);
if (!createdUser.Succeeded)
{
return(new AuthenticationResult
{
Errors = createdUser.Errors.Select(x => x.Description)
});
}
await this.userManager.AddToRoleAsync(newUser, Roles.User);
return(await GenerateAuthenticationResultForUserAsync(newUser));
}
public UserRegistrationContext(UserRegistrationRequest request, UserManager <UserEntity> userManager, RoleManager <RoleEntity> roleManager)
{
this.RoleManager = roleManager;
this.UserManager = userManager;
this.Request = request;
this.Result = new UserRegistrationResponse();
}
public void can_assign_roles()
{
var createRequest = new UserRegistrationRequest
{
Email = "*****@*****.**",
Password = "******",
AutoLogin = false
};
var createResponse = RestClient.Post<UserRegistrationResponse>(createRequest);
Assert.IsNotNull(createResponse);
Assert.IsTrue(createResponse.UserId.Length > 0);
//login an admin
var checkLoginStatus = RestClient.Post<AuthenticateResponse>(new Authenticate { provider = "credentials", UserName = DefaultAdmin.Email, Password = DefaultAdmin.Password });
Assert.IsNotNull(checkLoginStatus);
Assert.AreEqual(DefaultAdmin.Email, checkLoginStatus.UserName);
var response = RestClient.Post(
new AssignRoles
{
UserName = "******",
Roles = { "Role1", "Role2" },
Permissions = { "Permission1", "Permission2" }
});
Assert.That(response.AllRoles, Is.EquivalentTo(new[] { "Role1", "Role2" }));
Assert.That(response.AllPermissions, Is.EquivalentTo(new[] { "Permission1", "Permission2" }));
}
public async Task <IActionResult> Register([FromBody] UserRegistrationRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(new AuthFailedResponse
{
Errors = ModelState.Values.SelectMany(x => x.Errors.Select(xx => xx.ErrorMessage))
}));
}
var authResponse = await _identityService.RegisterAsync(request.Email, request.Name, request.Password, request.Role, request.Business);
if (!authResponse.Success)
{
return(BadRequest(new AuthFailedResponse
{
Errors = authResponse.Errors
}));
}
return(Ok(new AuthSuccessResponse
{
Id = authResponse.Id,
Name = authResponse.Name,
Email = authResponse.Email,
Role = authResponse.Role,
Success = true
}));
}
public async Task <IActionResult> Register([FromBody] UserRegistrationRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(new AuthFailedResponse
{
Errors = ModelState.Values.SelectMany(x => x.Errors.Select(xx => xx.ErrorMessage))
}));
}
if (request.userType.Equals(UserType.Auditor))
{
PublishEvent(new AuditorProfileCreationRequest()
{
Name = request.Email
});
}
var authResponse = await _identityService.RegisterAsync(request.Email, request.Password);
if (!authResponse.Success)
{
return(BadRequest(new AuthFailedResponse
{
Errors = authResponse.Errors
}));
}
return(Ok(new AuthSuccessResponse
{
Token = authResponse.Token,
RefreshToken = authResponse.RefreshToken
}));
}
public void user_can_not_update_if_not_authenticated()
{
// ReSharper disable RedundantTypeArgumentsOfMethod
var createRequest = new UserRegistrationRequest
{
Email = "*****@*****.**",
Password = "******",
AutoLogin = true
};
var createResponse = RestClient.Post <UserRegistrationResponse>(createRequest);
Assert.IsNotNull(createResponse);
Assert.IsTrue(createResponse.UserId.Length > 0);
var checkLoginStatus = RestClient.Post <AuthenticateResponse>(new Authenticate());
Assert.IsNotNull(checkLoginStatus);
Assert.AreEqual(createRequest.Email, checkLoginStatus.UserName);
//logout
Logout();
// try and fail update the password
var updateRequest = new UserRegistrationRequest {
Email = "*****@*****.**", Password = "******"
};
var error = Assert.Throws <WebServiceException>(() => RestClient.Put <UserRegistrationResponse>(updateRequest));
Assert.AreEqual("Unauthorized", error.Message);
// ReSharper restore RedundantTypeArgumentsOfMethod
}
public async Task <AuthenticationResult> RegisterAsync(UserRegistrationRequest request)
{
var existingUser = await _userManager.FindByEmailAsync(request.Email);
if (existingUser != null)
{
return(new AuthenticationResult
{
Errors = new[] { "User with this email address already exists." }
});
}
var newUser = new User
{
Email = request.Email,
UserName = request.Email,
Type = request.UserType
};
var createdUser = await _userManager.CreateAsync(newUser, request.Password);
if (!createdUser.Succeeded)
{
return(new AuthenticationResult
{
Errors = createdUser.Errors.Select(x => x.Description)
});
}
return(GenerateAuthenticationResult(newUser));
}
RegisterAsync([FromBody] UserRegistrationRequest request, CancellationToken cancellationToken = default(CancellationToken))
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.Values
.SelectMany(x => x.Errors
.Select(xx => xx.ErrorMessage))
.Join("\n")));
}
try
{
var result = await _service.RegisterAsync(request, cancellationToken);
return(result.IsError
? throw new InvalidOperationException(result.Message)
: result.IsSuccess
? (IActionResult)NoContent()
: BadRequest(result.Message));
}
catch (InvalidOperationException ex)
{
return(StatusCode(StatusCodes.Status500InternalServerError, ex.Message));
}
}
private INavigation _navigation; // HERE
public UserViewModel(INavigation navigation)
{
_navigation = navigation;
Setup();
UserRegInfo = new UserRegistrationPayload(); //{ first_name = "Mohd", last_name = "Riyaz", email = "*****@*****.**", mobileno = "0987654321", password = "******", city = "", address = "test road, test" };
_userDetails = new ObservableCollection<UserRegistrationRequest>();
UserListInfo = new UserRegistrationRequest();
GetCountriesCommand.Execute(null);
//GetAllUsers.Execute(null);
}
/*
[Test]
public void Accepts_valid_registration_with_autologon()
{
var service = GetRegistrationService();
var request = GetValidRegistrationRequest(true);
var response = service.Post(request);
Assert.That(response as UserRegistrationResponse, Is.Not.Null);
}*/
public static UserRegistrationRequest GetValidRegistrationRequest(bool autoLogin = false)
{
var request = new UserRegistrationRequest
{
DisplayName = "DisplayName",
Email = "*****@*****.**",
FirstName = "FirstName",
LastName = "LastName",
Password = "******",
UserName = "******",
AutoLogin = autoLogin,
};
return request;
}
public void can_register_a_new_user_and_log_them_on()
{
// ReSharper disable RedundantTypeArgumentsOfMethod
var createRequest = new UserRegistrationRequest
{
Email = "*****@*****.**",
Password = "******",
AutoLogin = true
};
var createResponse = RestClient.Post<UserRegistrationResponse>(createRequest);
Assert.IsNotNull(createResponse);
Assert.IsTrue(createResponse.UserId.Length > 0);
var checkLoginStatus = RestClient.Post<AuthenticateResponse>(new Authenticate());
Assert.IsNotNull(checkLoginStatus);
Assert.AreEqual(createRequest.Email, checkLoginStatus.UserName);
//logout
Logout();
// ReSharper restore RedundantTypeArgumentsOfMethod
}
public void non_admins_can_not_update_other_passwords()
{
// ReSharper disable RedundantTypeArgumentsOfMethod
var createRequest = new UserRegistrationRequest
{
Email = "*****@*****.**",
Password = "******",
AutoLogin = true
};
var createResponse = RestClient.Post<UserRegistrationResponse>(createRequest);
Assert.IsNotNull(createResponse);
Assert.IsTrue(createResponse.UserId.Length > 0);
var checkLoginStatus = RestClient.Post<AuthenticateResponse>(new Authenticate());
Assert.IsNotNull(checkLoginStatus);
Assert.AreEqual(createRequest.Email, checkLoginStatus.UserName);
//login as a non-admin
checkLoginStatus = RestClient.Post<AuthenticateResponse>(new Authenticate { provider = "credentials", UserName = TestUser.Email, Password = TestUser.Password });
Assert.IsNotNull(checkLoginStatus);
Assert.AreEqual(TestUser.Email, checkLoginStatus.UserName);
// try and fail update the password
var updateRequest = new UpdateUserRegistrationPasswordRequest { Email = "*****@*****.**", NewPassword = "******" };
var error = Assert.Throws<WebServiceException>(() => RestClient.Post<UpdateUserRegistrationPasswordResponse>(updateRequest));
Assert.AreEqual("Invalid Role", error.Message);
//logout
Logout();
// ReSharper restore RedundantTypeArgumentsOfMethod
}
public void user_an_admin_update_registration_password()
{
// ReSharper disable RedundantTypeArgumentsOfMethod
var createRequest = new UserRegistrationRequest
{
Email = "*****@*****.**",
Password = "******",
AutoLogin = true
};
var createResponse = RestClient.Post<UserRegistrationResponse>(createRequest);
Assert.IsNotNull(createResponse);
Assert.IsTrue(createResponse.UserId.Length > 0);
//login as admin
var checkLoginStatus = RestClient.Post<AuthenticateResponse>(new Authenticate { provider = "credentials", UserName = DefaultAdmin.Email, Password = DefaultAdmin.Password });
Assert.IsNotNull(checkLoginStatus);
Assert.AreEqual(DefaultAdmin.Email, checkLoginStatus.UserName);
//update password
var updateResponse = RestClient.Post<UpdateUserRegistrationPasswordResponse>(new UpdateUserRegistrationPasswordRequest{Email = "*****@*****.**", NewPassword = "******"});
Assert.IsNotNull(updateResponse);
Assert.IsTrue(updateResponse.UserId.Length > 0);
//logoff
Logout();
// login as the updated user
checkLoginStatus = RestClient.Post<AuthenticateResponse>(new Authenticate { provider = "credentials", UserName = "******", Password = "******"});
Assert.IsNotNull(checkLoginStatus);
Assert.AreEqual("*****@*****.**", checkLoginStatus.UserName);
//logoff
Logout();
// ReSharper restore RedundantTypeArgumentsOfMethod-
}
public void user_can_not_update_if_not_authenticated()
{
// ReSharper disable RedundantTypeArgumentsOfMethod
var createRequest = new UserRegistrationRequest
{
Email = "*****@*****.**",
Password = "******",
AutoLogin = true
};
var createResponse = RestClient.Post<UserRegistrationResponse>(createRequest);
Assert.IsNotNull(createResponse);
Assert.IsTrue(createResponse.UserId.Length > 0);
var checkLoginStatus = RestClient.Post<AuthenticateResponse>(new Authenticate());
Assert.IsNotNull(checkLoginStatus);
Assert.AreEqual(createRequest.Email, checkLoginStatus.UserName);
//logout
Logout();
// try and fail update the password
var updateRequest = new UserRegistrationRequest {Email = "*****@*****.**", Password = "******"};
var error = Assert.Throws<WebServiceException>(() => RestClient.Put<UserRegistrationResponse>(updateRequest));
Assert.AreEqual("Unauthorized", error.Message);
// ReSharper restore RedundantTypeArgumentsOfMethod
}
public void user_can_update_their_password()
{
// ReSharper disable RedundantTypeArgumentsOfMethod
var createRequest = new UserRegistrationRequest
{
Email = "*****@*****.**",
Password = "******",
AutoLogin = true
};
var createResponse = RestClient.Post<UserRegistrationResponse>(createRequest);
Assert.IsNotNull(createResponse);
Assert.IsTrue(createResponse.UserId.Length > 0);
var checkLoginStatus = RestClient.Post<AuthenticateResponse>(new Authenticate());
Assert.IsNotNull(checkLoginStatus);
Assert.AreEqual(createRequest.Email, checkLoginStatus.UserName);
//update the password
var updateRequest = new UserRegistrationRequest {Password = "******"};
var updateResponse = RestClient.Put<UserRegistrationResponse>(updateRequest);
Assert.IsNotNull(updateResponse);
Assert.IsTrue(updateResponse.UserId.Length > 0);
//logout
Logout();
//logon with the new password
checkLoginStatus = RestClient.Post<AuthenticateResponse>(new Authenticate {provider = "credentials", UserName = "******", Password = "******"});
Assert.IsNotNull(checkLoginStatus);
Assert.AreEqual("*****@*****.**", checkLoginStatus.UserName);
//logout
Logout();
// ReSharper restore RedundantTypeArgumentsOfMethod-
}
public void test_login_logout_using_basic_auth()
{
// ReSharper disable RedundantTypeArgumentsOfMethod
var createRequest = new UserRegistrationRequest
{
Email = "*****@*****.**",
Password = "******",
AutoLogin = false
};
var createResponse = RestClient.Post<UserRegistrationResponse>(createRequest);
Assert.IsNotNull(createResponse);
Assert.IsTrue(createResponse.UserId.Length > 0);
//logout - in case we had an open session
Logout();
// login the user in by making a request with a Basic Auth Header
var client = new JsonServiceClient {AlwaysSendBasicAuthHeader = true, BaseUri = WebServiceHostUrl, UserName = "******", Password = "******"};
var response = client.Get<List<Transaction>>(new GetTransactions());
Assert.IsNotNull(response);
var checkLoginStatus = client.Post<AuthenticateResponse>(new Authenticate());
Assert.IsNotNull(checkLoginStatus);
Assert.AreEqual("*****@*****.**", checkLoginStatus.UserName);
//logout
Logout();
// ReSharper restore RedundantTypeArgumentsOfMethod
}
private static HttpError PostRegistrationError(UserRegistrationService service, UserRegistrationRequest register)
{
var response = (HttpError)service.RunAction(register, (svc, req) => svc.Post(req));
return response;
}
public void test_login_logout_using_credential_auth()
{
// ReSharper disable RedundantTypeArgumentsOfMethod
var createRequest = new UserRegistrationRequest
{
Email = "*****@*****.**",
Password = "******",
AutoLogin = false
};
var createResponse = RestClient.Post<UserRegistrationResponse>(createRequest);
Assert.IsNotNull(createResponse);
Assert.IsTrue(createResponse.UserId.Length > 0);
//logout - in case we had an open session
RestClient.Post(new Authenticate {provider = "logout"});
var error = Assert.Throws<WebServiceException>(() => RestClient.Post<AuthenticateResponse>(new Authenticate()));
Assert.AreEqual("Not Authenticated", error.Message);
// login the user in
var checkLoginStatus = RestClient.Post<AuthenticateResponse>(new Authenticate {provider = "credentials", UserName = "******", Password = "******"});
Assert.IsNotNull(checkLoginStatus);
Assert.AreEqual("*****@*****.**", checkLoginStatus.UserName);
// we should stay logged in
checkLoginStatus = RestClient.Post<AuthenticateResponse>(new Authenticate());
Assert.IsNotNull(checkLoginStatus);
Assert.AreEqual("*****@*****.**", checkLoginStatus.UserName);
//logout
Logout();
// ReSharper restore RedundantTypeArgumentsOfMethod
}
public void Requires_unique_UserName_and_Email()
{
var mockExistingUser = new UserAuth();
var mock = new Mock<IUserAuthRepository>();
mock.Setup(x => x.GetUserAuthByUserName(It.IsAny<string>()))
.Returns(() => mockExistingUser).Verifiable();
var mockUserAuth = mock.Object;
var service = new UserRegistrationService
{
UserRegistrationRequestValidator = new UserRegistrationRequestValidator { UserAuthRepo = mockUserAuth },
AuthRepo = mockUserAuth,
};
var request = new UserRegistrationRequest
{
DisplayName = "DisplayName",
Email = "*****@*****.**",
FirstName = "FirstName",
LastName = "LastName",
Password = "******",
UserName = "******",
};
var response = PostRegistrationError(service, request);
var errors = response.GetFieldErrors();
Assert.That(errors.Count, Is.EqualTo(2));
Assert.That(errors[0].ErrorCode, Is.EqualTo("AlreadyExists"));
Assert.That(errors[0].FieldName, Is.EqualTo("UserName"));
Assert.That(errors[1].ErrorCode, Is.EqualTo("AlreadyExists"));
Assert.That(errors[1].FieldName, Is.EqualTo("Email"));
mock.Verify();
}
