public async Task<LoginDto> Register([FromBody] UserDto user)
{
var request = new RegisterUserRequest
{
User = user
};
return await _mediator.ExecuteAsync(request).ConfigureAwait(false);
}
public IActionResult Register([FromBody] RegisterUserRequest request)
{
try
{
_userOperationsHandler.RegisterNewUser(request);
return(Created("", null));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public async Task <ActionResult> Register(RegisterAction action, CancellationToken token)
{
var request = new RegisterUserRequest
{
EmailAddress = action.EmailAddress,
Password = action.Password
};
await this._requestContext.Send(request, token).ConfigureAwait(false);
await this._requestContext.CommitAsync(token);
return(this.Ok());
}
protected override async Task <Response <CreateResult> > HandleCore(RegisterUserRequest request)
{
var user = new Database.Collections.User(request.UserName, request.Email);
var result = await _userManager.CreateAsync(user, request.Password);
if (result.Succeeded)
{
_logger.LogInformation(3, "User created a new account with password.");
return(new Response <CreateResult>(CreateResult.Created));
}
return(new Response <CreateResult>(CreateResult.NotCreated));
}
public async Task <IActionResult> Register(RegisterUserRequest registerUserRequest)
{
var registrationResult = await _authenticationService.RegisterAsync(registerUserRequest.UsernameOrEmail, registerUserRequest.Password);
if (!registrationResult.Success)
{
return(BadRequest(new AuthenticationResult()
{
Errors = registrationResult.Errors
}));
}
return(Ok(registrationResult.CastTo <RegisterUserResponse>()));
}
public void RegisterUser(RegisterUserRequest req)
{
string userId = UserIdFactory.GetUserId();
db.User.Add(new User()
{
Id = userId,
LoginId = req.LoginId,
Name = req.Name,
MailAddress = req.MailAddress
});
db.SaveChanges();
}
public async Task <RegisterUserResponse> RegisterUser(RegisterUserRequest request)
{
//await ValidateToken();
var checkUserEmailRegistered = _userService.GetUserByEmail(request.Email);
if (checkUserEmailRegistered != null)
{
throw new Exception("Email de usuário já cadastrado");
}
return(new RegisterUserResponse()
{
User = _userService.RegisterUser(request.Email, request.Password, request.Name, request.PrimaryTelephone, request.SecundaryTelephone, request.Cpf, request.UserType, request.Cep, request.AverageTicketPoints, request.RegisterClientsPoints, request.SalesNumberPoints, request.AverageItensPerSalePoints, request.InviteAllyFlowersPoints, request.TemporadaId, request.MotherFlowerId, request.IsActive, request.Birthday)
});
}
private static async Task SeedUser(IIdentityServiceClient client, string userName, string password)
{
var request = new RegisterUserRequest
{
Email = userName,
Password = password,
};
var seedResponse = await client.RegisterUserAsync(request);
// Sanity check
seedResponse.UserId.Should().NotBeNullOrWhiteSpace();
seedResponse.Errors.Should().BeEmpty();
}
//[InlineData(null)]
//[InlineData("")]
public async Task SecurityServiceManager_RegisterUser_UserIsRegistered(String password)
{
TestScenario testScenario = TestScenario.RegisterUserSuccess;
SecurityServiceManager securityServiceManager = this.SetupSecurityServiceManager(testScenario);
RegisterUserRequest request = SecurityServiceManagerTestData.GetRegisterUserRequest;
request.Password = password;
RegisterUserResponse response = await securityServiceManager.RegisterUser(request, CancellationToken.None);
response.ShouldNotBeNull();
response.UserId.ShouldNotBe(Guid.Empty);
}
public IActionResult Register(string code, string state, string error, string error_description)
{
var req = new RegisterUserRequest()
{
AuthCode = code,
State = state,
Error = error,
ErrorDescription = error_description
};
var resp = ServiceRegistrar.Current.GetMediator().Send(req);
return(Ok());
}
public static async Task <string> CreateUserAndSignIn(this HttpClient client)
{
string email = DataGenerator.RandomEmail();
var url = new Uri("api/users/Register", UriKind.Relative);
StringContent content = new RegisterUserRequest {
Email = email
}.ToStringContent();
HttpResponseMessage response = await client.PostAsync(url, content);
UserLoginResponse userLoginResponse = await response.OnSuccessDeserialize <UserLoginResponse>();
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", userLoginResponse.Token);
return(email);
}
public IHttpActionResult SignUp(RegisterUserRequest request)
{
try
{
var root = Request.RequestUri.GetLeftPart(UriPartial.Authority);
var user = this.dataServiceAuth.RegisterUser(request);
var thread = new Thread(delegate() { user.SendVerificationEmail(root); });
thread.Start();
return(new HttpActionResult <GenericResponse <UserEntity> >(
HttpStatusCode.OK,
new GenericResponse <UserEntity>
{
Result = user
}
));
}
catch (GeneralException exception)
{
return(new HttpActionResult <GenericResponse <UserEntity> >(
HttpStatusCode.OK,
new GenericResponse <UserEntity>
{
Error = new Error
{
Code = exception.Code,
ResponseCode = HttpStatusCode.OK,
Message = exception.AllMessages()
}
}
));
}
catch (Exception exception)
{
return(new HttpActionResult <GenericResponse <UserEntity> >(
HttpStatusCode.InternalServerError,
new GenericResponse <UserEntity>
{
Error = new Error
{
Code = 10699,
ResponseCode = HttpStatusCode.InternalServerError,
Message = exception.AllMessages()
}
}
));
}
}
public void Add_Throws_User_Is_Already_Registered()
{
var registerUserRequest = new RegisterUserRequest {
Email = "*****@*****.**",
Password = "******"
};
var userService = AddUserRequestValidatorMock.Create();
userService.UserSecurityRepositoryMock.Setup(us => us.GetByEmail(registerUserRequest.Email)).Returns(UserSecurity.CreateBasic(Guid.Empty, string.Empty, string.Empty));
var exception = Assert.Throws <DenialException>(() => userService.DataValidate(registerUserRequest, ActionType.Add));
Assert.AreEqual(exception.Message, "UserIsAlreadyRegistered");
Assert.AreEqual(exception.StatusCode, HttpStatusCode.BadRequest);
}
public RegisterUserResponse RegisterUser(RegisterUserRequest request)
{
RegisterUserResponse retval = default;
try
{
retval = _DAL.RegisterUser(request);
}
catch (Exception e)
{
//log
retval = new RegisterUserResponseDontAdd();
}
return(retval);
}
//[Consumes("multipart/form-data")]
//[AllowAnonymous]
public async Task <IActionResult> Register([FromBody] RegisterUserRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var result = await _userService.Register(request);
if (!result.IsSuccessed)
{
return(BadRequest(result));
}
return(Ok(result));
}
public NewRegisterUserPage()
{
InitializeComponent();
NavigationPage.SetHasNavigationBar(this, false);
_objGenderViewModel = new GenderViewModel();
RadioGenderCheck.ItemsSource = _objGenderViewModel.GetRadioType();
_objRegisterUserRequest = new RegisterUserRequest();
BindingContext = _objRegisterUserRequest;
_objRegisterUserResponse = new RegisterUserResponse();
_apiServices = new RestApi();
_baseUrl = Settings.Url + Domain.RegisterUserApiConstant;
}
public async Task <AuthenticationResult> RegisterAsync(RegisterUserRequest registerRequest)
{
var dbUser = this.mapper.Map <DbUser>(registerRequest);
this.CheckCreateUserConflicts(dbUser);
const string role = "User";
dbUser.Role = role;
dbUser.Articles = new List <string>();
await this.context.Users.InsertOneAsync(dbUser);
var credentials = this.mapper.Map <UserCredentials>(dbUser);
return(this.AuthenticateUser(credentials));
}
public async Task RegisterSuccess(string password, string username, string email, string name, AccountType a)
{
var req = new RegisterUserRequest()
{
Password = password,
AccountType = a.ToString(),
Email = email,
DisplayName = name,
};
AuthorizationService service = new AuthorizationService(userRepo, userMapper);
var resp = await service.RegisterAsync(req);
resp.ShouldNotBeNull();
}
public ActionResult RegisterUser(
[FromServices] ICommandHandler <CreateUserCommand> handler,
[FromBody] RegisterUserRequest request)
{
var command = new CreateUserCommand
{
FirstName = request.FirstName,
LastName = request.LastName,
UserName = request.UserName
};
handler.Handle(command);
return(new OkResult());
}
public bool Register(RegisterUserRequest user)
{
try
{
HttpClient client = new HttpClient();
client.BaseAddress = new Uri(BASE_URL);
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
HttpResponseMessage response = client.PostAsync("users/register", new StringContent(JsonConvert.SerializeObject(user), Encoding.UTF8, "application/json")).Result;
return(response.IsSuccessStatusCode);
}
catch
{
return(false);
}
}
public void RegisterUser_UserNameIsAvailable_VerifyRepository()
{
var mockBlogUserRepo = new MockIBlogUserRepository();
var interactor = new RegisterUserInteractor(mockBlogUserRepo);
mockBlogUserRepo.StubList(new List <BlogUser>());
var param_request = new RegisterUserRequest {
UserName = "******"
};
interactor.RegisterUser(param_request);
mockBlogUserRepo.VerifyList();
mockBlogUserRepo.VerifyAddCalled(1);
}
/// <summary>
/// Creates a new instance of the <see cref="UserDataModel" /> class.
/// </summary>
/// <param name="request">The request.</param>
/// <returns>
/// The user data model.
/// </returns>
public UserDataModel NewUserDataModel(RegisterUserRequest request)
{
var encryptionModel = encryptionHelper.EncryptPassword(request.Password);
return(new UserDataModel
{
DateOfBirth = request.DateOfBirth,
EmailAddress = request.EmailAddress,
FirstName = request.FirstName,
LastName = request.LastName,
Salt = encryptionModel.Salt,
Hash = encryptionModel.Hash,
Iterations = encryptionModel.Iterations
});
}
public async Task <IActionResult> Register([FromBody] RegisterUserRequest userRequest)
{
var authResponse = await _account.RegisterAsync(userRequest);
if (!authResponse.Success)
{
return(Ok(_mapper.Map <ConfirmMapResponse>(authResponse)));
}
//var callbackUrl = Url.Action("ConfirmEmail", "Manage", new { UserId = authResponse.UserId, Code = authResponse.Code }, HttpContext.Request.Scheme);
//await _emailSender.SendEmailAsync(authResponse.Email, "ProjMAN - Confirm Your Email", "Please Confirm Your E-Mail by clicking this link: <a href=\"" + callbackUrl + "\">Click here </a>");
return(Ok(_mapper.Map <ConfirmMapResponse>(authResponse)));
}
public async Task <IActionResult> RegisterUser([FromBody] RegisterUserRequest registerUserRequest)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var response = await userProvider.RegisterUserAsync(registerUserRequest);
if (response.Errors != null && response.Errors.Any())
{
return(BadRequest(response));
}
return(Created(registerUserRequest.Username, response));
}
/// <summary>
/// 注册账户
/// </summary>
/// <param name="account">账户</param>
/// <param name="password">密码</param>
/// <param name="inviteAccountId">邀请者账户id</param>
/// <param name="appleId">应用id</param>
/// <param name="referer">来源地址</param>
/// <returns></returns>
public static async Task <object> RegisterUser(string account, string password, string inviteAccountId = "",
string appleId = "",
string referer = "")
{
var client = GrpcDispatcher.Instance <Grpc.Service.Register.RegisterClient>("https://localhost:5001");
RegisterUserRequest request = new RegisterUserRequest()
{
Account = account,
Password = password
};
return(await client.RegisterAsync(request));
return(null);
}
public async Task <bool> RegisterUserAsync(RegisterUserRequest registerUser)
{
var user = _mapper.Map <User>(registerUser);
user.UserName = user.Name;
var result = await _userManager.CreateAsync(user, registerUser.Password);
if (result.Succeeded)
{
await _signInManager.SignInAsync(user, false);
return(true);
}
return(false);
}
public async Task Should_ReturnBadRequest_When_PassingParametersAreEmpty(string username, string password)
{
var cancellationToken = new CancellationToken();
var databaseContext = Create.MockedDbContextFor <DatabaseContext>();
var userPasswordUtility = Substitute.For <IUserPasswordUtility>();
var saltGeneratorUtility = Substitute.For <ISaltGeneratorUtility>();
saltGeneratorUtility.Generate().Returns(Encoding.ASCII.GetBytes("UserPasswordTest"));
userPasswordUtility.HashPassword(password, Encoding.ASCII.GetBytes("UserPasswordTest")).Returns("HashedPassword");
databaseContext.Set <SystemUser>().Add(new SystemUser()
{
Id = 1,
Password = "******",
Username = "******",
Salt = Encoding.ASCII.GetBytes("password1")
});
databaseContext.Set <SystemUser>().Add(new SystemUser()
{
Id = 2,
Password = "******",
Username = "******",
Salt = Encoding.ASCII.GetBytes("password2")
});
databaseContext.Set <SystemUser>().Add(new SystemUser()
{
Id = 3,
Password = "******",
Username = "******",
Salt = Encoding.ASCII.GetBytes("password3")
});
databaseContext.SaveChanges();
var entity = new RegisterUserRequest(username, password);
var handler = new RegisterUserHandler(databaseContext, userPasswordUtility, saltGeneratorUtility);
var result = await handler.Handle(entity, cancellationToken);
Assert.Multiple(() =>
{
Assert.IsFalse(result.Success);
Assert.AreEqual(result.StatusCode, HttpStatusCode.BadRequest);
});
}
/// <inheritdoc/>
public async Task <AuthResponse> RegisterAsync(RegisterUserRequest request)
{
var existingWithUsername = await _userRepository.GetUserByUsernameAsync(request.Username);
var existingWithEmail = await _userRepository.GetUserByEmailAsync(request.Email);
if (existingWithUsername != null)
{
var errors = new List <string>
{
"User with this username already exists!"
};
if (existingWithEmail != null)
{
errors.Add("User with this email already exists!");
}
return(new AuthResponse
{
Success = false,
Errors = errors
});
}
var userToCreate = _mapper.Map <User>(request);
userToCreate.HashedPassword = _passwordHasher.HashPassword(_mapper.Map <User>(request), request.Password);
UserRepository.PutFieldsToUppercase(userToCreate);
try
{
userToCreate.Id = await _userRepository.CreateAsync(userToCreate);
}
catch (MySqlException ex)
{
Console.WriteLine(ex);
return(new AuthResponse
{
Success = false,
Errors = new List <string>
{
"Database error occured!"
}
});
}
return(await GenerateAuthResultForUserAsync(userToCreate));
}
public async Task <IActionResult> Register([FromBody] RegisterUserRequest request)
{
Logger.Trace($"Executing '{nameof(Register)}'.");
try
{
var result = await _mediator.Send(request).ConfigureAwait(false);
return(result.GetResult());
}
catch (Exception ex)
{
Logger.Error(ex, $"Unexpected error thrown while executing '{nameof(RegisterUserHandler)}'.");
throw;
}
}
/// <summary>
/// Register a user by giving username, password, and displayName
/// </summary>
/// <param name="emailAddress">Email address of the user</param>
/// <param name="password">Password to login</param>
/// <param name="displayName">Any string can be used as display name, make it more flexible than Usernam</param>
/// <param name="callback">Returns a Result that contains UserData via callback</param>
public void Register(string emailAddress, string password, string displayName, string country,
DateTime dateOfBirth, ResultCallback <RegisterUserResponse> callback)
{
Report.GetFunctionLog(this.GetType().Name);
var registerUserRequest = new RegisterUserRequest
{
authType = AuthenticationType.EMAILPASSWD,
emailAddress = emailAddress,
password = password,
displayName = displayName,
country = country,
dateOfBirth = dateOfBirth.ToString("yyyy-MM-dd")
};
this.coroutineRunner.Run(this.userAccount.Register(registerUserRequest, callback));
}
public async Task <bool> Handle(RegisterUserRequest message, IOutputPort <RegisterUserResponce> outputPort)
{
var responce = await _userReposytory.Create(message.FirstName, message.SecondName, message.Email, message.UserName, message.Password);
outputPort.Handle(responce.Success ? new RegisterUserResponce(responce.Id, true) : new RegisterUserResponce(responce.Errors.Select(e => e.Description)));
if (responce.Success)
{
var user = await _userReposytory.GetByIdentityId(responce.Id);
await _email.SendMessage(message.Email, user.Id);
}
return(responce.Success);
}
public ActionResult Register(RegisterModel model)
{
var handler = new RegisterUserHandle(new UserRepository());
var request = new RegisterUserRequest()
{
ConfirmPassword = model.ConfirmPassword,
LoginEmail = model.UserName,
Password = model.Password
};
var response = handler.Handle(request);
if (response.Status == ResponseCodes.Success)
{
FormsAuthentication.SetAuthCookie(model.UserName, true);
return RedirectToAction("ChooseProfile", "Profile");
}
var errorMessage = response.Status.GetMessage();
ModelState.AddModelError("", errorMessage);
return View(model);
}
/// <summary>
/// Register user.
/// </summary>
/// <param name="request">
/// The request.
/// </param>
/// <returns>
/// Register user response.
/// </returns>
public RegisterUserResponse RegisterUser(RegisterUserRequest request)
{
return null;
}
