public async Task <ActionResult <AuthenticatedUser> > Register([FromBody] RegisterCredentials credentials)
{
var isAdded = await _users.AddUserAsync(credentials);
if (isAdded)
{
var user = await _authenticateService.Authenticate(new LoginCredentials()
{
Email = credentials.Email, Password = credentials.Password
});
if (user != null)
{
var transaction = await _transactions.CreateTransactionAsync(null, user.Id, REGISTRATION_BONUS, DateTime.Now);
if (transaction != null)
{
var result = await _transactions.CommitTransactionAsync(transaction);
if (result != null)
{
return(Ok(user));
}
}
}
return(BadRequest(new { message = "Registration failed" }));
}
else
{
return(BadRequest(new { message = "User already registered" }));
}
}
public async Task <IActionResult> Register([FromBody] RegisterCredentials userDetails)
{
if (!ModelState.IsValid || userDetails == null)
{
return(new BadRequestObjectResult(new { Message = "User Registration Failed" }));
}
var identityUser = new ApplicationUser()
{
UserName = userDetails.username, Email = userDetails.Email
};
var result = await userManager.CreateAsync(identityUser, userDetails.Password);
if (!result.Succeeded)
{
var dictionary = new ModelStateDictionary();
foreach (IdentityError error in result.Errors)
{
dictionary.AddModelError(error.Code, error.Description);
}
return(new BadRequestObjectResult(new { Message = "User Registration Failed", Errors = dictionary }));
}
return(Ok(new { Message = "User Reigstration Successful" }));
}
public async Task <string> Register(RegisterCredentials registerCredentials)
{
var userExists = await _userManager.FindByEmailAsync(registerCredentials.Email);
if (userExists != null)
{
throw new UserAlreadyExistsException("User already exists");
}
User user = new User()
{
UserName = registerCredentials.Username,
Email = registerCredentials.Email,
SecurityStamp = Guid.NewGuid().ToString(),
};
var result = await _userManager.CreateAsync(user, registerCredentials.Password);
if (!result.Succeeded)
{
throw new UnexpectedException("Unexpected user registration fail");
}
var userRoles = await _userManager.GetRolesAsync(user);
var token = _jwtService.GenerateJwtToken(user, userRoles);
return(token);
}
public async Task <IActionResult> RegisterAccount([FromBody] RegisterCredentials credentials)
{
if (!credentials.Password.Equals(credentials.RePassword))
{
return(BadRequest(new List <IdentityError>()
{
new IdentityError()
{
Description = "Passwords are not the same!"
}
}));
}
var user = new CustomIdentityUser()
{
First = credentials.First, Last = credentials.Last, UserName = credentials.Email, Email = credentials.Email
};
var result = await userManager.CreateAsync(user, credentials.Password);
if (!result.Succeeded)
{
return(BadRequest(result.Errors));
}
await signInManager.SignInAsync(user, false);
return(Ok(CreateToken(user)));
}
public IHttpActionResult Post(RegisterCredentials registerCredentials)
{
if (registerCredentials != null)
{
try
{
DebugLog.Logar(registerCredentials.Id.ToString());
Funcionario funcionario = db.Funcionarios.Where(x => x.Id == registerCredentials.Id && x.Senha == registerCredentials.Senha).Include(f => f.Cargo).FirstOrDefault();
if (funcionario == null)
{
return(Json("invalido"));
}
return(Json(funcionario));
}
catch (Exception e)
{
DebugLog.Logar(e.Message);
DebugLog.Logar(e.StackTrace);
return(Json("Erro ao cadastrar solicitação!"));
}
}
return(Ok("registerCredentials Null"));
}
public string Register(RegisterCredentials credentials)
{
if (repo.Register(credentials))
{
return(repo.GenerateToken(credentials.Username));
}
throw new FaultException("User already exist!");
}
public async Task <IActionResult> Register([FromBody] RegisterCredentials credentials)
{
if (ModelState.IsValid)
{
return(await _accountsService.Register(credentials));
}
return(Error("Unexpected error"));
}
public void RegistrarUsuario(RegisterCredentials credentials)
{
String user = credentials.Nombre + " " + credentials.Apellidos;
DateTime fecha = DateTime.Now;
String rol = "cliente";
UsuarioDTO u = new UsuarioDTO(credentials.Password, user, credentials.Nombre, credentials.Apellidos, credentials.Email, rol, fecha);
this.context.Usuario.Add(u);
this.context.SaveChanges();
}
public async Task <OneOf <Ok, LoginOccupied> > Handle(RegisterCommand request, CancellationToken cancellationToken)
{
var credentials = new RegisterCredentials(
request.RegisterDTO.Login,
request.RegisterDTO.Password,
request.RegisterDTO.Username
);
var serviceResponse = await _usersService.RegisterUser(credentials);
return(serviceResponse);
}
public async Task <Response <LoggedUser> > Register(RegisterCredentials credentials, string userRole)
{
var existingUser = await userManager.FindByEmailAsync(credentials.Email);
if (existingUser != null)
{
return(Response <LoggedUser> .Failure(ResponseResult.BadRequestStructure, $"Użytkownik o adresie e-mail: {credentials.Email} już istnieje!"));
}
var existingRole = await roleManager.RoleExistsAsync(userRole);
if (!existingRole)
{
return(Response <LoggedUser> .Failure(ResponseResult.ResourceDoesntExist, $"Rola: {userRole} nie istnieje w systemie!"));
}
var user = new AppUser
{
FirstName = credentials.FirstName,
LastName = credentials.LastName,
UserName = $"{credentials.FirstName}{credentials.LastName}{Guid.NewGuid().ToString()}",
Email = credentials.Email,
Tags = new Collection <Tag>(),
TodoSets = new Collection <TodoSet>(),
};
var result = await userManager.CreateAsync(user, credentials.Password);
if (!result.Succeeded)
{
return(Response <LoggedUser> .Failure(ResponseResult.InternalError, "Nie udało się utworzyć nowego użytkownika"));
}
await userManager.AddToRoleAsync(user, userRole);
await userManager.AddClaimAsync(user, new Claim(ClaimTypes.Role, userRole));
var logged = new LoggedUser
{
Id = user.Id,
FirstName = user.FirstName,
LastName = user.LastName,
UserName = user.UserName,
PhoneNumber = user.PhoneNumber,
Email = user.Email,
Token = webTokenGenerator.CreateToken(user, userRole)
};
return(Response <LoggedUser> .Success(ResponseResult.DataObtained, logged));
}
public async Task <OneOf <Ok, LoginOccupied> > RegisterUser(RegisterCredentials userRegister)
{
if (await _usersRepository.LoginOccupied(userRegister.Login))
{
return(new LoginOccupied());
}
var user = new User(userRegister.Login, userRegister.Password, userRegister.Username);
_usersRepository.Add(user);
await _usersRepository.SaveChangesAsync();
return(new Ok());
}
public HttpResponseMessage Post(RegisterCredentials credentials)
{
if (!ModelState.IsValid)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, ModelState.Values.SelectMany(v => v.Errors).Select(e => e.ErrorMessage)));
}
try
{
this.repo.RegistrarUsuario(credentials);
return(Request.CreateResponse(HttpStatusCode.OK, "Todo perfecto! Pruebe a loguearse."));
}
catch (Exception ex)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, ex));
}
}
public async Task <IActionResult> Register([FromBody] RegisterCredentials registerCredentials)
{
try
{
var token = await _authenticationService.Register(registerCredentials);
return(Ok(token));
}
catch (Exception error) when(error is UserAlreadyExistsException)
{
return(Conflict(error.Message));
}
catch (Exception error) when(error is UnexpectedException)
{
return(StatusCode(StatusCodes.Status500InternalServerError, error.Message));
}
}
public async Task <ActionResult <LoginResponse> > Register(RegisterCredentials registerCredentials)
{
try
{
var loginResponse = await _userService.RegisterAsync(registerCredentials);
if (loginResponse == null)
{
return(BadRequest("Error during registration"));
}
return(loginResponse);
}
catch (ArgumentException ex)
{
return(BadRequest(ex.Message));
}
}
public async Task <IActionResult> Register(RegisterCredentials register)
{
var user = new AppUser
{
UserName = register.UserName,
FirstName = register.FirstName,
LastName = register.LastName,
Email = register.Email
};
var result = await _userManager.CreateAsync(user, register.Password);
if (result.Succeeded)
{
return(Ok(user));
}
return(BadRequest(result.Errors));
}
public bool Register(RegisterCredentials credentials)
{
var user = context.Products.SingleOrDefault(x => x.Username == credentials.Username);
if (user == null)
{
var newUser = new AppUser()
{
IsAuth = true,
Name = credentials.Name,
PasswordHash = credentials.Password,
Username = credentials.Username,
Account = new UserAccount()
};
context.Products.Add(newUser);
context.SaveChanges();
return(true);
}
return(false);
}
public static void Register()
{
if (token == null)
{
string username, password, name;
Console.Write("Name:");
name = Console.ReadLine();
Console.Write("Username:"******"Password[4 chars]:");
password = Console.ReadLine();
if (String.IsNullOrEmpty(username) || String.IsNullOrEmpty(password) || String.IsNullOrEmpty(name))
{
return;
}
if (password.Length != 4)
{
Console.WriteLine("--> Password lenght must be 4 <--");
}
try
{
RegisterCredentials cred = new RegisterCredentials(name, username, password);
token = authService.Register(cred);
Console.WriteLine($"--> Logged In! <--");
}
catch (FaultException ex)
{
token = null;
Console.WriteLine($"--> {ex.Message} <--");
}
}
else
{
Console.WriteLine("--> Already Logged In! <--");
}
}
public async Task <IActionResult> Register([FromBody] RegisterCredentials credentials)
{
if (ModelState.IsValid)
{
var user = new IdentityUser
{
UserName = credentials.Email,
Email = credentials.Email
};
var result = await _userManager
.CreateAsync(user, credentials.Password);
if (!result.Succeeded)
{
return(BadRequest(result.Errors));
}
await _signInManager.SignInAsync(user, isPersistent : false);
return(Ok("User Created."));
}
return(BadRequest());
}
public ActionResult Register(RegisterCredentials model)
{
if (!UserProvider.ValidateLogin(model.Login))
ModelState.AddModelError("Login", "Логин не соответствует требованиям");
if (!UserProvider.ValidateEmail(model.Email))
ModelState.AddModelError("Email", "Email не соответствует требованиям");
if (!UserProvider.ValidatePassword(model.Password))
ModelState.AddModelError("Password", "Пароль не соответствует требованиям");
if (string.Compare(model.Password, model.RePassword) != 0)
ModelState.AddModelError("RePassword", "Пароли не совпадают");
if (!ModelState.IsValid)
{
model.Password = string.Empty;
model.RePassword = string.Empty;
return View(model);
}
MembershipCreateStatus status;
string Password = model.Password;
Membership.Provider.CreateUser(model.Login, model.Password, model.Email, string.Empty, string.Empty, false, null, out status);
switch (status)
{
case MembershipCreateStatus.InvalidEmail:
ModelState.AddModelError("Email", "Email не соответствует требованиям");
break;
case MembershipCreateStatus.DuplicateEmail:
ModelState.AddModelError("Email", "Такой email уже зарегистрирован");
break;
case MembershipCreateStatus.InvalidUserName:
ModelState.AddModelError("Login", "Логин не соответствует требованиям");
break;
case MembershipCreateStatus.DuplicateUserName:
ModelState.AddModelError("Login", "Такой логин уже зарегистрирован");
break;
case MembershipCreateStatus.Success:
{
SendActivationEmail(model.Email, Password);
Common.SetSessionMessage(Session, "Вы успешно зарегистрировались на сайте. На Ваш email выслано письмо с инструкциями по активации Вашей учётной записи.", "Регистрация");
return RedirectToAction("Result", "Home");
}
default:
Common.SetSessionMessage(Session, "Ошибка регистрации нового пользователя: "+status.ToString(), "Регистрация");
return RedirectToAction("Result", "Home");
}
return View(model);
}
private string ValidateRecoveryCredentials(RegisterCredentials u)
{
string sql = @"select UserId from cycli_riders where UserName=@username and Email=@email and (AccountStatus='Active' or AccountStatus='Reset')";
// Check against the database
SQLiteDatabase db = new SQLiteDatabase();
string userId = db.ExecuteScalar(sql, "@username", u.username, "@email", u.email);
if (!string.IsNullOrEmpty(userId))
{
string hash = PasswordHash.CreateHash(u.password);
string code = Guid.NewGuid().ToString();
sql = @"update cycli_riders set activationcode=@a, AccountStatus='Reset', password=@p where userid=@u and AccountStatus='Active'";
if (db.ExecuteNonQuery(sql, "@a", code,"@p", hash, "@u", userId) > 0)
{
Emailer.SendRecoveryConfirmation(u.username, userId, code, u.email);
}
}
db.Close();
return userId;
}
