public async Task <IResult <IRegisterUserResponse> > Register(IRegisterUserRequest registerUser, CancellationToken cancel = default)
{
Result <IRegisterUserResponse> result;
if (registerUser is null)
{
throw new ArgumentNullException(nameof(registerUser));
}
var user = new AppUser()
{
UserName = registerUser.UserName,
Email = registerUser.Email
};
var registerResult = await _userManager.CreateAsync(user, registerUser.Password).ConfigureAwait(false);
if (registerResult.Succeeded)
{
result = new RegisterUserResponse()
{
Token = _jwtGenerator.CreateToken(user)
};
return(result);
}
result = registerResult.Errors.Select(item => new ErrorInformation(item.Description)).ToArray();
return(result);
}
public async Task <RegisterUserResponse> RegisterUserAsync(RegisterUserRequest request)
{
var userToRegister = new ApplicationUser()
{
LastName = request.LastName,
FirstName = request.FirstName,
Email = request.Email,
UserName = request.Email
};
var emailTaken = await _userManager.FindByEmailAsync(request.Email) != null;
var accountCreationResult = await _userManager.CreateAsync(userToRegister, request.Password);
if (!accountCreationResult.Succeeded)
{
return(null);
}
var token = await _jwtGenerator.CreateTokenAsync(userToRegister);
var response = new RegisterUserResponse
{
Token = token.Token,
RefreshToken = token.RefreshToken
};
return(response);
}
public async Task <RegisterUserResponse> SignUpAsync(Guid id, string email, string firstName, string lastName, string password, string role = Role.User)
{
var response = new RegisterUserResponse();
var user = await _userRepository.GetAsync(email);
if (user != null)
{
response.Code = Codes.EmailInUse;
response.Message = $"Email: '{email}' is already in use.";
response.Error = true;
}
else
{
if (string.IsNullOrWhiteSpace(role))
{
role = Role.User;
}
user = new User(id, email, firstName, lastName, role);
user.SetPassword(password, _passwordHasher);
await _userRepository.AddAsync(user);
await _busPublisher.PublishAsync(new SignedUp(id, email, role), CorrelationContext.Empty);
response.Code = Codes.RegistrationSuccessful;
response.Message = $"Registration successful.";
response.Error = false;
}
return(response);
}
public async Task <IActionResult> RegisterUser([FromBody] RegisterUserRequest request,
CancellationToken cancellationToken)
{
RegisterUserResponse result = await this.Manager.RegisterUser(request, cancellationToken);
return(this.Ok(result));
}
public AccountResponseDto(RegisterUserResponse result) : this()
{
switch (result.Result)
{
case RegisterUserResponse.RegistrateUserResult.UserCreated:
Success = true;
Description = "Your account has been successfully opened.";
Password = result.Password;
break;
case RegisterUserResponse.RegistrateUserResult.InvalidUsername:
Success = false;
Description = "Failure: username must contain at least one character.";
break;
case RegisterUserResponse.RegistrateUserResult.UsernameAlreadyExists:
Success = false;
Description = "Failure: username already exists.";
break;
case RegisterUserResponse.RegistrateUserResult.Unknown:
default:
Success = false;
Description = "Failure: unknown exception occurred. Try again later or report the issue.";
break;
}
}
public void RegisterUser()
{
try
{
RegisterUserResponse response = null;
response = _userService.RegisterUser(new RegisterUserRequest()
{
Duty = "技术员", RoleId = "SuperManager", Email = "*****@*****.**", Password = "******", Name = "hy"
});
Assert.IsTrue(response.IsSucess && response.User != null);
response = _userService.RegisterUser(new RegisterUserRequest()
{
Duty = "技术员", RoleId = "SuperManager", Email = "*****@*****.**", Password = "******", Name = string.Empty
});
Assert.IsTrue(response.IsSucess == false && response.Message.Contains("Name"));
response = _userService.RegisterUser(new RegisterUserRequest()
{
Duty = "技术员", RoleId = "SuperManager", Email = "*****@*****.**", Password = "******", Name = ""
});
Assert.IsTrue(response.IsSucess == false && response.Message.Contains("Name"));
}
catch (Exception ex)
{
Assert.IsTrue(false);
}
}
public async Task CantRegisterUserWithInvalidAccountDetails()
{
AccountsClient client = new AccountsClient(GrpcChannel);//_serviceProvider.GetRequiredService<AccountsClient>();
Assert.NotNull(client);
// Act
RegisterUserResponse response = await client.RegisterAsync(new RegisterUserRequest()
{
FirstName = "John",
LastName = "Doe",
Email = string.Empty,
UserName = string.Empty,
Password = "******"
});//.ResponseAsync.DefaultTimeout();
// Assert
//Assert.AreEqual(deadline, options.Deadline);
//Assert.AreEqual(cancellationToken, options.CancellationToken);
Assert.NotNull(response);
Assert.NotNull(response.Response);
Assert.False(response.Response.Success);
Assert.Single(response.Response.Errors);
Assert.True(string.IsNullOrEmpty(response.Id));
Assert.Equal("InvalidUserName", response.Response.Errors.First().Code);
//Assert.Equal("'Email' is not a valid email address.", response.Response.Errors.First().Description);
}
public async Task <ActionResult> AddKYC(int userId)
{
bool isSuccess = false;
if (userId > 0)
{
RegisterUserResponse rr = new RegisterUserResponse();
RegisterUser registerUser = new RegisterUser();
registerUser.idprooftype = Convert.ToInt32(Request.Form["idprooftype"].ToString());
registerUser.idproof = Request.Form["idproof"];
registerUser.addressprooftype = Convert.ToInt32(Request.Form["addressprooftype"].ToString());
registerUser.addressproof = Request.Form["addressproof"];
registerUser.bankdetails = Request.Form["bankdetails"];
KYCDetails kdetail = new KYCDetails();
kdetail.kyc_detail_id = 0;
kdetail.id_proof_id = registerUser.idprooftype;
kdetail.id_proof_document_path = registerUser.idproof;
kdetail.address_proof_id = registerUser.addressprooftype;
kdetail.address_proof_document_path = registerUser.addressproof;
kdetail.bank_details = registerUser.bankdetails;
int kyc_detail_id = await rs.InsertKYCInfo(kdetail);
if (kyc_detail_id > 0)
{
isSuccess = await rs.UpdateKYCInfoInUser(userId, kyc_detail_id);
}
}
return(Ok(isSuccess));
}
public bool AddNewUser(RegisterUserResponse newUser)
{
newUser.NewUser.Password = PasswordManager.HashPassword(configuration, newUser.NewUser.Password);
using (context)
{
try
{
var user = context.Users.FirstOrDefault(usr => usr.UserName == newUser.NewUser.UserName || usr.Email == newUser.NewUser.Email);
if (user == null)
{
context.Users.Add(newUser.NewUser);
context.SaveChanges();
newUser.Success = true;
}
else
{
newUser.Success = false;
newUser.ErrorMesssage = $"User {newUser.NewUser.FirstName} already exists";
}
}
catch (Exception ex)
{
newUser.Success = false;
newUser.ErrorMesssage = $"An Error has occured { ex.Message }";
}
}
return(newUser.Success);
}
public override void Execute(string packet)
{
RegisterUserResponse registerUserResponse = JsonConvert.DeserializeObject <RegisterUserResponse>(packet);
switch (registerUserResponse.Status)
{
case ResponseStatus.Ok:
Application.Current.Dispatcher.Invoke(() =>
{
SetPage(new Login());
});
break;
case ResponseStatus.Bad:
unlock();
(ClientObject.view as UserViewModel).Status = "Ошибка на стороне сервера";
break;
case ResponseStatus.LoginIsTaken:
unlock();
(ClientObject.view as UserViewModel).Status = "Пользователь с таким логином уже существует";
break;
}
}
public AuthModule(ITokenizer tokenizer, IAuthService authService)
: base("auth")
{
this.tokenizer = tokenizer;
this.authService = authService;
Post["/token"] = x =>
{
var request = this.CustomBindAndValidate <AuthenticateUserRequest>();
var identity = GetUserIdentity(request);
var response = GetAuthenticateResponse(identity);
return(Negotiate
.WithStatusCode(HttpStatusCode.OK)
.WithModel(response));
};
Post["/register"] = x =>
{
var request = this.CustomBindAndValidate <RegisterUserRequest>();
authService.Register(request);
var response = new RegisterUserResponse();
return(Negotiate
.WithStatusCode(HttpStatusCode.OK)
.WithModel(response));
};
}
public async Task <RegisterUserResponse> RegisterUserAsync(RegisterUserRequest registerUserRequest)
{
var user = Mapper.Map <RegisterUserRequest, User>(registerUserRequest);
this.userValidationService.ValidateRegisterUser(user);
user.HashedPassword = this.passwordService.HashPassword(registerUserRequest.Password);
var refreshToken = this.jwtSecurityTokenService.GenerateRefreshToken();
user.RefreshToken = Encoding.Default.GetBytes(refreshToken);
user.RoleId = AnyUserExists ? (int)AuthorizationRole.User : (int)AuthorizationRole.Administrator;
await Context.Users.AddAsync(user);
await Context.SaveChangesAsync();
var accessTokenGenerationData = new AccessTokenGenerationData
{
UserId = user.Id,
RefreshToken = refreshToken,
Email = user.Email,
AuthorizationRole = user.AuthorizationRole
};
var registerUserResponse = new RegisterUserResponse
{
AccessToken = this.jwtSecurityTokenService.GenerateToken(accessTokenGenerationData),
User = Mapper.Map <User, UserDto>(user)
};
return(registerUserResponse);
}
/// <summary>
/// Unmarshaller the response from the service to the response class.
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public override AmazonWebServiceResponse Unmarshall(JsonUnmarshallerContext context)
{
RegisterUserResponse response = new RegisterUserResponse();
context.Read();
int targetDepth = context.CurrentDepth;
while (context.ReadAtDepth(targetDepth))
{
if (context.TestExpression("RequestId", targetDepth))
{
var unmarshaller = StringUnmarshaller.Instance;
response.RequestId = unmarshaller.Unmarshall(context);
continue;
}
if (context.TestExpression("User", targetDepth))
{
var unmarshaller = UserUnmarshaller.Instance;
response.User = unmarshaller.Unmarshall(context);
continue;
}
}
response.Status = (int)context.ResponseData.StatusCode;
return(response);
}
public async Task <RegisterUserResponse> RegisterUser(RegisterUserPostModel Model)
{
var json = await new HttpMethods().ServicePostAsync(BaseUrlDotNetCore + "/api/v4/RegisterUser", Model);
RegisterUserResponse Response = JsonConvert.DeserializeObject <RegisterUserResponse>(json);
return(Response);
}
public AuthModule(ITokenizer tokenizer, IAuthService authService)
: base("auth")
{
this.tokenizer = tokenizer;
this.authService = authService;
Post["/token"] = x =>
{
var request = this.CustomBindAndValidate<AuthenticateUserRequest>();
var identity = GetUserIdentity(request);
var response = GetAuthenticateResponse(identity);
return Negotiate
.WithStatusCode(HttpStatusCode.OK)
.WithModel(response);
};
Post["/register"] = x =>
{
var request = this.CustomBindAndValidate<RegisterUserRequest>();
authService.Register(request);
var response = new RegisterUserResponse();
return Negotiate
.WithStatusCode(HttpStatusCode.OK)
.WithModel(response);
};
}
public async Task ThenMyNewUserIdWillBeReturned()
{
HttpResponseMessage httpResponse = this.ScenarioContext.Get <HttpResponseMessage>("RegisterUserHttpResponse");
RegisterUserResponse responseData = JsonConvert.DeserializeObject <RegisterUserResponse>(await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false));
responseData.UserId.ShouldNotBe(Guid.Empty);
this.ScenarioContext["UserId"] = responseData.UserId;
}
public IActionResult RegisterNewUser([FromBody] User data)
{
RegisterUserResponse newUser = new RegisterUserResponse {
NewUser = data
};
_userRepository.AddNewUser(newUser);
return(Json(newUser));
}
public async Task <ActionResult> Register([FromBody] Models.Request.RegisterUserRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
RegisterUserResponse response = await _mediator.Send(new RegisterUserCommand(request.FirstName, request.LastName, request.Email, request.UserName, request.Password));
return(_mapper.Map <JsonContentResult>(response));
}
public SignUpPage()
{
InitializeComponent();
NavigationPage.SetHasNavigationBar(this, false);
_objRegisterUserRequest = new RegisterUserRequest();
BindingContext = _objRegisterUserRequest;
_objRegisterUserResponse = new RegisterUserResponse();
_apiServices = new RestApi();
_baseUrl = Settings.Url + Domain.RegisterUserApiConstant;
}
public RegisterUserResponse RegisterUser(RegisterUserRequest request)
{
RegisterUserResponse response = new RegisterUserResponse();
try
{
using (IUnitOfWork unitOfWork = RepositoryFactory.GetUnitOfWork())
{
if (request != null)
{
IUserRepository userRepository = RepositoryFactory.Get(typeof(IUserRepository), unitOfWork) as IUserRepository;
IRoleRepository roleRepository = RepositoryFactory.Get(typeof(IRoleRepository), unitOfWork) as IRoleRepository;
User user = new User()
{
Id = System.Guid.NewGuid(), Name = request.Name, Password = request.Password, Duty = request.Duty, Email = request.Email, RoleId = request.RoleId
};
user.IsValidated();
userRepository.Add(user);
Role role = roleRepository.GetByKey(request.RoleId);
unitOfWork.Commit();
if (role != null)
{
response.IsSucess = true;
response.User = new ViewModels.UserView()
{
Id = user.Id.ToString(),
Name = user.Name,
Password = user.Password,
Duty = user.Duty,
Email = user.Email,
RoleId = user.RoleId,
RoleName = role.Name
};
}
else
{
response.IsSucess = false;
response.Message = "No role in RegisterUser of UserService!";
}
}
else
{
response.IsSucess = false;
response.Message = "No Input!";
}
}
}
catch (Exception ex)
{
Log.Write(ex.Message);
response.IsSucess = false;
response.Message = ex.Message;
}
return(response);
}
protected void CreateUser_Click(object sender, EventArgs e)
{
if (checkMail(Email.Text))
{
GetPersonRequest rqt = new GetPersonRequest()
{
Username = Email.Text
};
using (Service1Client client = new Service1Client())
{
GetPersonResponse rsp = client.GetPerson(rqt);
//Check mail is not already used
if (rsp.Errored)
{
//Check password and Hash
if (check_password(Password.Text) && Password.Text == ConfirmPassword.Text)
{
// Add to database
Person user = new Person()
{
Username = Email.Text,
Company = Company.Text,
IsAdmin = false,
Password = Password.Text
};
RegisterUserResponse response = client.RegisterUser(new RegisterUserRequest()
{
User = user
});
if (!response.Errored)
{
ErrorMessage.Text = "Your account has been created";
}
else
{
ErrorMessage.Text = "Fail to create your account";
}
}
else
{
ErrorMessage.Text = "Wrong Password";
}
}
else
{
ErrorMessage.Text = "This email adress is already used";
}
}
}
else
{
ErrorMessage.Text = "Wrong email address format";
}
}
public bool RegisterUser(string username, string email, string password, out string errorMessage)
{
RegisterUserRequest inValue = new RegisterUserRequest();
inValue.username = username;
inValue.email = email;
inValue.password = password;
RegisterUserResponse retVal = ((IAuthService)(this)).RegisterUser(inValue);
errorMessage = retVal.errorMessage;
return(retVal.RegisterUserResult);
}
public RegisterUserResponse Login(RegisterUserRequest request)
{
RegisterUserResponse retval = default;
var parameters = _DalParametersConverter.ConvertToParameters(request.UserDTO);
var dataset = _SQLDAL.ExecSPQuery("LoginUser", con, parameters);
if (dataset.Tables[0].Rows.Count != 0)
{
retval = new RegisterUserExistsResponse();
}
return(retval);
}
public static RegisterUserResponse Unmarshall(UnmarshallerContext _ctx)
{
RegisterUserResponse registerUserResponse = new RegisterUserResponse();
registerUserResponse.HttpResponse = _ctx.HttpResponse;
registerUserResponse.RequestId = _ctx.StringValue("RegisterUser.RequestId");
registerUserResponse.ErrorCode = _ctx.StringValue("RegisterUser.ErrorCode");
registerUserResponse.ErrorMessage = _ctx.StringValue("RegisterUser.ErrorMessage");
registerUserResponse.Success = _ctx.BooleanValue("RegisterUser.Success");
return(registerUserResponse);
}
public async Task <IActionResult> Register(
[HttpTrigger(
AuthorizationLevel.Anonymous,
"post",
Route = "user")]
[RequestBodyType(typeof(RegisterUserRequest), "Register User Request")]
HttpRequest req)
{
if (req.ContentLength <= 0)
{
return(HttpCodeHelper.EmptyRequestBody());
}
string requestBody;
using (StreamReader readStream = new StreamReader(req.Body))
{
requestBody = await readStream.ReadToEndAsync();
}
RegisterUserRequest payload;
try
{
payload = JsonConvert.DeserializeObject <RegisterUserRequest>(requestBody);
}
catch (Exception e)
{
return(HttpCodeHelper.Return400(e.Message));
}
var newUser = new User
{
Email = payload.Email
};
try
{
_userService.Create(newUser, payload.Password);
}
catch (JournallyException ex)
{
return(HttpCodeHelper.Return400(ex.Message));
}
var response = new RegisterUserResponse
{
Email = newUser.Email
};
return(new CreatedResult("https://example.com/api/entries/201", response));
}
//[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 void Excecute(ClientObject client, ServerObject server, RoomObject room, string packet = "")
{
Console.WriteLine("Register user");
var request = JsonConvert.DeserializeObject <RegisterUserRequest>(packet);
var response = new RegisterUserResponse();
response.Status = DB.RegisterUser(request.User);
Console.WriteLine($"Register user status: {response.Status.ToString()}");
string packetResponse = JsonConvert.SerializeObject(response);
server.SendMessageToDefiniteClient(packetResponse, client);
}
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 RegisterUserResponse RegisterUser(RegisterUserRequest request)
{
RegisterUserResponse retval = default;
try
{
retval = _DAL.RegisterUser(request);
}
catch (Exception e)
{
//log
retval = new RegisterUserResponseDontAdd();
}
return(retval);
}
public HttpResponseMessage Register(ToDoUser user)
{
RegisterUserResponse response = new RegisterUserResponse();
//trying to add new user
if (_authManager.AddUserToDb(user))
{
response.SessionId = _sessionManager.CreateSession(user);
return(Request.CreateResponse(HttpStatusCode.Created, response));
}
else
{
return(Request.CreateResponse(HttpStatusCode.Conflict, response));
}
}
public void RegisterUser_UserNameIsAvailable_ReturnsExpectedRegisterUserResponse()
{
var stubBlogUserRepo = new StubIBlogUserRepository();
var interactor = new RegisterUserInteractor(stubBlogUserRepo);
stubBlogUserRepo.StubList(new List <BlogUser>());
var expected = new RegisterUserResponse {
RegisterSuccessful = true
};
var param_request = new RegisterUserRequest {
UserName = "******"
};
var actual = interactor.RegisterUser(param_request);
Assert.Equal(expected.RegisterSuccessful, actual.RegisterSuccessful);
}
