public void CanGetUserRolesOnNewAccount()
{
String username = "******";
String password = "******";
AccountRegistrationRequest request = new AccountRegistrationRequest()
{
Email = "*****@*****.**",
Password = password,
Username = username,
};
AccountRegistrationResponse response = client.RegisterAccount(request);
Assert.IsTrue(response.Token != null);
Assert.IsTrue(response.User.Id != null);
Assert.AreEqual(response.User.Username, username);
GetRolesResponse roleResponse = client.GetRoles(new GetRolesRequest()
{
});
Assert.IsTrue(roleResponse.Status.IsSuccess);
Assert.IsTrue(roleResponse.Claims.Contains(UserClaim.User));
Assert.IsFalse(roleResponse.Claims.Contains(UserClaim.Admin));
}
public async Task <AccountRegistrationResponse> RegistrationAsync(AccountRegistrationRequest request)
{
if (request.Account.Email == null)
{
throw AbortBadRequest("missing email address");
}
if (request.Account.Username.Length < 2)
{
throw AbortBadRequest("username too short");
}
try {
var document = Document.FromJson(SerializeJson(new AccountRecord {
PK = request.Account.Username.ToLowerInvariant(),
Password = HashText(request.Account.Password),
Email = request.Account.Email,
Name = request.User?.Name,
ProfileImage = request.User?.ProfileImage,
Salt = Guid.NewGuid().ToString("N").ToUpperInvariant()
}));
await _table.PutItemAsync(document, new PutItemOperationConfig {
ConditionalExpression = new Expression {
ExpressionStatement = "attribute_not_exists(PK)"
}
});
return(new AccountRegistrationResponse {
});
} catch (ConditionalCheckFailedException) {
throw AbortBadRequest("account is already registered");
}
}
public async Task <AccountRegistrationResponse> RegisterUserAsync(AccountRegistrationRequest request)
{
var existsUser = await GetUserByPhoneAsync(request.Phone);
if (existsUser?.CreateUserPlace == CreateUserPlace.FromRegistration)
{
return(new AccountRegistrationResponse()
{
Code = ResponseCode.UserWithTheSamePhoneExists
});
}
var user = _userEntityFactory.Create(
request.Name,
request.LastName,
request.Phone,
request.Password,
CreateUserPlace.FromRegistration);
_userRepository.Add(user);
await _userRepository.SaveChangesAsync();
return(new AccountRegistrationResponse()
{
User = _mapper.Map <UserModel>(user)
});
}
public void PlayerCannotRegisterWithTheSameUsername()
{
String username = "******";
String password = "******";
AccountRegistrationRequest request = new AccountRegistrationRequest()
{
Email = "*****@*****.**",
Password = password,
Username = username,
};
AccountRegistrationResponse response = client.RegisterAccount(request);
String userId = response.User.Id;
Assert.IsTrue(response.Token != null);
Assert.IsTrue(response.User.Id != null);
Assert.IsTrue(response.User.Username == username);
request.Email = "*****@*****.**";
var exception = client.RegisterAccount(request);
Assert.AreEqual(exception.Status.IsSuccess, false);
Assert.That(exception.Status.Detail, Is.EqualTo(ResponseType.DUPLICATE.ToString()));
}
public override AccountRegistrationResponse RegisterAccount(AccountRegistrationRequest request, CallOptions options)
{
AccountRegistrationResponse response = base.RegisterAccount(request, options);
Auth.Login(response.Token);
return(response);
}
public override async Task <AccountRegistrationResponse> RegisterAccount(AccountRegistrationRequest request,
ServerCallContext context)
{
DbUserModel dbUserModel = await DbUserModel.GetUserFromUsername(request.Username);
if (dbUserModel != null)
{
return new AccountRegistrationResponse()
{
Status = ResponseFactory.createResponse(ResponseType.DUPLICATE)
}
}
;
// Create a new user model
DbUserModel model = new DbUserModel(request);
await model.SaveToDatabase();
string token = JwtManager.GenerateToken(model.UserModel.Id);
context.ResponseTrailers.Add("Authorization", token);
return(new AccountRegistrationResponse
{
Token = token,
User = model.AsUser(),
Status = ResponseFactory.createResponse(ResponseType.SUCCESS),
});
}
public override AccountRegistrationResponse RegisterAccount(AccountRegistrationRequest request, Metadata headers = null,
DateTime?deadline = null, CancellationToken cancellationToken = default(CancellationToken))
{
AccountRegistrationResponse response = base.RegisterAccount(request, headers, deadline, cancellationToken);
Auth.Login(response.Token);
return(response);
}
/// <summary>
/// Đăng ký, tạo mới tài khoản
/// </summary>
/// <param name="request"></param>
/// <returns>Thông tin tài khoản</returns>
public async Task <Response <AuthenticationResult> > RegisterAsync(AccountRegistrationRequest request)
{
if (request.Role.Count == 0)
{
request.Role.Add(Constant.ROLE_USER);
}
if (String.IsNullOrEmpty(request.Password))
{
_logger.LogError(Constant.PASS_NULL);
return(new Response <AuthenticationResult>(Constant.STATUS_ERROR, new List <string> {
Constant.PASS_NULL
}));
}
var existingUser = await _userManager.FindByEmailAsync(request.Email);
if (existingUser != null)
{
_logger.LogError(Constant.USER_EXIST);
return(new Response <AuthenticationResult>
{
Data = null,
Message = new List <string> {
Constant.USER_EXIST
},
Status = Constant.STATUS_ERROR,
TotalData = 0
});
}
var newUser = new AppUser
{
Email = request.Email,
UserName = request.FirstName + request.LastName,
FirstName = request.FirstName,
LastName = request.LastName,
Age = request.Age,
Address = request.Address,
Id = Guid.NewGuid()
};
var createdUser = await _userManager.CreateAsync(newUser, request.Password);
if (!createdUser.Succeeded)
{
_logger.LogError("Create User Failed");
return(new Response <AuthenticationResult>(Constant.STATUS_ERROR, createdUser.Errors.Select(x => x.Description)));
}
await _userManager.AddToRolesAsync(newUser, request.Role);
var dataResponse = await GenerateAuthenticationResultForUserAsync(newUser);
_logger.LogInformation("Create account success");
return(new Response <AuthenticationResult>(Constant.STATUS_SUCESS, null, dataResponse, 1));
}
public async Task <AccountRegistrationResponse> Register(AccountRegistrationRequest request)
{
var inputPassword = request.Password;
request.Password = _hashService.HashPassword(request.Password);
var result = await _userService.RegisterUserAsync(request);
await Login(new AccountLoginRequest()
{
Phone = request.Phone,
Password = inputPassword
});
return(result);
}
public async Task Register(Account account, User user)
{
var requestBody = new AccountRegistrationRequest
{
Account = account,
User = user
};
var json = JsonConvert.SerializeObject(requestBody);
var requestMessage = new HttpRequestMessage(HttpMethod.Post, "/registration")
{
Content = new StringContent(json, Encoding.UTF8, "application/json")
};
using (await Client.SendMessage(requestMessage)) { }
}
public ActionResult Register(RegisterModel model, string returnUrl, FormCollection form)
{
if (_workContext.CurrentAccount == null || _workContext.CurrentAccount.IsRegistered())
{
//Already registered customer.
_authenticationService.SignOut();
//Save a new record
// _workContext.CurrentAccount = _accountService.InsertGuestAccount();
}
var account = new Account()
{
Birthdate = model.Birthdate,
Contact = model.Contact,
Country = model.Country,
Email = model.Email,
Deleted = false,
Gender = model.Gender,
Language = model.Language,
CreatedOnUtc = DateTime.Now,
LastActivityDateUtc = DateTime.Now,
AccountGuid = Guid.NewGuid()
};
if (ModelState.IsValid)
{
var registrationRequest = new AccountRegistrationRequest(account, model.Email, model.Password, PasswordFormat.Hashed);
// _accountService.InsertGuestAccount
var registrationResult = _accountRegistrationService.RegisterAccount(registrationRequest);
if (registrationResult.Success)
{
_accountService.CreateAccount(account);
_authenticationService.SignIn(account, true);
return(RedirectToRoute("HomePage"));
}
else
{
foreach (var error in registrationResult.Errors)
{
ModelState.AddModelError("", error);
}
}
}
return(View(model));
}
private void CreateDefaultAdmin(string defaultUserEmail, string defaultUserPassword)
{
var admin = new Account()
{
AccountGuid = Guid.NewGuid(),
Active = true,
CreatedOnUtc = DateTime.UtcNow,
LastActivityDateUtc = DateTime.UtcNow,
};
var arAdmin = _accountService.GetAccountRoleBySystemName(SystemAccountRoleNames.Administrators);
admin.AccountRoles.Add(arAdmin);
_accountService.InsertAccount(admin);
var registrarRequest = new AccountRegistrationRequest(admin, defaultUserEmail, defaultUserEmail, defaultUserPassword, PasswordFormat.Hashed);
var registrarResult = _accountRegistrationService.RegisterAccount(registrarRequest);
}
public void UserCanRegisterNewAccount()
{
String username = "******";
String password = "******";
AccountRegistrationRequest request = new AccountRegistrationRequest()
{
Email = "*****@*****.**",
Password = password,
Username = username,
};
AccountRegistrationResponse response = client.RegisterAccount(request);
Assert.IsTrue(response.Token != null);
Assert.IsTrue(response.User.Id != null);
Assert.AreEqual(response.User.Username, username);
}
public String createAccount(String username)
{
String pass = RandomString(13);
AccountRegistrationRequest request = new AccountRegistrationRequest()
{
Email = "*****@*****.**",
Password = pass,
Username = username,
DeviceIdentifier = Guid.NewGuid().ToString(),
};
AccountRegistrationResponse response = client.RegisterAccount(request);
userIds.Add(username, response.User.Id);
accounts.Add(username, pass);
return(response.User.Id);
}
public void UserIsLoggedInAfterRegistering()
{
String username = "******";
String password = "******";
AccountRegistrationRequest request = new AccountRegistrationRequest()
{
Email = "*****@*****.**",
Password = password,
Username = username,
};
AccountRegistrationResponse response = client.RegisterAccount(request);
Assert.IsTrue(response.Token != null);
Assert.IsTrue(response.User.Id != null);
Assert.AreEqual(response.User.Username, username);
AuthorizedHealthCheckResponse AuthResponse = client.AuthorizedHealthCheck(new AuthorizedHealthCheckRequest());
Assert.IsTrue(AuthResponse != null);
}
public DbUserModel(AccountRegistrationRequest registration)
{
string deviceIdentifier;
if (string.IsNullOrEmpty(registration.DeviceIdentifier))
{
deviceIdentifier = registration.Email;
}
else
{
deviceIdentifier = registration.DeviceIdentifier;
}
UserModel = new UserModel()
{
Id = Guid.NewGuid().ToString(),
Username = registration.Username,
Email = registration.Email,
EmailVerified = false,
PasswordHash = JwtManager.HashPassword(registration.Password),
Claims = { UserClaim.User },
DeviceIdentifier = deviceIdentifier
};
}
public virtual AuthorizationResult Authorize(OpenAuthenticationParameters parameters)
{
var userFound = _openAuthenticationService.GetUser(parameters);
var userLoggedIn = _currentActivity.CurrentAccount.IsRegistered() ? _currentActivity.CurrentAccount : null;
if (AccountAlreadyExists(userFound, userLoggedIn))
{
if (AccountIsAssignedToLoggedOnAccount(userFound, userLoggedIn))
{
// The person is trying to log in as himself.. bit weird
return new AuthorizationResult(OpenAuthenticationStatus.Authenticated);
}
var result = new AuthorizationResult(OpenAuthenticationStatus.Error);
result.AddError("Account is already assigned");
return result;
}
if (AccountDoesNotExistAndUserIsNotLoggedOn(userFound, userLoggedIn))
{
ExternalAuthorizerHelper.StoreParametersForRoundTrip(parameters);
if (AutoRegistrationIsEnabled())
{
#region Register user
var currentAccount = _currentActivity.CurrentAccount;
var details = new RegistrationDetails(parameters);
var randomPassword = CommonHelper.GenerateRandomDigitCode(20);
bool isApproved = _accountSettings.UserRegistrationType == UserRegistrationType.Standard;
var registrationRequest = new AccountRegistrationRequest(currentAccount, details.EmailAddress,
_accountSettings.UsernamesEnabled ? details.UserName : details.EmailAddress, randomPassword, PasswordFormat.Clear, isApproved);
var registrationResult = _accountRegistrationService.RegisterAccount(registrationRequest);
if (registrationResult.Success)
{
//store other parameters (form fields)
if (!String.IsNullOrEmpty(details.FirstName))
_genericAttributeService.SaveAttribute(currentAccount, SystemAttributeNames.FirstName, details.FirstName);
if (!String.IsNullOrEmpty(details.LastName))
_genericAttributeService.SaveAttribute(currentAccount, SystemAttributeNames.LastName, details.LastName);
userFound = currentAccount;
_openAuthenticationService.AssociateExternalAccountWithUser(currentAccount, parameters);
ExternalAuthorizerHelper.RemoveParameters();
//code below is copied from AccountController.Register method
//authenticate
if (isApproved)
_authenticationService.SignIn(userFound ?? userLoggedIn, false);
//notifications
if (_accountSettings.NotifyNewRegistration)
_workflowMessageService.SendAccountRegisteredNotificationMessage(currentAccount, _localizationSettings.DefaultAdminLanguageId);
switch (_accountSettings.UserRegistrationType)
{
case UserRegistrationType.EmailValidation:
{
//email validation message
_genericAttributeService.SaveAttribute(currentAccount, SystemAttributeNames.AccountActivationToken, Guid.NewGuid().ToString());
_workflowMessageService.SendAccountEmailValidationMessage(currentAccount, _currentActivity.CurrentLanguage.Id);
//result
return new AuthorizationResult(OpenAuthenticationStatus.AutoRegisteredEmailValidation);
}
case UserRegistrationType.AdminApproval:
{
//result
return new AuthorizationResult(OpenAuthenticationStatus.AutoRegisteredAdminApproval);
}
case UserRegistrationType.Standard:
{
//send account welcome message
_workflowMessageService.SendAccountWelcomeMessage(currentAccount, _currentActivity.CurrentLanguage.Id);
//result
return new AuthorizationResult(OpenAuthenticationStatus.AutoRegisteredStandard);
}
default:
break;
}
}
else
{
ExternalAuthorizerHelper.RemoveParameters();
var result = new AuthorizationResult(OpenAuthenticationStatus.Error);
foreach (var error in registrationResult.Errors)
result.AddError(string.Format(error));
return result;
}
#endregion
}
else if (RegistrationIsEnabled())
{
return new AuthorizationResult(OpenAuthenticationStatus.AssociateOnLogon);
}
else
{
ExternalAuthorizerHelper.RemoveParameters();
var result = new AuthorizationResult(OpenAuthenticationStatus.Error);
result.AddError("Registration is disabled");
return result;
}
}
if (userFound == null)
{
_openAuthenticationService.AssociateExternalAccountWithUser(userLoggedIn, parameters);
}
//authenticate
_authenticationService.SignIn(userFound ?? userLoggedIn, false);
return new AuthorizationResult(OpenAuthenticationStatus.Authenticated);
}
/// <summary>
/// Register account
/// </summary>
/// <param name="request">Request</param>
/// <returns>Result</returns>
public virtual AccountRegistrationResult RegisterAccount(AccountRegistrationRequest request)
{
if (request == null)
throw new ArgumentNullException("request");
if (request.Account == null)
throw new ArgumentException("Can't load current account");
var result = new AccountRegistrationResult();
if (request.Account.IsSearchEngineAccount())
{
result.AddError("Search engine can't be registered");
return result;
}
if (request.Account.IsRegistered())
{
result.AddError("Current account is already registered");
return result;
}
if (String.IsNullOrEmpty(request.Email))
{
result.AddError(_localizationService.GetResource("Account.Register.Errors.EmailIsNotProvided"));
return result;
}
if (!CommonHelper.IsValidEmail(request.Email))
{
result.AddError(_localizationService.GetResource("Common.WrongEmail"));
return result;
}
if (String.IsNullOrWhiteSpace(request.Password))
{
result.AddError(_localizationService.GetResource("Account.Register.Errors.PasswordIsNotProvided"));
return result;
}
if (_accountSettings.UsernamesEnabled)
{
if (String.IsNullOrEmpty(request.Username))
{
result.AddError(_localizationService.GetResource("Account.Register.Errors.UsernameIsNotProvided"));
return result;
}
}
//validate unique user
if (_accountService.GetAccountByEmail(request.Email) != null)
{
result.AddError(_localizationService.GetResource("Account.Register.Errors.EmailAlreadyExists"));
return result;
}
if (_accountSettings.UsernamesEnabled)
{
if (_accountService.GetAccountByUsername(request.Username) != null)
{
result.AddError(_localizationService.GetResource("Account.Register.Errors.UsernameAlreadyExists"));
return result;
}
}
//at this point request is valid
request.Account.Username = request.Username;
request.Account.Email = request.Email;
request.Account.PasswordFormat = request.PasswordFormat;
switch (request.PasswordFormat)
{
case PasswordFormat.Clear:
{
request.Account.Password = request.Password;
}
break;
case PasswordFormat.Encrypted:
{
request.Account.Password = _encryptionService.EncryptText(request.Password);
}
break;
case PasswordFormat.Hashed:
{
string saltKey = _encryptionService.CreateSaltKey(5);
request.Account.PasswordSalt = saltKey;
request.Account.Password = _encryptionService.CreatePasswordHash(request.Password, saltKey, _accountSettings.HashedPasswordFormat);
}
break;
default:
break;
}
request.Account.Active = request.IsApproved;
//add to 'Registered' role
var registeredRole = _accountService.GetAccountRoleBySystemName(SystemAccountRoleNames.Registered);
if (registeredRole == null)
throw new AaronException("'Registered' role could not be loaded");
request.Account.AccountRoles.Add(registeredRole);
//remove from 'Guests' role
var guestRole = request.Account.AccountRoles.FirstOrDefault(cr => cr.SystemName == SystemAccountRoleNames.Guests);
if (guestRole != null)
request.Account.AccountRoles.Remove(guestRole);
_accountService.UpdateAccount(request.Account);
return result;
}
public override AsyncUnaryCall <AccountRegistrationResponse> RegisterAccountAsync(AccountRegistrationRequest request, Metadata headers = null,
DateTime?deadline = null, CancellationToken cancellationToken = default(CancellationToken))
{
AsyncUnaryCall <AccountRegistrationResponse> response = base.RegisterAccountAsync(request, headers, deadline, cancellationToken);
response.ResponseAsync.ContinueWith((authResponse) => { Auth.Login(authResponse.Result.Token); });
return(response);
}
public override AsyncUnaryCall <AccountRegistrationResponse> RegisterAccountAsync(AccountRegistrationRequest request, CallOptions options)
{
AsyncUnaryCall <AccountRegistrationResponse> response = base.RegisterAccountAsync(request, options);
response.ResponseAsync.ContinueWith((authResponse) => { Auth.Login(authResponse.Result.Token); });
return(response);
}
public async Task <HttpOperationResponse <object> > PostRegisterWithHttpMessagesAsync(AccountRegistrationRequest registrationRequest, Dictionary <string, List <string> > customHeaders = null, CancellationToken cancellationToken = default(CancellationToken))
{
if (registrationRequest == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "registrationRequest");
}
// Tracing
bool _shouldTrace = ServiceClientTracing.IsEnabled;
string _invocationId = null;
if (_shouldTrace)
{
_invocationId = ServiceClientTracing.NextInvocationId.ToString();
Dictionary <string, object> tracingParameters = new Dictionary <string, object>();
tracingParameters.Add("registrationRequest", registrationRequest);
tracingParameters.Add("cancellationToken", cancellationToken);
ServiceClientTracing.Enter(_invocationId, this, "PostRegister", tracingParameters);
}
// Construct URL
var _baseUrl = Client.BaseUri.AbsoluteUri;
var _url = new System.Uri(new System.Uri(_baseUrl + (_baseUrl.EndsWith("/") ? "" : "/")), "api/account/register").ToString();
// Create HTTP transport objects
var _httpRequest = new HttpRequestMessage();
HttpResponseMessage _httpResponse = null;
_httpRequest.Method = new HttpMethod("POST");
_httpRequest.RequestUri = new System.Uri(_url);
// Set Headers
if (customHeaders != null)
{
foreach (var _header in customHeaders)
{
if (_httpRequest.Headers.Contains(_header.Key))
{
_httpRequest.Headers.Remove(_header.Key);
}
_httpRequest.Headers.TryAddWithoutValidation(_header.Key, _header.Value);
}
}
// Serialize Request
string _requestContent = null;
if (registrationRequest != null)
{
_requestContent = Microsoft.Rest.Serialization.SafeJsonConvert.SerializeObject(registrationRequest, Client.SerializationSettings);
_httpRequest.Content = new StringContent(_requestContent, System.Text.Encoding.UTF8);
_httpRequest.Content.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse("application/json; charset=utf-8");
}
// Send Request
if (_shouldTrace)
{
ServiceClientTracing.SendRequest(_invocationId, _httpRequest);
}
cancellationToken.ThrowIfCancellationRequested();
_httpResponse = await Client.HttpClient.SendAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
if (_shouldTrace)
{
ServiceClientTracing.ReceiveResponse(_invocationId, _httpResponse);
}
HttpStatusCode _statusCode = _httpResponse.StatusCode;
cancellationToken.ThrowIfCancellationRequested();
string _responseContent = null;
if ((int)_statusCode != 200)
{
var ex = new HttpOperationException(string.Format("Operation returned an invalid status code '{0}'", _statusCode));
if (_httpResponse.Content != null)
{
_responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
}
else
{
_responseContent = string.Empty;
}
ex.Request = new HttpRequestMessageWrapper(_httpRequest, _requestContent);
ex.Response = new HttpResponseMessageWrapper(_httpResponse, _responseContent);
if (_shouldTrace)
{
ServiceClientTracing.Error(_invocationId, ex);
}
_httpRequest.Dispose();
if (_httpResponse != null)
{
_httpResponse.Dispose();
}
throw ex;
}
// Create Result
var _result = new HttpOperationResponse <object>();
_result.Request = _httpRequest;
_result.Response = _httpResponse;
// Deserialize Response
if ((int)_statusCode == 200)
{
_responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
try
{
_result.Body = Microsoft.Rest.Serialization.SafeJsonConvert.DeserializeObject <object>(_responseContent, Client.DeserializationSettings);
}
catch (JsonException ex)
{
_httpRequest.Dispose();
if (_httpResponse != null)
{
_httpResponse.Dispose();
}
throw new SerializationException("Unable to deserialize the response.", _responseContent, ex);
}
}
if (_shouldTrace)
{
ServiceClientTracing.Exit(_invocationId, _result);
}
return(_result);
}
public static object PostRegister(this IAccount operations, AccountRegistrationRequest registrationRequest)
{
return(operations.PostRegisterAsync(registrationRequest).GetAwaiter().GetResult());
}
public static async Task <object> PostRegisterAsync(this IAccount operations, AccountRegistrationRequest registrationRequest, CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.PostRegisterWithHttpMessagesAsync(registrationRequest, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
public async Task <Response <AuthenticationResult> > Register([FromBody] AccountRegistrationRequest request)
{
return(await _accountService.RegisterAsync(request));
}
