public async Task <IActionResult> Register([FromBody] RegisterUserResource registerUser)
{
if (!ModelState.IsValid)
{
return(BadRequest(0));
}
var user = new ApplicationUser
{
UserName = registerUser.UserName,
PhoneNumber = registerUser.Phone
};
var result = await userManager.CreateAsync(user, registerUser.Password);
if (result.Succeeded)
{
var createdUser = await userManager.FindByNameAsync(registerUser.UserName);
personService.AddPerson(createdUser);
await SendCode(createdUser.PhoneNumber);
return(Ok(new APIResponse {
bit = true
}));
}
else
{
return(BadRequest(new APIResponse {
bit = false
}));
}
}
public List <LoginInfo> RegisterNewUser([FromBody] RegisterUserResource userResource)
{
string parameters = Convert.ToBoolean(userResource.PersonalInfo.isReg.ToString())
+ " , '" + userResource.PersonalInfo.FirstName
+ "', '" + userResource.PersonalInfo.SecondName
+ "', '" + userResource.PersonalInfo.LastName
+ "', '" + userResource.PersonalInfo.Gender
+ "', '" + userResource.PersonalInfo.EmailId
+ "', '" + userResource.PersonalInfo.ContactNumber
+ "', '" + userResource.PersonalInfo.ContactAddress
+ "', '" + userResource.PersonalInfo.Dob
+ "', '" + userResource.UserInfo.username
+ "', '" + userResource.UserInfo.password + "'";
if (userResource.PersonalInfo.Type == "S")
{
string comand = "exec Add_Student " + parameters;
return(db.LoginInfo.FromSql(comand).ToList());
}
else
{
string comand = "exec Add_Teacher "
+ "0 ,"
+ parameters;
return(db.LoginInfo.FromSql(comand).ToList());
}
}
private JwtTokenResource BuildJwtToken(RegisterUserResource model, IList <string> roles)
{
var claims = new List <Claim>
{
new Claim(JwtRegisteredClaimNames.UniqueName, model.Email),
new Claim("Mi valor", "Lo que quiera"),
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString())
};
foreach (var rol in roles)
{
claims.Add(new Claim(ClaimTypes.Role, rol));
}
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(iconfiguration["JWT:key"]));
var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
var expiration = DateTime.UtcNow.AddHours(1);
JwtSecurityToken token = new JwtSecurityToken(
issuer: null,
audience: null,
claims: claims,
expires: expiration,
signingCredentials: creds);
return(new JwtTokenResource()
{
Token = new JwtSecurityTokenHandler().WriteToken(token),
Expiration = expiration
});
}
public async Task <IActionResult> Register([FromBody] RegisterUserResource registerUser)
{
if (!ModelState.IsValid)
{
return(BadRequest(0));
}
var user = new ApplicationUser
{
UserName = registerUser.UserName,
PhoneNumber = registerUser.Phone
};
var result = await userManager.CreateAsync(user, registerUser.Password);
if (result.Succeeded)
{
var createdUser = await userManager.FindByNameAsync(registerUser.UserName);
personService.AddPerson(createdUser);
////var token = await userManager.GenerateEmailConfirmationTokenAsync(user);
//var confirmationLink = Url.Action("ConfirmEmail", "Account",
// new { userId = user.Id, token = token }, Request.Scheme);
return(Ok(new APIResponse {
bit = true
}));
}
else
{
return(BadRequest(new APIResponse {
bit = false
}));
}
}
public async Task <ActionResult> Registrar(RegisterUserResource registerUser)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessages()));
}
var user = new IdentityUser()
{
UserName = registerUser.Email,
Email = registerUser.Email, //Ambos sao a mesma informacao
EmailConfirmed = true
};
var result = await _userManager.CreateAsync(user, registerUser.Password);
if (result.Succeeded)
{
await _signInManager.SignInAsync(user, false); //Faz o login (false -> nao vai lembrar)
return(Ok(await GerarJwt(user.Email)));
}
foreach (var error in result.Errors)
{
return(BadRequest(error.Description));
}
return(Ok(await GerarJwt(user.Email)));
}
public async Task <IActionResult> Register([FromBody] RegisterUserResource user)
{
if (!string.IsNullOrEmpty(user.Username))
{
user.Username = user.Username.ToLower();
}
if (await _userRepo.UserExists(user.Username, user.Email))
{
ModelState.AddModelError("Duplicate", "Username or email already exist.");
}
var userToCreate = _mapper.Map <User>(user);
//Validate request goes here.
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
userToCreate.CreateDate = DateTime.Now;
userToCreate.CreateBy = ClaimTypes.NameIdentifier;
var createdUser = await _userRepo.Register(userToCreate);
await _uom.CommitAsync();
var userToReturn = _mapper.Map <UserResource>(createdUser);
return(CreatedAtRoute("GetUser",
new { controller = "User", id = createdUser.Id }, userToReturn));
}
public async Task <IActionResult> Register([FromBody] RegisterUserResource userResource)
{
if (ModelState.IsValid)
{
var user = mapper.Map <RegisterUserResource, ApplicationUser>(userResource);
var role = await roleManager.FindByNameAsync(RolesEnum.User.ToString());
if (role == null)
{
ModelState.AddModelError("", "Role not found");
return(new BadRequestObjectResult(new BadRequestResource(ModelState)));
}
user.UserRoles.Add(new ApplicationUserRole()
{
RoleId = role.Id
});
user.IsActive = true;
user.CreatedAt = DateTime.Now;
user.UpdatedAt = DateTime.Now;
var result = await this.userManager.CreateAsync(user, userResource.Password);
if (!result.Succeeded)
{
foreach (IdentityError error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
return(new BadRequestObjectResult(new BadRequestResource(ModelState)));
}
else
{
var token = await this.userManager.GenerateEmailConfirmationTokenAsync(user);
var callbackUrl = Url.Action(
"ConfirmEmail",
"Auth",
values: new EmailConfirmationResource {
UserId = user.Id, Token = token
},
protocol: Request.Scheme);
await this.unitOfWork.CompleteAsync();
return(new OkObjectResult(new { callbackUrl = callbackUrl }));
}
}
return(new BadRequestObjectResult(new BadRequestResource(ModelState)));
}
public async Task <IActionResult> CreateUserAsync([FromBody] RegisterUserResource registerUserResource)
{
var language = Request.Headers["Accept-Language"].ToString();
if (ModelState.IsValid)
{
var user = await this.userManager.FindByEmailAsync(registerUserResource.Email);
if (user != null)
{
ModelState.AddModelError("", "User is already exist");
return(new BadRequestObjectResult(new BadRequestResource(ModelState)));
}
user = this.mapper.Map <RegisterUserResource, ApplicationUser>(registerUserResource);
var role = await roleManager.FindByNameAsync(RolesEnum.User.ToString());
if (role == null)
{
ModelState.AddModelError("", "Role not found");
return(new BadRequestObjectResult(new BadRequestResource(ModelState)));
}
user.UserRoles.Add(new ApplicationUserRole()
{
RoleId = role.Id
});
user.EmailConfirmed = true;
user.IsActive = true;
user.CreatedAt = DateTime.Now;
user.UpdatedAt = DateTime.Now;
var result = await this.userManager.CreateAsync(user, registerUserResource.Password);
if (result.Succeeded)
{
user = await this.userRepository.FindUserByIdAsync(user.Id);
var userResource = this.mapper.Map <ApplicationUser, UserResource>(user);
return(new OkObjectResult(userResource));
}
foreach (IdentityError error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
return(new BadRequestObjectResult(new BadRequestResource(ModelState)));
}
public static string RegisterPlayer(string clientId, string name, string password, string gameId)
{
string response;
string urlSuffix = GAME_SUFFIX + "/" + gameId + "/register";
RegisterUserResource rur = new RegisterUserResource {
name = name,
clientID = clientId,
password = password
};
int code = Post(urlSuffix, JsonUtility.ToJson(rur), out response);
HandleReturnCode(code);
return(response);
}
public async Task <ActionResult <JwtTokenResource> > CreateUser([FromBody] RegisterUserResource model)
{
var user = new ApplicationUser {
UserName = model.Email, Email = model.Email
};
var result = await userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
return(BuildJwtToken(model, new List <string>()));
}
else
{
return(BadRequest("El usuario o la contraseña son invàlidos"));
}
}
public async Task <IActionResult> Register([FromBody] RegisterUserResource userResource)
{
if (ModelState.IsValid)
{
var registerUserDto = _mapper.Map <RegisterUserResource, RegisterUserDto>(userResource);
var roleDto = await _userService.FindRoleByNameAsync("User");
var createdUser = await _userService.CreateUserAsync(registerUserDto, roleDto, userResource.Password);
var code = await _userService.GetPhoneNumberTokenAsync(createdUser.Id, createdUser.PhoneNumber);
return(new OkObjectResult(new { userId = createdUser.Id, Code = code }));
}
return(new BadRequestObjectResult(new { message = "Failed to register" }));
}
public async Task <IActionResult> RegisterAsync([FromBody] RegisterUserResource registerUserResource)
{
try
{
var user = _mapper.Map <RegisterUserResource, User>(registerUserResource);
var result = await _userService.SaveAsync(user);
if (!result.Success)
{
return(BadRequest(result));
}
return(Ok(result));
}
catch (Exception ex)
{
return(StatusCode(StatusCodes.Status500InternalServerError, new FailureResponse($"Internal Server Error:{ex.Message}")));
}
}
public async Task <ActionResult <JwtTokenResource> > Login([FromBody] RegisterUserResource model)
{
var result = await signInManager.PasswordSignInAsync(model.Email, model.Password,
isPersistent : false, lockoutOnFailure : false);
if (result.Succeeded)
{
var usuario = await userManager.FindByEmailAsync(model.Email);
var roles = await userManager.GetRolesAsync(usuario);
return(BuildJwtToken(model, roles));
}
else
{
ModelState.AddModelError(string.Empty, "Intento de ingreso inválido");
return(BadRequest(ModelState));
}
}
public async Task <IActionResult> Register([FromBody] RegisterUserResource registerUserResource)
{
try {
var user = mapper.Map <RegisterUserResource, User>(registerUserResource);
var userWithSameEmail = unitOfWork.Accounts.FindUserByEmail(user.Email);
if (userWithSameEmail != null)
{
return(BadRequest(new ApiResponse(400, "User with same email already exists")));
}
unitOfWork.Accounts.Register(user);
await unitOfWork.CompleteAsync();
}
catch (Exception ex)
{
Debug.WriteLine("Exception", ex);
}
return(Ok());
}
