public async Task <IActionResult> Register([FromBody] RegisterRequestViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var result = await _accountDSL.Register(model);
if (!result.Succeeded)
{
return(BadRequest(result.Errors));
}
return(Ok(await _accountDSL.AddToken(model)));
}
public async Task <IActionResult> register([FromBody] RegisterRequestViewModel request)
{
var result = await _userService.RegisterRequest(request);
if (result.UserName == null)
{
return(BadRequest("Register is failed"));
}
else
{
return(new OkObjectResult(new {
statusCode = HttpStatusCode.OK,
data = result
}));
}
}
public async Task <IActionResult> Register([FromBody] RegisterRequestViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(GetModelStateErrorResponse(ModelState)));
}
var resp = await RegisterUser(model);
if (resp.Type != ResponseType.Success)
{
return(BadRequest(resp));
}
return(Ok(resp));
}
public async Task <UserViewModel> CreateUser(RegisterRequestViewModel viewModel, string token)
{
var json = JsonConvert.SerializeObject(viewModel);// convert object to json
// create request
var client = _httClientFactory.CreateClient();
var httpcontent = new StringContent(json, Encoding.UTF8, "application/json");
client.BaseAddress = new Uri("http://apieshop.somee.com");
client.DefaultRequestHeaders.Add("Authorization", "Bearer " + token);
var response = await client.PostAsync("/api/User/register", httpcontent);
var data = await response.Content.ReadAsStringAsync();
var user = JsonConvert.DeserializeObject <ResultApiCreateUser>(data);
return(user.data);
}
public IActionResult Register(RegisterRequestViewModel model)
{
if (ModelState.IsValid)
{
try
{
_accountManager.Register(model);
return(RedirectToAction("Login", "Account"));
}
catch (AppException app)
{
ModelState.AddModelError(string.Empty, app.Message);
}
}
return(View());
}
public async Task <IActionResult> DoctorRegister([FromBody] UsersModel model)
{
try
{
ResultModel res = new ResultModel();
if (model == null)
{
return(BadRequest(new Exception("Unable to fetch record")));
}
else
{
var req = new RegisterRequestViewModel
{
Email = model.Email,
Name = model.FirstName + " " + model.LastName,
Password = "******",//model.Password,
Role = model.Role
};
res = await RegisterAsync(req);
if (res.Code == 4)
{
//return BadRequest(result.Response);
return(Json(res));
}
else
{
model.loginId = res.Response;
if (!string.IsNullOrEmpty(model.Role) && model.Role.ToLower().Equals("doctor"))
{
this._repo.AddDoctor(model);
}
else
{
this._repo.AddNurse(model);
}
return(Json(res));
//return Ok();
}
}
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public async Task <ResultModel> RegisterAsync([FromBody] RegisterRequestViewModel model)
{
//var aVal = 0; var blowUp = 1 / aVal;
ResultModel res = new ResultModel();
if (!ModelState.IsValid)
{
//return BadRequest(ModelState);
var errors = ModelState.Values.SelectMany(v => v.Errors).Select(a => a.Exception).ToList();
res.Code = 4;
res.Response = String.Join(',', errors);
return(res);
}
var user = new AppUser {
UserName = model.Email, Name = model.Name, Email = model.Email
};
var result = await _userManager.CreateAsync(user, model.Password);
if (!result.Succeeded)
{
//return BadRequest(result.Errors);
res.Code = 4;
res.Response = string.Join(',', result.Errors.Select(a => a.Description).ToList());
return(res);
}
await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("userName", user.UserName));
await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("name", user.Name));
await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("email", user.Email));
if (string.IsNullOrEmpty(model.Role))
{
await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("role", Roles.Patient));
}
else
{
await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("role", model.Role.ToLower()));
}
res.Code = 1;
res.Response = user.Id;
return(res);//Ok(new RegisterResponseViewModel(user));
}
public void Register_RegisterSuccess()
{
//Arrange
var mockRegisterRequest = new RegisterRequestViewModel()
{
Password = "******",
Balance = 1,
ConfirmPassword = "******",
LoginName = "MockLoginName"
};
// Act
var result = _accountController.Register(mockRegisterRequest);
var redirectResult = (RedirectToActionResult)result;
//Assert
Assert.True(redirectResult.ControllerName == "Account");
Assert.True(redirectResult.ActionName == "Login");
}
public async Task <IActionResult> Register([FromBody] RegisterRequestViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = new AppUser {
FirstName = model.FirstName, LastName = model.LastName, UserName = model.Email, Email = model.Email
};
var result = await _userManager.CreateAsync(user, model.Password);
if (!result.Succeeded)
{
return(BadRequest(result.Errors));
}
return(Ok());
}
public async Task <IActionResult> Register([FromBody] RegisterRequestViewModel model)
{
await ValidateEmailAsync(model.Email);
await ValidateNameAsync(model.Name);
var user = new ApplicationUser
{
Email = model.Email,
UserName = model.Name,
};
var createUserResult = await _userManager.CreateAsync(user, model.Password);
if (!createUserResult.Succeeded)
{
return(BadRequest(ModelState));
}
return(Ok(user));
}
public async Task <IActionResult> Register([FromBody] RegisterRequestViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = new AppUser {
UserName = model.Name, Name = model.Name, Email = model.Email, PhoneNumber = model.PhoneNumber
};
var result = await _userManager.CreateAsync(user, model.Password);
if (!result.Succeeded)
{
return(BadRequest(result.Errors));
}
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var callbackUrl = Url.Action(
action: "ConfirmEmail",
controller: "Account",
values: new { userId = user.Id, code, model.RedirectUrl },
protocol: Request.Scheme);
await _emailSender.SendEmailAsync(user.Email, "Confirm your email",
$"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");
await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("userName", user.UserName));
await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("name", user.Name));
await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("email", user.Email));
await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("phoneNumber", user.PhoneNumber));
await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("role", Roles.Consumer));
return(Ok());
}
public async Task <IActionResult> Register([FromBody] RegisterRequestViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = new ApplicationUser
{
Email = model.Email,
Nome = model.Name,
SobreNome = model.SobreNome,
UserName = model.Email,
Cep = model.Cep,
Cidade = model.Cidade,
Estado = model.Estado,
Endereco = model.Endereco,
Pais = model.Pais,
PhoneNumber = model.Telefone
};
var result = await _userManager.CreateAsync(user, model.Password);
if (!result.Succeeded)
{
return(BadRequest(result.Errors));
}
await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("userName", user.UserName));
await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("name", user.Nome));
await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("email", user.Email));
await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("role", Roles.Operador));
await _userManager.AddToRoleAsync(user, "operador");
return(Ok(new RegisterResponseViewModel(user)));
}
public IActionResult RegisterUser([FromBody] RegisterRequestViewModel request)
{
if (string.IsNullOrWhiteSpace(request.Name))
{
return(BadRequest(new ErrorViewModel($"{nameof(request.Name)} cannot be empty", nameof(request.Name))));
}
if (!EmailHelper.IsEmailValid(request.Email))
{
return(BadRequest(new ErrorViewModel($"{nameof(request.Email)} is not valid", nameof(request.Email))));
}
if (string.IsNullOrWhiteSpace(request.Password))
{
return(BadRequest(new ErrorViewModel {
Message = $"{nameof(request.Password)} cannot be empty"
}));
}
if (!PasswordValidator.IsPassWordValid(request.Password))
{
return(BadRequest(new ErrorViewModel {
Message = "Password must be between 8 and 64 characters and must contain both uppercase and lowercase letters"
}));
}
// Trim spaces from name + email
request.Name = request.Name.Trim();
request.Email = request.Email.Trim();
if (_userService.GetUser(request.Email) != null)
{
return(BadRequest(new ErrorViewModel($"A user with email {request.Email} already exists", nameof(request.Email))));
}
var user = _userService.Register(request.Name, request.Email, request.ShowEmail, request.Password,
string.Empty, RemoteIpAddress);
return(Ok(user));
}
public IActionResult Register([FromBody] RegisterRequestViewModel request)
{
User newUser = new User
{
FirstName = request.FirstName,
LastName = request.LastName,
Password = request.Password,
Role = request.Role,
Username = request.Username,
PrimaryAddress = new Address
{
State = request.State,
StreetAddress = request.StreetAddress,
City = request.City,
ZipCode = request.ZipCode
}
};
_userRepository.InsertRecord(newUser);
return(Ok(newUser));
}
public void Register(RegisterRequestViewModel request)
{
Log.Information("Start - Registration request for user: {0}", request.LoginName);
var account = _accountRepository.GetByLoginName(request.LoginName);
if (account != null && account.Id != 0)
{
CommonHelper.ThrowAppException(string.Format("Login name {0} already exist!", request.LoginName));
}
_accountRepository.Insert(new AccountEntity()
{
//TODO Auto Generate
AccountNumber = CommonHelper.GenerateAccountNumber(_accountRepository.GetNextAccountId(request.LoginName)),
Balance = request.Balance,
CreateDate = DateTime.Now,
LoginName = request.LoginName,
Password = CommonHelper.EncodePasswordToBase64(request.Password, _config.GetValue <string>("HashKey")),
});
Log.Information("End - Registration request for user: {0}", request.LoginName);
}
public async Task<IActionResult> Register([FromBody]RegisterRequestViewModel model)
{
//var aVal = 0; var blowUp = 1 / aVal;
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
var user = new AppUser { UserName = model.Email, Name = model.Name, Email = model.Email };
var result = await _userManager.CreateAsync(user, model.Password);
if (!result.Succeeded) return BadRequest(result.Errors);
await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("userName", user.UserName));
await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("name", user.Name));
await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("email", user.Email));
await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("role", Roles.Consumer));
return Ok(new RegisterResponseViewModel(user));
}
public async Task <IActionResult> Register([FromBody] RegisterRequestViewModel model)
{
if (!ModelState.IsValid)
{
var errorsList =
ModelState.Keys.SelectMany(key => ModelState[key].Errors.Select(error => new IdentityError
{
Code = "Validation",
Description = error.ErrorMessage
}));
return(BadRequest(errorsList));
}
var user = new ApplicationUser
{
UserName = model.Email, Name = model.Name, CompanyName = model.CompanyName, Email = model.Email,
Id = Guid.NewGuid().ToString()
};
var result = await _userManager.CreateAsync(user, model.Password);
if (!result.Succeeded)
{
return(BadRequest(result.Errors));
}
await _userManager.AddClaimAsync(user, new Claim("userName", user.UserName));
await _userManager.AddClaimAsync(user, new Claim("name", user.Name));
await _userManager.AddClaimAsync(user, new Claim("email", user.Email));
await _userManager.AddClaimAsync(user, new Claim("role", Roles.Consumer));
await _userManager.AddClaimAsync(user, new Claim("companyName", user.CompanyName));
return(Ok(new RegisterResponseViewModel(user)));
}
public async Task <IActionResult> PatientRegister([FromBody] UsersModel model)
{
try
{
ResultModel res = new ResultModel();
if (model == null)
{
return(BadRequest(new Exception("Unable to fetch record")));
}
else
{
var req = new RegisterRequestViewModel
{
Email = model.Email,
Name = model.FirstName + " " + model.LastName,
Password = model.Password,
//Role = null
};
res = await RegisterAsync(req);
if (res.Code == 4)
{
//return BadRequest(result.Response);
return(Json(res));
}
else
{
model.loginId = res.Response;
this._repo.AddPatient(model);
return(Json(res));
//return Ok();
}
}
}
catch (Exception e) {
return(BadRequest(e));
}
}
public async Task <IActionResult> Register([FromBody] RegisterRequestViewModel model)
{
//var aVal = 0; var blowUp = 1 / aVal;
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = new AppUser {
UserName = model.Email, Name = model.Name, Email = model.Email
};
var result = await _userManager.CreateAsync(user, model.Password);
if (!result.Succeeded)
{
return(BadRequest(result.Errors));
}
var token = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var confirmationLink = Url.Action(nameof(ConfirmEmail), "Account", new { token, email = user.Email }, Request.Scheme);
var message = "Confirmation email link " + confirmationLink;
await _emailSender.SendEmailAsync(user.Email, "Email verification", message);
await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("userName", user.UserName));
await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("name", user.Name));
await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("email", user.Email));
await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("role", Roles.Consumer));
return(Ok(new RegisterResponseViewModel(user)));
}
public async Task <IActionResult> Register([FromBody] RegisterRequestViewModel model)
{
//var aVal = 0; var blowUp = 1 / aVal;
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = new TIRIRIT_USER
{
UserName = model.UserName,
FIRST_NAME = model.FirstName,
LAST_NAME = model.LastName,
Email = model.EmailAddress
};
var result = await this.userManager.CreateAsync(user, model.Password);
if (!result.Succeeded)
{
return(BadRequest(result.Errors));
}
await this.userManager.AddClaimAsync(user, new Claim(JwtClaimTypes.PreferredUserName, user.UserName));
await this.userManager.AddClaimAsync(user, new Claim(JwtClaimTypes.GivenName, user.FIRST_NAME));
await this.userManager.AddClaimAsync(user, new Claim(JwtClaimTypes.FamilyName, user.FIRST_NAME));
await this.userManager.AddClaimAsync(user, new Claim(JwtClaimTypes.Email, user.Email));
await this.userManager.AddToRoleAsync(user, Roles.StandardUser);
return(Ok(new RegisterResponseViewModel(user)));
}
public async Task <IActionResult> CreateUser(RegisterRequestViewModel viewModel)
{
if (ModelState.IsValid)
{
var token = HttpContext.Session.GetString("Token");
var reponse = await _userApiClient.CreateUser(viewModel, token);
if (reponse != null)
{
TempData["Result"] = "Create Success";
return(Redirect("Index"));
}
else
{
ViewBag.Erorr = "Create user failed";
return(View());
}
}
else
{
ViewBag.Erorr = "Create user failed";
return(View());
}
}
public async Task <IActionResult> Register([FromBody] RegisterRequestViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = new ApplicationUser
{
UserName = model.Name,
Email = model.Email
};
var result = await _userManager.CreateAsync(user, model.Password);
if (!result.Succeeded)
{
return(BadRequest(result.Errors));
}
await _userManager.AddClaimAsync(user, new Claim("account_id", user.Id));
return(Ok());
}
public IActionResult CreateUser()
{
var user = new RegisterRequestViewModel();
return(View(user));
}
public Task <RegisterResponseViewModel> AddToken(RegisterRequestViewModel model)
{
var user = AccountHelper.MapAppUser(model);
return(_accountDAL.AddToken(user));
}
public Task <IdentityResult> Register(RegisterRequestViewModel model)
{
var user = AccountHelper.MapAppUser(model);
return(_accountDAL.Register(user, model.Password));
}
public async Task <IActionResult> Register([FromBody] RegisterRequestViewModel model)
{
//var aVal = 0; var blowUp = 1 / aVal;
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (Domains.IsValid(model.Domain))
{
return(BadRequest("Domain not supported"));
}
var user = new AppUser
{
DomainUsername = model.DomainUsername,
UserName = model.Email,
Name = model.Name,
Email = model.Email,
Domain = model.Domain
};
var result = await _userManager.CreateAsync(user, model.Password);
if (!result.Succeeded)
{
return(BadRequest(result.Errors));
}
var appUser = new User()
{
Email = model.Email,
AdUser = new ADUser()
{
Username = model.DomainUsername,
Groups = new List <string>(model.Groups)
},
Interests = new List <string>(model.Interests),
Name = model.Name,
Surname = model.Surname,
IdentityId = (await _userManager.FindByEmailAsync(model.Email)).Id
};
var appRegister = new CreateUserRequest()
{
Key = _config["KEY"],
User = appUser
};
Api.MakeRequest(_config["API_ADDRESS"] + "/Identity/createUser", JsonConvert.SerializeObject(appRegister));
await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("username", user.UserName));
await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("name", user.Name));
await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("email", user.Email));
await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("role", Roles.Student));
await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("domain", user.Domain));
await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("domainUsername", user.DomainUsername));
foreach (var interest in model.Interests)
{
await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("interest", interest));
}
foreach (var group in model.Groups)
{
await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("group", group));
}
return(Ok(new RegisterResponseViewModel(user)));
}
public IActionResult Register(RegisterRequestViewModel model)
{
_accountService.Register(model, Request.Headers["origin"]);
return(Ok(new { message = "Registration successful, please check your email for verification instructions" }));
}
public async Task <ActionResult <ResponseStatusViewModel> > Put(RegisterRequestViewModel model)
{
ResponseStatusViewModel responseModel = new ResponseStatusViewModel();
responseModel.Result = true;
if (string.IsNullOrWhiteSpace(model.FirstName))
{
responseModel.Result = false;
responseModel.Messages.Add("First name cannot be blank.");
}
if (string.IsNullOrWhiteSpace(model.LastName))
{
responseModel.Result = false;
responseModel.Messages.Add("Last name cannot be blank.");
}
if (string.IsNullOrWhiteSpace(model.Username))
{
responseModel.Result = false;
responseModel.Messages.Add("Username cannot be blank.");
}
if (string.IsNullOrWhiteSpace(model.Password))
{
responseModel.Result = false;
responseModel.Messages.Add("Password cannot be blank.");
}
if (!responseModel.Result)
{
return(new BadRequestObjectResult(responseModel));
}
MemberModel member = new MemberModel()
{
Email = model.Email,
UserName = model.Username,
FirstName = model.FirstName,
LastName = model.LastName,
TwoFactorEnabled = true
};
IdentityResult result = await _userManager.CreateAsync(member, model.Password);
if (result.Succeeded)
{
IdentityRole memberRole = _roleManager.Roles.FirstOrDefault(r => r.Name == "Member");
IdentityRole adminRole = _roleManager.Roles.FirstOrDefault(r => r.Name == "Admin");
if (memberRole == null)
{
await _userManager.AddToRoleAsync(member, "Member");
}
await _userManager.AddToRoleAsync(member, memberRole.Name);
if (model.Username == "Admin")
{
if (adminRole == null)
{
await _userManager.AddToRoleAsync(member, "Admin");
}
await _userManager.AddToRoleAsync(member, adminRole.Name);
}
responseModel.Result = true;
responseModel.Messages.Add("Thank you for registering your account.");
return(new OkObjectResult(responseModel));
}
else
{
responseModel.Result = false;
responseModel.Messages.Add("Unable to create your user account.");
return(new BadRequestObjectResult(responseModel));
}
}
