public async Task <IActionResult> Register([FromBody] RegisterAccountRequest model)
{
var appUser = new ApplicationUser()
{
Email = model.Login,
UserName = model.Login,
SecurityStamp = Guid.NewGuid().ToString()
};
var result = await userManager.CreateAsync(appUser, model.Password);
if (result.Succeeded)
{
var user = new User
{
Login = model.Login,
Password = model.Password
};
forumContext.Add(user);
forumContext.SaveChanges();
return(Ok());
}
else
{
return(BadRequest());
}
}
public async Task ShouldBeHttpStatusCodeBadRequest()
{
const string email = "*****@*****.**";
var user = TestData.FileStorage.GetUsers().First();
var factory = TestHost;
_httpClient = factory.CreateClient();
var testServer = factory.Server;
testServer.CleanupDbContext();
await testServer.UsingScopeAsync(
async scope =>
{
var service = scope.GetRequiredService <IUserService>();
await service.CreateAsync(user);
});
var request = new RegisterAccountRequest
{
Country = EnumCountryIsoCode.CA,
Dob = "1990/01/01",
Email = email,
Ip = "127.0.0.1",
Password = "******",
};
// Act
using var response = await this.ExecuteAsync(request);
// Assert
response.StatusCode.Should().Be(HttpStatusCode.BadRequest);
}
public ActionResult <AuthenticateAccountResponse> Register([FromBody] RegisterAccountRequest request)
{
// Register the account
try
{
var response = _accountService.Register(request);
_logger.LogInformation("(AccountId: {accountId}, EmailAddress: {emailAddress}) registered successfully", response.AccountId, response.EmailAddress);
return(Ok(response));
}
catch (Exception e)
{
_logger.LogWarning(e, "Email address {emailAddress} registration failed!", request.EmailAddress);
// Default status code
int httpStatusCode = (int)HttpStatusCode.InternalServerError;
if (e is AccountAlreadyExistsException)
{
// Status code if account already exists
httpStatusCode = (int)HttpStatusCode.Conflict;
}
return(StatusCode(httpStatusCode, e.GetType().Name));
}
}
public async Task CreateAccount(RegisterAccountRequest registerAccountRequest)
{
var resource = "/v1/account";
var request = new HttpRequestMessage(HttpMethod.Post, resource);
await Execute(request, registerAccountRequest);
}
public async Task <IActionResult> RegisterAccountAsync([FromBody] RegisterAccountRequest request)
{
var result = await _userService.CreateAsync(
new User
{
Id = new UserId(),
Email = request.Email,
Country = request.Country.ToEnumeration <Country>(),
Dob = new UserDob(DateTime.Parse(request.Dob))
},
request.Password);
if (result.Succeeded)
{
var user = await _userService.FindByEmailAsync(request.Email);
await _serviceBusPublisher.PublishUserCreatedIntegrationEventAsync(user, request.Ip);
var code = await _userService.GenerateEmailConfirmationTokenAsync(user);
await _serviceBusPublisher.PublishUserEmailConfirmationTokenGeneratedIntegrationEventAsync(user.Id.ConvertTo <UserId>(), code);
return(this.Ok());
}
ModelState.Bind(result); // FRANCIS: VALIDATION SHOULD BE MORE GENERAL FOR REGISTRATION
return(this.BadRequest(new ValidationProblemDetails(ModelState)));
}
public async Task <IHttpActionResult> Register([FromBody] RegisterAccountRequest model)
{
if (model == null)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (await _userManager.FindByNameAsync(model.Email) != null)
{
return(BadRequest("User with such email already exists"));
}
var createResult = await CreateUser(model);
IdentityResult result = createResult.Item1;
Guid userDomainId = createResult.Item2;
if (!result.Succeeded)
{
return(GetErrorResult(result));
}
var actionLink = Url.Link("GetUserAccountById", new { id = userDomainId });
return(Created(actionLink, new { Id = userDomainId }));
}
private async Task <Tuple <IdentityResult, Guid> > CreateUser(RegisterAccountRequest model)
{
var user = new ApplicationUser
{
DomainId = Guid.NewGuid(),
UserName = model.Email,
Email = model.Email,
IsActive = true,
Profile = new ApplicationUserProfile {
FirstName = model.FirstName, LastName = model.LastName
}
};
IdentityResult result = await _userManager.CreateAsync(user, model.Password);
if (!result.Succeeded)
{
return(new Tuple <IdentityResult, Guid>(result, Guid.Empty));
}
string role = GlobalInfo.Client;
await SendConfirmEmail(user);
await _userManager.AddToRoleAsync(user.Id, role);
return(new Tuple <IdentityResult, Guid>(IdentityResult.Success, user.DomainId));
}
private void Register(object sender, RoutedEventArgs e)
{
SaveLoginSettings();
LoginMessageText = string.Empty;
AwaitingLoginResponse = true;
Cursor = Cursors.Wait;
MainWindow main = App.Current.MainWindow as MainWindow;
Task.Run(() =>
{
main.Client.Connect(address, port, CONNECT_TIMEOUT);
if (!main.Client.IsConnected)
{
App.Current.Dispatcher.Invoke(() =>
{
main.Client.Dispose();
loginMessageText = SERVER_UNREACHABLE;
AwaitingLoginResponse = false;
if (!WorkInProgress)
{
Cursor = Cursors.Arrow;
}
});
return;
}
RegisterAccountRequest request = new RegisterAccountRequest(username, PasswordBox.Password, main.Client.Serializer);
JamPacket requestPacket = new JamPacket(Guid.Empty, Guid.Empty, RegisterAccountRequest.DATA_TYPE, request.GetBytes());
main.Client.Send(requestPacket);
});
}
public async Task <IActionResult> Register([FromBody] RegisterAccountRequest request)
{
if (request == null)
{
return(BadRequest());
}
var user = new ApplicationUser
{
UserName = request.EMail,
Email = request.EMail
};
var result = await userManager.CreateAsync(user, request.Password);
if (result.Succeeded)
{
// Generate Confirmation Token for the User:
var confirmationCode = await userManager.GenerateEmailConfirmationTokenAsync(user);
// Generate the Callback URL for the Confirmation:
var confirmationUrl = Url.EmailConfirmationLink(user.Id, confirmationCode, Request.Scheme);
// Send the Mail:
await emailConfirmationService.SendEmailConfirmationAsync(user, confirmationUrl);
return(Ok());
}
return(BadRequest());
}
private static void RegisterAccount(JamServerConnection serverConnection, JamPacket packet)
{
RegisterAccountRequest register = new RegisterAccountRequest(packet.Data, serverConnection.Serializer);
RegisterAccountResponse response;
try
{
Account createdAccount = AccountFactory.Generate(register.Username, register.Password, Program.Server.HashFactory, true);
response = new RegisterAccountResponse(RegisterAccountResponse.AccountRegistrationResult.Good, createdAccount, serverConnection.Serializer);
Console.WriteLine("Registered new Account: {0} - {1}", createdAccount.AccountID, createdAccount.Username);
}
catch (DbUpdateException)
{
response = new RegisterAccountResponse(RegisterAccountResponse.AccountRegistrationResult.Bad, null, serverConnection.Serializer);
}
catch (EntityException)
{
serverConnection.Server.Dispose();
return;
}
JamPacket responsePacket = new JamPacket(Guid.Empty, Guid.Empty, RegisterAccountResponse.DATA_TYPE, response.GetBytes());
serverConnection.Send(responsePacket);
}
private void RegisterDialogOnResponse(object?sender, DialogResponseEventArgs e)
{
var registerAccountRequest = new RegisterAccountRequest();
registerAccountRequest.Email = "*****@*****.**";
registerAccountRequest.Login = _player.Name;
registerAccountRequest.Password = e.InputText;
try
{
var response = MruV.Accounts.RegisterAccount(registerAccountRequest);
if (response.Success)
{
new LoginFlow(_player).Show();
Tutorial tutorial = new Tutorial(_player);
tutorial.RegisterMessage();
}
else
{
_player.SendClientMessage("Nie udało się zarejestrować konta.");
_registerDialog.Show(_player);
}
}
catch (RpcException err)
{
_player.SendClientMessage($"Nie udało się zarejestrować, błąd: {err.Status.Detail}");
}
}
public async Task <IActionResult> Register([FromBody] RegisterAccountRequest registerAccount)
{
var user = new Employee
{
UserName = registerAccount.Email,
Email = registerAccount.Email,
FirstName = registerAccount.FirstName,
LastName = registerAccount.LastName,
};
if (registerAccount.ProfilePhoto != null)
{
user.ProfilePhoto = registerAccount.ProfilePhoto;
}
if (registerAccount.RegisteredOfficeId != 0)
{
user.RegisteredOffice = await _officeRepository.FindById(registerAccount.RegisteredOfficeId);
}
var result = await _userManager.CreateAsync(user, registerAccount.Password);
if (!result.Succeeded)
{
return(Conflict());
}
return(Ok(DateTime.Now));
}
/// <summary>
/// sends a registration request to the server
/// </summary>
/// <param name="userName"></param>
/// <param name="newPassword"></param>
/// <param name="newPasswordRe"></param>
/// <returns></returns>
public async Task <bool> RegisterUser(string userName, string newPassword, string newPasswordRe)
{
try
{
IsLoading = true;
if (newPassword != newPasswordRe)
{
throw new Exception("A két jelszó értéke nem egyezik meg!");
}
var registerAccountRequest = new RegisterAccountRequest
{
EmployeeId = Parameter,
Password = newPassword,
Username = userName
};
await _accountApiService.RegisterAccount(registerAccountRequest);
return(true);
}
catch (Exception e)
{
_dialogService.ShowWarning(e.Message);
return(false);
}
finally
{
IsLoading = false;
}
}
public AuthenticateAccountResponse Register(RegisterAccountRequest request)
{
if (_context.Accounts.Any(x => x.EmailAddress == request.EmailAddress))
{
// There is already an account with given email address
throw new AccountAlreadyExistsException();
}
// Create new account object from the request model
var account = new Account()
{
UserFullName = request.UserFullName,
EmailAddress = request.EmailAddress,
PasswordHash = BC.HashPassword(request.Password)
};
// Save account
_context.Accounts.Add(account);
_context.SaveChanges();
// Create a response that includes the access token
var response = new AuthenticateAccountResponse
{
AccountId = account.AccountId,
UserFullName = account.UserFullName,
EmailAddress = account.EmailAddress,
AccessToken = GenerateJsonWebToken(account)
};
return(response);
}
/// <summary>
/// registers a new account
/// </summary>
/// <param name="registerAccountRequest"></param>
/// <returns></returns>
public async Task RegisterAccount(RegisterAccountRequest registerAccountRequest)
{
_loggingService.LogDebug(new
{
action = nameof(registerAccountRequest)
});
await _apiService.PostAsync("Account/RegisterAccount", registerAccountRequest);
}
public async Task <IdentityResult> RegisterUser(RegisterAccountRequest registerAccountRequest)
{
IdentityUser account = new IdentityUser
{
UserName = registerAccountRequest.UserName,
Email = registerAccountRequest.UserName
};
return(await _userManager.CreateAsync(account, registerAccountRequest.Password));
}
public async Task <IActionResult> Post([FromBody] RegisterAccountRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.Values.SelectMany(m => m.Errors)));
}
var user = mapper.Map <AppUser>(request);
var createActionResult = await userManager.CreateAsync(user, request.Password);
return(createActionResult.Succeeded ? Ok("User created") : Ok(createActionResult.Errors.ToList()));
}
public Task <AlpApiResponse> RegisterAccount([FromBody] RegisterAccountRequest registerAccountRequest)
{
var sessionToken = HttpContext.Request.Headers["sessiontoken"];
if (!_accountService.Authorize(sessionToken, new List <RoleType> {
RoleType.Admin
}))
{
return(Task.FromResult(new AlpApiResponse {
Success = false, Message = "Nincs jogosultsága ehhez a művelethez!"
}));
}
return(_accountService.RegisterAccount(registerAccountRequest));
}
private async Task <Tuple <IdentityResult, Guid> > CreateUser(RegisterAccountRequest model)
{
InviteInfo invite = null;
if (model.InviteCode != null)
{
invite = _invitesService.FindInviteByToken(model.InviteCode.Value);
if (invite == null || !invite.Email.Equals(model.Email, StringComparison.OrdinalIgnoreCase))
{
return(new Tuple <IdentityResult, Guid>(IdentityResult.Failed("Bad invite"), Guid.Empty));
}
}
var user = new ApplicationUser
{
DomainId = Guid.NewGuid(),
UserName = model.Email,
Email = model.Email,
IsActive = true,
Profile = new ApplicationUserProfile {
FirstName = model.FirstName, LastName = model.LastName
}
};
IdentityResult result = await _userManager.CreateAsync(user, model.Password);
if (!result.Succeeded)
{
return(new Tuple <IdentityResult, Guid>(result, Guid.Empty));
}
string role = GlobalInfo.Candidate;
if (invite != null)
{
role = invite.RoleName;
user.EmailConfirmed = true;
await _invitesService.UseInviteAsync(model.InviteCode.Value, user.Id);
}
else
{
await SendConfirmEmailAsync(user);
}
await _userManager.AddToRoleAsync(user.Id, role);
return(new Tuple <IdentityResult, Guid>(IdentityResult.Success, user.DomainId));
}
public async Task <User> RegisterAccount(RegisterAccountRequest request)
{
var chk = await _unitOfWork.GetRepository <User>().FindAsync(x => x.Username == request.Username || x.Email == request.Email);
if (chk == null)
{
var user = new User();
user = _mapper.Map <User>(request);
_unitOfWork.GetRepository <User>().Add(user);
await _unitOfWork.CommitAsync();
return(user);
}
return(null);
}
public async Task WhenRegisterReturnsFailedReturnsError()
{
var request = new RegisterAccountRequest
{
Email = "*****@*****.**"
};
UserServiceMock
.Setup(us => us.RegisterUserAsync(It.IsAny <RegisterAccountRequest>(), It.IsAny <string>()))
.ReturnsAsync(RegisterAccountResult.Failed("Test Error"));
var result = await Controller.RegisterAccount(request);
var errorValue = TestUtils.GetValueFromResultObject <BadRequestObjectResult, SerializableError>(result);
CollectionAssert.Contains(errorValue.Keys, string.Empty);
}
public async Task <IHttpActionResult> Register(RegisterAccountRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var result = await _memberManager.RegisterAndSignInAsync(Mapper.Map <Registration>(request));
if (result.HasErrors)
{
ModelState.AddErrors(result);
return(BadRequest(ModelState));
}
return(Ok());
}
public async Task <IHttpActionResult> Register(RegisterAccountRequest userModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
IdentityResult result = await _authRepository.RegisterUser(userModel);
IHttpActionResult errorResult = GetErrorResult(result);
if (errorResult != null)
{
return(errorResult);
}
return(Ok(result));
}
public async Task WhenRegisterSucceedsReturnsSuccess()
{
var request = new RegisterAccountRequest
{
Email = "*****@*****.**"
};
UserServiceMock
.Setup(us => us.RegisterUserAsync(It.IsAny <RegisterAccountRequest>(), It.IsAny <string>()))
.ReturnsAsync(RegisterAccountResult.Succeeded(new GametekiUser {
Settings = new UserSettings()
}));
var result = await Controller.RegisterAccount(request);
var response = TestUtils.GetResponseFromResult <ApiResponse>(result);
Assert.IsTrue(response.Success);
}
public async Task <IActionResult> Register(RegisterAccountRequest registerAccountRequest)
{
if (!ModelState.IsValid)
{
return(View(registerAccountRequest));
}
var user = await _userManager.FindByNameAsync(registerAccountRequest.UserName);
if (user != null)
{
return(View());
}
IdentityUser newuser = new IdentityUser(registerAccountRequest.UserName);
var result = await _userManager.CreateAsync(newuser, registerAccountRequest.Password);
if (!result.Succeeded)
{
return(View());
}
return(View());
}
public RegisterRequestResponse RegisterUser(RegisterAccountRequest request)
{
if (request == null)
{
return new RegisterRequestResponse {
ResponseCode = 422, ResponseMessage = "Null Request"
}
}
;
if (_authRepository.UserAlreadyExists(request.Email) == false)
{
_authRepository.RegisterAccount(request);
return(new RegisterRequestResponse {
ResponseCode = 200, ResponseMessage = "Ok"
});
}
return(new RegisterRequestResponse {
ResponseCode = 500, ResponseMessage = "Internal Server Error"
});
}
}
public void RegisterAccount(RegisterAccountRequest request)
{
if (request == null)
{
return;
}
var accountToAdd = new AppAccount();
accountToAdd.Email = request.Email;
accountToAdd.Password = request.Password;
_appDbContext.T_IBS_App_Accounts.Add(accountToAdd);
_appDbContext.SaveChanges();
var customerToAdd = new Customer();
customerToAdd.First_Name = request.FirstName;
customerToAdd.Last_Name = request.LastName;
customerToAdd.CNP = request.Cnp;
customerToAdd.Age = request.Age;
_appDbContext.T_IBS_CUSTOMERS.Add(customerToAdd);
_appDbContext.SaveChanges();
var justAddedCustomer = from o in _appDbContext.T_IBS_CUSTOMERS
select o.Id_Customer;
var justAddedAcc = from o in _appDbContext.T_IBS_App_Accounts
select o.Id_App_Account;
var jointAccount = new JoinCustomerAppAccounts();
jointAccount.Id_Customer = justAddedCustomer.ToList().Max();
jointAccount.Id_App_Account = justAddedAcc.ToList().Max();
_appDbContext.T_IBS_Join_Customers_App_Accounts.Add(jointAccount);
_appDbContext.SaveChanges();
}
public async Task ShouldBeHttpStatusCodeOK()
{
var factory = TestHost;
_httpClient = factory.CreateClient();
var testServer = factory.Server;
testServer.CleanupDbContext();
const string email = "*****@*****.**";
var request = new RegisterAccountRequest
{
Email = email,
Password = "******",
Dob = "01/01/1990",
Country = EnumCountryIsoCode.CA,
Ip = "127.0.0.1"
};
// Act
using var response = await this.ExecuteAsync(request);
// Assert
response.StatusCode.Should().Be(HttpStatusCode.OK);
await testServer.UsingScopeAsync(
async scope =>
{
var service = scope.GetRequiredService <IUserService>();
var user = await service.FindByEmailAsync(email);
user.Should().NotBeNull();
});
}
public async Task WhenActivationEnabledSendVerificationEmail()
{
var request = new RegisterAccountRequest
{
Email = "*****@*****.**"
};
ApiOptions.Value.AccountVerification = true;
UserServiceMock
.Setup(us => us.RegisterUserAsync(It.IsAny <RegisterAccountRequest>(), It.IsAny <string>()))
.ReturnsAsync(RegisterAccountResult.Succeeded(new GametekiUser {
Settings = new UserSettings()
}));
var result = await Controller.RegisterAccount(request);
var response = TestUtils.GetResponseFromResult <ApiResponse>(result);
Assert.IsTrue(response.Success);
UserServiceMock.Verify(
us => us.SendActivationEmailAsync(It.IsAny <GametekiUser>(), It.IsAny <AccountVerificationModel>()),
Times.Once);
}
public async Task <IActionResult> Register([FromBody] RegisterAccountRequest registerAccount)
{
var invite = await _inviteControllerService.GetInvite(registerAccount.InviteId);
// username = email without special symbols
Employee user = new Employee
{
UserName = registerAccount.Email.Replace("@", "").Replace(".", "").Replace("-", ""),
Email = registerAccount.Email,
FirstName = registerAccount.FirstName,
LastName = registerAccount.LastName,
BossId = invite.EmployeeId
};
try
{
var result = await _userManager.CreateAsync(user, registerAccount.Password);
if (!result.Succeeded)
{
Console.WriteLine("User -> " + registerAccount.Email + " registration failed.");
//Log.Information("Registering user was unsuccessfull");
return(Conflict(result.Errors));
}
await _inviteControllerService.DeleteInvite(registerAccount.InviteId);
Console.WriteLine("User -> " + registerAccount.Email + " registered successfully!");
//Log.Information("Registration succeeded");
return(Ok(result.Succeeded));
}
catch (Exception exception)
{
//Log.Error(exception, "Failed to register user");
return(StatusCode((int)HttpStatusCode.InternalServerError, "Failed to register user. Message: " + exception.Message));
}
}
