public async Task <User> RegisterNoSave(UserRegisterDTO dto)
{
var user = await _context.Users.WhereIsNotDeleted().FirstOrDefaultAsync(
u => u.UserName == dto.UserName || u.Email == dto.Email);
if (user == null)
{
var passwordHash = PasswordHelper.GetPasswordHash(dto.Password);
var utcNow = _scopeService.RequestDateTimeOffsetUtc;
var role = await _context.Roles.FirstAsync(r => r.Name == UserRoleNames.USER);
user = new User
{
UserName = dto.UserName,
Email = dto.Email,
PasswordHash = passwordHash,
StatusId = (int)UserStatusEnum.Created,
RegistrationDate = utcNow,
Role = role,
Company = dto.Company
};
var newUser = (await _context.Users.AddAsync(user)).Entity;
return(newUser);
}
throw new BusinessLogicException(ExceptionCodes.BL_CODE_USER_ALREADY_EXIST);
}
public async Task <IHttpActionResult> Register(RegisterUser model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = new UserRegisterDTO()
{
UserName = model.UserName,
Password = model.Password,
Email = model.Email,
Fullname = model.FirstName + " " + model.Surname,
PhoneNumber = model.PhoneNumber
};
IdentityResult result = await userService.Register(user);
if (!result.Succeeded)
{
return(GetErrorResult(result));
}
return(Ok("User was registered successfully"));
}
public async Task <IActionResult> Register(UserRegisterDTO userDto)
{
var userCheck = await _repo.UserExits(userDto.UserName);
if (userCheck)
{
return(BadRequest("User name already exists"));
}
var userToCreate = new User
{
UserName = userDto.UserName
};
var addUser = await _repo.Register(userToCreate, userDto.Password);
if (addUser)
{
await _repo.Save();
return(StatusCode(201));
}
else
{
return(BadRequest("Something went wrong!"));
}
}
public bool RegisterUser(UserRegisterDTO register)
{
try
{
using (StoryboardDBEntities context = new StoryboardDBEntities())
{
context.Users.Add(new User()
{
FirstName = register.FirstName,
MiddleName = register.MiddleName,
LastName = register.LastName,
Email = register.Email,
Password = register.Password,
CreatedOn = DateTime.Now,
ModifiedOn = DateTime.Now
});
context.SaveChanges();
return(true);
}
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <IActionResult> Register([FromBody] UserRegisterDTO registerParam)
{
try
{
var user = await _userService.Register(registerParam);
if (user == null)
{
throw new Exception("Register Error");
}
return(Ok(new Response <UserLoginDTO>
{
Error = false,
ErrorDescription = null,
ResponseModel = user,
StatusCode = StatusCodes.Status200OK
}));
}
catch (Exception ex)
{
return(BadRequest(new Response <UserLoginDTO>
{
Error = true,
ErrorDescription = ex.Message,
StatusCode = StatusCodes.Status400BadRequest
}));
}
}
// [FromBody] needed if not using [ApiController]
// public async Task<IActionResult> Register([FromBody]UserRegisterDTO userRegisterDTO)
#endregion
public async Task <IActionResult> Register(UserRegisterDTO userRegisterDTO)
{
#region Validate ModelState
// // validate request - Needed if not using [ApiController]
// if (!ModelState.IsValid)
// return BadRequest(ModelState);
#endregion
userRegisterDTO.Username = userRegisterDTO.Username.ToLower().Trim();
if (await _authRepo.UserExists(userRegisterDTO.Username))
{
return(BadRequest("Username already exists."));
}
User userToCreate = new User
{
Username = userRegisterDTO.Username
};
User createdUser = await _authRepo.Register(userToCreate, userRegisterDTO.Password);
// Temporary, in development
return(StatusCode(201));
}
public async Task <IActionResult> Register(UserRegisterDTO registerDto)
{
if (ModelState.IsValid)
{
var user = new User()
{
UserName = registerDto.UserName,
FirstName = registerDto.FirstName,
LastName = registerDto.LastName
};
var result = await _userManager.CreateAsync(user, registerDto.Password);
if (result.Succeeded)
{
await _signInManager.SignInAsync(user, false);
return(new OkResult());
}
else
{
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
}
return(new OkResult());
}
public async Task <ActionResult <User> > store(
[FromBody] UserRegisterDTO model,
[FromServices] IUserRepository context
)
{
var user = new User {
name = model.name,
username = model.username,
password = model.password,
role = model.role
};
try{
await context.AddAsync(user);
return(NoContent());
}catch (Exception error) {
var errors = new List <string> {
error.Message
};
return(new ObjectResult(new { errors = errors })
{
StatusCode = 401
});
}
}
public async Task <bool> Register(String User, String Password, String Email)
{
var register = new UserRegisterDTO
{
Username = User,
Password = Password,
Email = Email
};
var httpClient = new HttpClient();
var json = JsonConvert.SerializeObject(register); // serializing the register object
var content = new StringContent(json, Encoding.UTF8, "application/json"); //specifying the json format
try
{
using var response = await httpClient.PostAsync(AppSettings.Url + "/auth/register", content); // calling post async with the json object
if (!response.IsSuccessStatusCode)
{
return(false);
}
else
{
return(true);
}
}
catch (Exception e)
{
await App.Current.MainPage.DisplayAlert("Something went wrong", e.Message, "OK");
}
return(false);
}
public async Task <ActionResult> Registrar(UserRegisterDTO registerUser)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.Values.SelectMany(e => e.Errors)));
}
var user = new IdentityUser
{
UserName = registerUser.Email,
Email = registerUser.Email,
EmailConfirmed = true
};
var result = await _userManager.CreateAsync(user, registerUser.Password);
if (!result.Succeeded)
{
return(BadRequest(result.Errors));
}
await _signInManager.SignInAsync(user, false);
Object token = new {
access_token = await GerarJwt(registerUser.Email),
user = registerUser.Email
};
return(Ok(token));
}
public async Task <IActionResult> Register([FromBody] UserRegisterDTO user)
{
// validate request if not using ApiController
// if(!ModelState.IsValid) return BadRequest(ModelState);
// user.Username = user.Username.ToLower ();
// if (await _repo.UserExists (user.Username)) {
// return BadRequest ("Username is already taken");
// }
var userToCreate = _mapper.Map <User> (user);
var result = await _userManager.CreateAsync(userToCreate, user.Password);
var userToReturn = _mapper.Map <UserForDetailedDTO> (userToCreate);
if (result.Succeeded)
{
return(CreatedAtRoute("GetUser",
new { controller = "Users", id = userToReturn.Id },
userToReturn));
}
return(BadRequest(result.Errors));
}
public async Task <IActionResult> Register([FromBody] UserRegisterDTO dto)
{
if (!string.IsNullOrEmpty(dto.UserName))
{
dto.UserName = dto.UserName.ToLower();
}
if (await repo.UserExists(dto.UserName))
{
ModelState.AddModelError("UserName", "Usernameis already taken");
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var userToCreate = mapper.Map <User>(dto);
var createdUser = await repo.Register(userToCreate, dto.Password);
var userToReturn = mapper.Map <UserDetailDTO>(createdUser);
return(CreatedAtAction("Register", userToReturn));
}
public UserRegisterDTO DeleteUser(int id)
{
if (id < 1)
{
throw new BadRequestException("Id nullo");
}
try
{
User user = _userRepository.GetUserById(id);
user.UserEnum = Enums.UserEnum.INACTIVE;
_userRepository.Update(user);
UserRegisterDTO userRegisterDTO = new UserRegisterDTO();
userRegisterDTO.CPF = user.CPF;
userRegisterDTO.Email = user.Email;
userRegisterDTO.Name = user.Name;
userRegisterDTO.UserEnum = user.UserEnum;
userRegisterDTO.UserRole = user.UserRole;
userRegisterDTO.Id = user.Id;
return(userRegisterDTO);
}
catch (Exception e)
{
throw new Exception("Algo deu errado: " + e.GetType());
}
}
public UserRegisterDTO UpdateUser(User user)
{
try
{
User user1 = _userRepository.GetUserByCPF(user.CPF);
user1.CPF = user.CPF;
user1.Email = user.Email;
user1.Name = user.Name;
user1.UserEnum = user.UserEnum;
user1.UserRole = user.UserRole;
_userRepository.Update(user1);
}
catch (Exception e)
{
throw new Exception("Algo deu errado: " + e.GetType());
}
UserRegisterDTO userRegisterDTO = new UserRegisterDTO();
userRegisterDTO.CPF = user.CPF;
userRegisterDTO.Email = user.Email;
userRegisterDTO.Name = user.Name;
userRegisterDTO.UserEnum = user.UserEnum;
userRegisterDTO.UserRole = user.UserRole;
userRegisterDTO.Id = user.Id;
return(userRegisterDTO);
}
public async Task <IActionResult> CreateUser(UserRegisterDTO urd)
{
try
{
if (!_authService.CheckPassword(urd.Password, urd.ReinputPassword))
{
return(BadRequest("As senhas não são iguais."));
}
;
if (!_authService.CheckRole(urd.Role))
{
return(BadRequest("O Permissionamento informado não existe."));
}
User novoUser = new User(urd.Name, urd.Email, urd.Role, new List <Tarefa>(), urd.isActive);
User user = await _authService.CreateUser(novoUser, urd.Password);
if (user == null)
{
return(BadRequest("Usuário já existe"));
}
return(StatusCode(201));
}
catch (MongoWriteException mwe)
{
throw new Exception(mwe.GetType().Name);
}
catch (Exception e)
{
throw new Exception(e.GetType().Name);
}
}
public async Task <User> CreateUser(UserRegisterDTO userDto)
{
var userEntity = _mapper.Map <User>(userDto);
var user = await _context.Users.Where(a => a.Email == userEntity.Email).FirstOrDefaultAsync();
if (user != null)
{
_logger.LogWarning(LoggingEvents.HaveException, $"user already exists");
throw new ExistedUserLoginException();
}
var salt = SecurityHelper.GetRandomBytes();
userEntity.PasswordSalt = Convert.ToBase64String(salt);
userEntity.PasswordHash = SecurityHelper.HashPassword(userDto.Password, salt);
userEntity.RegisteredAt = DateTime.Now;
userEntity.EditorSettingsId = await _editorSettingService.CreateInitEditorSettings();
if (!string.IsNullOrEmpty(userDto.Picture))
{
userEntity.Avatar = new Image
{
Url = userDto.Picture
};
}
_context.Users.Add(userEntity);
await _context.SaveChangesAsync();
await SendConfirmationMail(userEntity.Id);
return(userEntity);
}
public bool Register(UserRegisterDTO userRegisterDTO)
{
userRegisterDTO.username = userRegisterDTO.username.ToLower();
if (_userRepository.Exist(x => x.userName == userRegisterDTO.username))
{
return(false);
}
byte[] passwordHash, passwordSalt;
CreatePasswordHash(userRegisterDTO.password, out passwordHash, out passwordSalt);
User user = new User
{
PasswordHash = passwordHash,
PasswordSalt = passwordSalt,
userName = userRegisterDTO.username
};
_userRepository.Add(user);
_unitOfWork.Save();
return(true);
}
public ActionResult Register([Bind(Include = "Name,Password,ConfirmedPassword,Email,PhoneNumber,RoleName,Roles")] RegistrationViewModel registrationViewModel)
{
registrationViewModel.Roles = roleList.Roles;
try
{
//registrationViewModel = RegisterationRoleMapper.Map<RolesDTO, RegistrationViewModel>(roleList);
ModelState.Remove("Roles");
if (ModelState.IsValid)
{
UserRegisterDTO userRegisterDTO = RegistrationViewModelMapper.Map <RegistrationViewModel, UserRegisterDTO>(registrationViewModel);
UserInfoDTO newUserInfoDTO = userBusinessContext.RegisterUser(userRegisterDTO);
return(View("Success"));
}
else
{
return(View(registrationViewModel));
}
}
catch (EmailAlreadyExistsException ex)
{
ModelState.AddModelError("Email", "Email id already Registered");
return(View(registrationViewModel));
}
catch (Exception exception)
{
ModelState.AddModelError("", "Something went wrong.Please try after some time");
}
return(View("Error"));
}
public async Task <IActionResult> RegisterAsync([FromBody] UserRegisterDTO registerModel)
{
var user = new User()
{
Nickname = registerModel.NickName,
PhoneNumber = registerModel.Mobile
};
user.UserName = registerModel.Account;
var result = await userManager.CreateAsync(user);
if (result.Succeeded == false)
{
if (result.Errors.Any(p => p.Code == nameof(IdentityErrorDescriber.DuplicateUserName)))
{
throw new Exception("该账号已存在");
}
else if (result.Errors.Any(p => p.Code == nameof(IdentityErrorDescriber.DuplicateEmail)))
{
throw new Exception("该邮箱已存在");
}
}
else
{
if (string.IsNullOrWhiteSpace(registerModel.Password) == false)
{
await userManager.AddPasswordAsync(user, registerModel.Password);
}
await signInManager.SignInAsync(user, true);
}
return(Ok());
}
public static ValidatorResult ValidatePassword(UserRegisterDTO user)
{
ValidatorResult validatorResult = new ValidatorResult(true);
bool passwordContainsUsername = user.Password.IndexOf(user.Username, StringComparison.OrdinalIgnoreCase) >= 0;
if (passwordContainsUsername && user.Username.Length >= 3)
{
validatorResult.IsValid = false;
validatorResult.ValidationMessage = "Password could not contains the username.";
return(validatorResult);
}
validatorResult = PasswordContainsFullName(user.Password, user.FullName);
if (!validatorResult.IsValid)
{
return(validatorResult);
}
Regex regex = new Regex(@"^(?=.*?[A-Z])(?=.*?[a-z])(?=.*?[0-9])(?=.*?[#?!@$%^&*-]).{8,}$");
Match match = regex.Match(user.Password);
if (!match.Success)
{
validatorResult.IsValid = false;
validatorResult.ValidationMessage = "Password must contain at less one Upper case letter, one lower case letter, one digit number and one special symbol.";
return(validatorResult);
}
return(validatorResult);
}
public async Task <IActionResult> Register([FromBody] UserRegisterDTO userRegisterDTO)
{
if (!string.IsNullOrEmpty(userRegisterDTO.UserName))
{
userRegisterDTO.UserName = userRegisterDTO.UserName.ToLower();
}
if (await this.repository.UserExists(userRegisterDTO.UserName))
{
ModelState.AddModelError("Username", "Username already exists");
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var newUser = new User
{
UserName = userRegisterDTO.UserName
};
var createUser = await this.repository.Register(newUser, userRegisterDTO.Password);
return(StatusCode(201));
}
public async Task <bool> Add(UserRegisterDTO model)
{
var user = _mapper.Map <User>(model);
await _cloadBeryContext.Users.AddAsync(user);
return(await _cloadBeryContext.SaveChangesAsync() > 0);
}
public async Task <IHttpActionResult> Register([FromBody] UserRegisterDTO user)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var newPerson = new UserRegisterDTO()
{
Password = user.Password,
ConfirmPassword = user.ConfirmPassword,
RoleName = "User",
Email = user.Email,
Name = user.Name,
PhoneNumber = user.PhoneNumber,
userId = user.userId
};
IdentityResult result = await _authService.RegisterUser(newPerson);
if (!result.Succeeded)
{
return(BadRequest(ModelState));
}
else
{
return(Ok());
}
}
public void RegisterUser(UserRegisterDTO User)
{
try
{
RegisterUserValidation rv = new RegisterUserValidation();
if (!rv.ValidationUser(User.DS_LOGIN))
{
throw new HttpException("Erro no Usuario", "Este Usuario ja esta cadastrado", HttpStatusCode.Unauthorized);
}
TB_LE_USUARIO us = new TB_LE_USUARIO();
us.DS_USUARIO = User.DS_USUARIO;
us.DS_LOGIN = User.DS_LOGIN;
us.DS_SENHA = EncryptProvider.Sha1(User.DS_SENHA);
us.FL_ADMINISTRADOR = false;
us.FL_ATIVO = true;
us.NR_IDADE = User.NR_IDADE;
db.TB_LE_USUARIOs.Add(us);
db.SaveChanges();
}
catch (HttpException)
{
throw;
}
catch (Exception ex)
{
throw new HttpException("Erro Interno no Sistema", string.Format("Ocorrou um erro durante o cadastro. Contate o administrador. {0}", ex.Message), HttpStatusCode.InternalServerError);
}
}
public Response <ClaimsPrincipal> Register(UserRegisterDTO user)
{
byte[] passwordHash, passwordSalt;
HashService.Create(user.Password, out passwordHash, out passwordSalt);
User userToCreate = new User
{
Email = user.EMail,
FirstName = user.FirstName,
LastName = user.LastName,
PasswordHash = passwordHash,
PasswordSalt = passwordSalt,
UserOperationClaim = new Collection <UserOperationClaim>()
{
new UserOperationClaim
{
OperationClaimId = AuthenticationConstants.OperationClaims.User
}
}
};
var response = UserService.Add(userToCreate);
if (response.IsSuccess == false)
{
return(Response <ClaimsPrincipal> .Fail(response.Message));
}
var claimsPrincipal = GetClaimsPrincipal(response.Data);
return(Response <ClaimsPrincipal> .Success("Kayıt başarılı", claimsPrincipal));
}
public async Task <string> RegisterUser(UserRegisterDTO userRegisterDTO)
{
try
{
var user = await _dbContext.Users.SingleOrDefaultAsync(x => x.Login == userRegisterDTO.Login);
if (user == null)
{
string salt;
userRegisterDTO.Password = _authenticationService.HashPassword(userRegisterDTO.Password, out salt);
var userToAdd = _mapper.Map <User>(userRegisterDTO);
userToAdd.Role = Roles.User;
userToAdd.Salt = salt;
await _dbContext.Users.AddAsync(userToAdd);
await _dbContext.SaveChangesAsync();
return("OK");
}
else
{
return("Login zajęty");
}
}
catch (Exception ex)
{
throw ex;
}
}
public ServiceMessage RegisterUser(UserRegisterDTO userDTO)
{
List <string> errors = new List <string>();
bool succeeded = Validate(userDTO, errors);
if (succeeded)
{
try
{
succeeded = Register(userDTO, errors);
if (succeeded)
{
UserEntity userEntity = new UserEntity
{
Id = userManager.FindByName(userDTO.Login).Id
};
unitOfWork.Users.Add(userEntity);
userManager.AddToRole(userEntity.Id, Roles.UserRole);
}
}
catch (Exception ex)
{
succeeded = false;
ExceptionMessageBuilder.FillErrors(ex, errors);
}
}
return(new ServiceMessage
{
Succeeded = succeeded,
Errors = errors
});
}
public ActionResult Register([Bind(Include = "Name,Password,ConfirmedPassword,Email,PhoneNumber,RoleName,Roles")] RegistrationViewModel registrationViewModel)
{
registrationViewModel.Roles = roleList.Roles;
try
{
//registrationViewModel = RegisterationRoleMapper.Map<RolesDTO, RegistrationViewModel>(roleList);
ModelState.Remove("Roles");
if (ModelState.IsValid)
{
UserRegisterDTO userRegisterDTO = RegistrationViewModelMapper.Map <RegistrationViewModel, UserRegisterDTO>(registrationViewModel);
UserInfoDTO newUserInfoDTO = userBusinessContext.RegisterUser(userRegisterDTO);
return(View("Success"));
}
else
{
return(View(registrationViewModel));
}
}
catch (EmailAlreadyExistsException ex)
{
ModelState.AddModelError("Email", "Email id already Registered");
return(View(registrationViewModel));
}
catch (Exception ex)
{
return(RedirectToAction("ExceptionCatch", "Static", new { exception = ex.Message }));
}
}
public ActionResult Register(RegisterModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
UserRegisterDTO user = new UserRegisterDTO
{
Email = model.Email,
Password = model.Password,
Login = model.Login,
FirstName = model.FirstName,
LastName = model.LastName
};
ServiceMessage serviceMessage = service.RegisterUser(user);
if (serviceMessage.Succeeded)
{
return(RedirectToAction("Login"));
}
else
{
foreach (string error in serviceMessage.Errors)
{
ModelState.AddModelError("", error);
}
return(View(model));
}
}
public async Task <IActionResult> Register(UserRegisterDTO userRegisterDTO)
{
if (ModelState.ErrorCount > 0)
{
return(BadRequest(ModelState));
}
if (await _repo.UserExists(userRegisterDTO.email.Trim()))
{
return(BadRequest("Email is already Taken"));
}
var user = await _repo.Register(userRegisterDTO);
if (user != null)
{
await _repo.AddRole(user.UID, "User");
return(Ok(user));
}
else
{
return(BadRequest("Problrem ocour"));
}
}
