public async Task <ActionResult <AppUser> > Login(RegisterUserDto registerUserDto)
{
var user = await _context.Users.SingleOrDefaultAsync(user => user.UserName == registerUserDto.UserName);
if (user == null)
{
return(Unauthorized("User does not exists"));
}
using var hmac = new HMACSHA512(user.PasswordSalt);
var computedHash = hmac.ComputeHash(Encoding.UTF8.GetBytes(registerUserDto.Password));
for (int index = 0; index < user.PasswordHash.Length; index++)
{
if (computedHash[index] != user.PasswordHash[index])
{
return(Unauthorized("Invalid password"));
}
}
return(user);
}
public async Task <bool> Register(RegisterUserDto model)
{
//if (!ModelState.IsValid)
//{
// return BadRequest(ModelState);
//}
var user = new NawafizApp.Services.Identity.IdentityUser()
{
Email = model.Email, UserName = model.Email, CreationDate = Utils.ServerNow, FullName = model.FullName
};
IdentityResult result = await UserManager.CreateAsync(user, model.Password);
//if (!result.Succeeded)
//{
// return GetErrorResult(result);
//}
UserManager.AddToRole(user.Id, "ClientRole");
return(true);
}
public async Task <ActionResult <UserDto> > Register(RegisterUserDto registerUserDto)
{
using var hmac = new HMACSHA512();
if (await UserExists(registerUserDto.UserName))
{
return(BadRequest("User already exists"));
}
AppUser appUser = new AppUser {
UserName = registerUserDto.UserName.ToLower(),
PasswordHash = hmac.ComputeHash(Encoding.UTF8.GetBytes(registerUserDto.Password)),
PasswordSalt = hmac.Key
};
_context.Users.Add(appUser);
await _context.SaveChangesAsync();
return(new UserDto {
UserName = registerUserDto.UserName, Token = tokenService.CreateToken(appUser)
});
}
public IHttpActionResult RegisterAdminUser([FromBody] RegisterUserDto registerUserDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(GeneralErrorMessages.MODEL_STATE_ERROR));
}
try
{
var userManager = new UserManager();
var response = userManager.CreateAdmin(registerUserDto);
if (response.Error != null)
{
return(BadRequest(response.Error));
}
return(Created("User has been created: ", registerUserDto.UserAccountDto.Username));
}
catch (Exception)
{
return(InternalServerError());
}
}
public void Post(RegisterUserDto registerUser)
{
//TODO verify facebook
//register
var user = this.unitOfWork.Users.Get(u => u.FacebookId == registerUser.FacebookId);
if (user != null)
{
//update
user.AuthToken = registerUser.AuthToken;
user.GCMClientToken = registerUser.GCMClientToken;
this.unitOfWork.Users.Update(user);
}
else
{
//register
var newUser = UserConverter.AsUser.Compile().Invoke(registerUser);
this.unitOfWork.Users.Create(newUser);
}
this.unitOfWork.SaveChanges();
}
public async Task <IActionResult> Register(RegisterUserDto registerUserDto)
{
if (!ModelState.IsValid)
{
return(View());
}
var errors = new List <String>();
await _userService.Register(registerUserDto, errors);
if (errors.Count == 0)
{
return(RedirectToAction("index", "home"));
}
foreach (var error in errors)
{
ModelState.AddModelError("", error);
}
return(View());
}
public void Execute(RegisterUserDto request)
{
_validator.ValidateAndThrow(request);
_context.Users.Add(new User
{
FirstName = request.FirstName,
LastName = request.LastName,
Username = request.Username,
Password = request.Password,
Email = request.Email,
RoleId = request.RoleId
});
_context.SaveChanges();
_sender.Send(new SendEmailDto
{
Content = "<h1>Successfull registration!</h1>",
SendTo = request.Email,
Subject = "Registration"
});
}
public async Task RegisterUser_CompanyNameIsAlreadyRegistered()
{
var dto = new RegisterUserDto();
dto.UserInfo = new RegisterUserDto.UserInfoDto
{
FirstName = "Unknown",
LastName = "Unknown",
Email = "*****@*****.**",
Username = "******",
Password = "******",
Role = "admin"
};
dto.CompanyInfo = new RegisterUserDto.CompanyInfoDto {
CompanyName = "companyName"
};
//var useCase = new RegisterUserCommand(dto);
//var request = new RegisterUserCommand.RequestHandler(context, mapper);
//await request.Handle(useCase, new CancellationToken());
}
public async Task <AuthTokenDto> RegisterAsync(RegisterUserDto registerUserDto)
{
var user = await _userRepository.GetAsync(registerUserDto.Email);
if (user is not null)
{
throw new ServiceException(ExceptionMessage.User.EmailAlreadyUsed);
}
var userId = Guid.NewGuid();
var userSalt = _encryptService.GenerateSalt();
var passwordHash = _encryptService.GetHash(registerUserDto.Password, userSalt);
user = new User(userId,
new UserIdentity
{
Email = registerUserDto.Email,
Salt = userSalt,
Password = passwordHash
});
await _userRepository.AddAsync(user);
return(_jwtService.GenerateToken(user));
}
public async Task <IActionResult> Register([FromBody] RegisterUserDto registerUserDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var newUser = new User()
{
Email = registerUserDto.Email,
RoleId = registerUserDto.RoleId,
Name = registerUserDto.Name
};
var passwordHash = _passwordHasher.HashPassword(newUser, registerUserDto.Password);
newUser.PasswordHash = passwordHash;
await _context.Users.AddAsync(newUser);
await _context.SaveChangesAsync();
return(StatusCode(StatusCodes.Status201Created));
}
public async Task <IActionResult> Register([FromBody] RegisterUserDto request)
{
if (User.Identity.IsAuthenticated)
{
return(StatusCode(StatusCodes.Status401Unauthorized));
}
if (ModelState.IsValid)
{
RegisterResponse response = new RegisterResponse();
var registrationResultUser = await this.identityService.RegisterUserAsync(request);
if (registrationResultUser != null)
{
response.Success = true;
response.Message = "Registration success";
}
return(Ok(response));
}
return(StatusCode(StatusCodes.Status400BadRequest));
}
public async Task <IActionResult> CreateUser([FromBody] RegisterUserDto userDto)
{
try
{
var user = await userService.RegisterUser(userDto);
return(Ok(user));
}
catch (Exception ex)
{
return(StatusCode(StatusCodes.Status500InternalServerError,
new ResponseDto <List <UserDto> >
{
Errors = new List <ErrorDto>
{
new ErrorDto
{
ErrorCode = 1, ErrorMessage = ex.Message
}
}
}));
}
}
public HttpResponseMessage RegisterUser(RegisterUserDto dto)
{
if (!ModelState.IsValid)
{
var errorList = (from item in ModelState.Values
from error in item.Errors
select error.ErrorMessage).ToArray();
return(new HttpResponseMessage(HttpStatusCode.BadRequest)
{
RequestMessage = Request, ReasonPhrase = JsonConvert.SerializeObject(errorList)
});
}
var resp = courierService.RegisterUser(dto);
if (resp == null)
{
return(new HttpResponseMessage(HttpStatusCode.BadRequest)
{
RequestMessage = Request, ReasonPhrase = ""
});
}
return(Request.CreateResponse(HttpStatusCode.OK, resp, "application/json"));
}
public async Task <IActionResult> Register(RegisterUserDto model)
{
var userExists = await _userManager.FindByNameAsync(model.Email);
if (userExists != null)
{
ModelState.AddModelError("UserExcisting", "User already exists!");
return(View(model));
}
if (ModelState.IsValid)
{
User user = new User()
{
Email = model.Email,
SecurityStamp = Guid.NewGuid().ToString(),
UserName = model.Email
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await _signInManager.PasswordSignInAsync(user.Email, model.Password, true, false);
await _userManager.AddToRoleAsync(user, UserRoles.User);
return(RedirectToAction("Index", "Home"));
}
else
{
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
}
return(View(model));
}
// RegisterUser <username> <password> <repeat-password> <email>
public string Execute(string[] data)
{
if (data.Length != DataLength)
{
throw new InvalidOperationException(InvalidCommandMessage);
}
string username = data[0];
string password = data[1];
string reapeatPassword = data[2];
string email = data[3];
var registerUserDto = new RegisterUserDto
{
Username = username,
Password = password,
Email = email
};
var userExist = this.userService.Exists(username);
if (userExist)
{
throw new InvalidOperationException(string.Format(RegisterUserMessages.UserIsTakenMessage, username));
}
if (password != reapeatPassword)
{
throw new ArgumentException(RegisterUserMessages.PasswordDontMatchMessage);
}
this.userService.Register(username, password, email);
string result = string.Format(RegisterUserMessages.SuccessMessage, username);
return(result);
}
public string Execute(string[] data)
{
string username = data[0];
string password = data[1];
string repeatPassword = data[2];
string email = data[3];
if (userSessionService.IsLoggedIn())
{
throw new ArgumentException("You are logged in!");
}
if (password != repeatPassword)
{
throw new ArgumentException("Passwords do not match!");
}
RegisterUserDto userDto = new RegisterUserDto {
Username = username, Password = password, Email = email
};
if (!IsValid(userDto))
{
throw new ArgumentException("Invalid user!");
}
var isUsernameExist = userService.Exists(username);
if (isUsernameExist)
{
throw new InvalidOperationException($"Username {username} is already taken!");
}
userService.Register(username, password, email);
return($"User {username} was registered successfully!");
}
public User RegisterUser(RegisterUserDto input)
{
//checkRole
var dataRole = _roles.Find(x => x.roleName == input.RoleName).FirstOrDefault();
if (dataRole == null)
{
dataRole = new Role
{
roleName = input.RoleName
};
_roles.InsertOne(dataRole);
}
//checkUser
var dataUser = _user.Find(x => x.userName == input.userName).FirstOrDefault();
if (dataUser != null)
{
throw new Exception("Username Already Exist");
}
dataUser = new User
{
userName = input.userName,
email = input.email,
phoneNumber = input.phoneNumber,
RoleId = dataRole.Id
};
dataUser.password = _passwordHasher.HashPassword(dataUser, input.password);
_user.InsertOne(dataUser);
return(dataUser);
}
public void Execute(RegisterUserDto request)
{
_validator.ValidateAndThrow(request);
_context.Users.Include(x => x.UserUseCases);
var user = _mapper.Map <User>(request);
_context.Users.Add(user);
_context.SaveChanges();
// --- OVAJ DEO ---
int[] allowedUseCases = new int[] { 3, 6, 12, 13, 17, 18, 19, 20, 21 };
//var id = 1;
foreach (var auc in allowedUseCases)
{
_context.UserUseCase.Add(new UserUseCase
{
//Id = id,
UserId = user.Id,
UseCaseId = auc
});
//id++;
}
_context.SaveChanges();
_sender.Send(new SendEmailDto
{
Subject = "Registration",
Content = "<h1>Successffully Registration</h1>",
SendTo = request.Email
});
}
// RegisterUser <username> <password> <repeat-password> <email>
public string Execute(string[] data)
{
string username = data[0];
string password = data[1];
string repeatPassword = data[2];
string email = data[3];
var registerUserDto = new RegisterUserDto
{
Username = username,
Password = password,
Email = email
};
this.userService.Register(username, password, email);
if (IsValid(registerUserDto))
{
throw new ArgumentException("Invalid data!");
}
var userExist = this.userService.Exists(username);
if (userExist)
{
throw new InvalidOperationException($"Username {username} is already taken!");
}
if (password != repeatPassword)
{
throw new ArgumentException("Password do not match!");
}
this.userService.Register(username, password, email);
return($"User {username} was registred successfully!");
}
public bool EmailAfterRegistration(RegisterUserDto registerUserDto)
{
string subject = "Top Tests Services";
string data = registerUserDto.Name;
string htmlBody = @"
<html lang=""en"">
<body style='width:720px'>
<h2>Dear " + registerUserDto.Name + @",</h2> <p style='font-family: Arial,sans-serif'>You have been registered in the online test service.
<br>
Please confirm registration and follow this link </p>
<div style='text-align:center'><a href='http://*****:*****@"' style='font-size:30px'>Change Password</a></div>
<p style='font-family: Arial,sans-serif'>We appreciate that you are with us and using service<br>Have a nice day,<br>Testex Education Platform</p>
<img src=""cid:WinLogo"" />
</body>
</html>";
string messageBody = string.Format(htmlBody, data);
AlternateView alternateViewHtml = AlternateView.CreateAlternateViewFromString(htmlBody, Encoding.UTF8, MediaTypeNames.Text.Html);
MailMessage mailMessage = new MailMessage("*****@*****.**", registerUserDto.Email, subject, messageBody);
mailMessage.AlternateViews.Add(alternateViewHtml);
using (SmtpClient smpt = new SmtpClient("smtp.gmail.com", 587))
{
smpt.EnableSsl = true;
smpt.DeliveryMethod = SmtpDeliveryMethod.Network;
smpt.UseDefaultCredentials = false;
smpt.Credentials = new NetworkCredential("*****@*****.**", "basket2009");
MailMessage message = new MailMessage();
message.To.Add(registerUserDto.Email);
message.From = new MailAddress("*****@*****.**");
message.DeliveryNotificationOptions = DeliveryNotificationOptions.OnFailure;
message.Subject = "Top Tests";
message.Body = "Something";
smpt.Send(mailMessage);
}
return(true);
}
public async Task <UserDto> RegisterAsync(RegisterUserDto newUser)
{
if (newUser == null)
{
throw new ArgumentNullException(nameof(newUser), "newUser cannot be null");
}
var user = _mapper.Map <User>(newUser);
var isCurrentUser = await _context.Users.AnyAsync(u => u.Email == user.Email);
if (isCurrentUser)
{
throw new UserExistsException();
}
await _context.Users.AddAsync(user);
await _unitOfWork.CompleteAsync();
var userDto = _mapper.Map <UserDto>(user);
return(userDto);
}
public IActionResult Register([FromBody] RegisterUserDto user)
{
string errCode = "01";
// check email
if (!credentialSrvice.CheckEmail(user.Email))
{
return(new Response(HttpStatusCode.Conflict,
new Error[] { new Error {
Code = ErrorCode + errCode + "01",
Detail = "This email has already been taken."
} }).ToActionResult());
}
credentialSrvice.AddUserByUserInfo(user);
var payload = new
{
email = user.Email,
password = user.Password
};
return(new Response(HttpStatusCode.Accepted, payload).ToActionResult());
}
public ActionResult Register([FromBody] RegisterUserDto registerUserDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var newUser = new User()
{
Email = registerUserDto.Email,
DateOfBirth = registerUserDto.DateOfBirth,
Nationality = registerUserDto.Nationality,
RoleId = registerUserDto.RoleId
};
// Hashed Password is presented for specified user
var passwordHash = _passwordHasher.HashPassword(newUser, registerUserDto.Password);
newUser.PasswordHash = passwordHash;
_meetupContext.Users.Add(newUser);
_meetupContext.SaveChanges();
return(Ok());
}
public IDataResult <User> Register(RegisterUserDto registerUserDto)
{
var validator = new UserValidator();
var validateResult = validator.Validate(registerUserDto);
if (!validateResult.IsValid)
{
var validationErros = ValidationHelper.GetErrors(validateResult.Errors);
return(new ErrorDataResult <User>("Kullanıcı oluşturma işlemi başarısız oldu.", validationErros));
}
byte[] passwordHash, passwordSalt;
HashingHelper.CreatePasswordHash(registerUserDto.Password, out passwordHash, out passwordSalt);
var user = new User()
{
Email = registerUserDto.Email,
FullName = registerUserDto.FullName,
PasswordHash = passwordHash,
PasswordSalt = passwordSalt,
Roles = "Owner"
};
return(_userDal.Add(user));
}
public async Task Register_Method_Test_CreateUserAsync_Call_Once_Return_Not_Null_Result()
{
// Arrange
var request = new RegisterUserDto();
var model = new RegisterUserViewModel()
{
Request = request
};
var returnModel = new AuthorizationResultDto()
{
IsSuccessful = true
};
_userService.Setup(f => f.CreateUserAsync(model.Request)).ReturnsAsync(returnModel);
var controller = new AccountController(_userService.Object);
// Act
var result = await controller.Register(model);
// Assert
Assert.IsNotNull(result);
_userService.Verify(f => f.CreateUserAsync(request), Times.Once);
}
public async Task RegisterUserAsync(RegisterUserDto registerUser)
{
var user = await _userManager.FindByNameAsync(registerUser.Email);
if (user != null)
{
throw new CaffStoreConflictException("User already registered");
}
user = new User
{
UserName = registerUser.Email,
Email = registerUser.Email,
FirstName = registerUser.FirstName,
LastName = registerUser.LastName,
};
var result = await _userManager.CreateAsync(user, registerUser.Password);
if (!result.Succeeded)
{
throw new CaffStoreBusinessException("Registration failed", result.Errors.Select(e => e.Description));
}
}
public async Task <IActionResult> Register([FromBody] RegisterUserDto apiRequest)
{
var request = new GetRiderRequest
{
Email = apiRequest.Email
};
var rider = new Rider
{
Email = apiRequest.Email,
UserName = apiRequest.UserName
};
var result = await _userManager.CreateAsync(rider, apiRequest.Password);
if (result != IdentityResult.Success)
{
return(BadRequest());
}
await _signInManager.SignInAsync(rider, false);
return(Ok());
}
public ActionResult ChangePassword(ChangePasswordDto dto)
{
var id = getGuid(User.Identity.GetUserId());
if (dto.wantEditpassword)
{
var u = UserManager.ChangePassword(id, dto.oldPassword, dto.newPassword);
if (u.Succeeded)
{
var user = _UserService.GetById(id);
RegisterUserDto userDto = new RegisterUserDto();
userDto.PassWordExpired = false;
var result = _UserService.Edit(userDto, id);
return(RedirectToAction("index", "Home"));
}
else
{
ViewBag.error = "حدث خطأ تأكد من كلمة المرور الخاصة بك وكون الكلمة الجديدة من 6 حروف";
return(View(dto));
}
}
_UserService.editForAdm(id, dto.fullname, dto.UserName);
return(RedirectToAction("index", "Home"));
}
// RegisterUser <username> <password> <repeat-password> <email>
public string Execute(string[] data)
{
var userDto = new RegisterUserDto()
{
Username = data[0],
Password = data[1],
RepeatPassword = data[2],
Email = data[3]
};
if (!IsValid(userDto))
{
return(InvalidDetails);
}
if (userService.Exists(userDto.Username))
{
return(String.Format(UsernameTaken, userDto.Username));
}
if (!userDto.Password.Equals(userDto.RepeatPassword))
{
return(PasswordsNotMatch);
}
try
{
userService.Register(userDto.Username, userDto.Password, userDto.Email);
}
catch (Exception ex)
{
return(ex.Message + ex.InnerException);
}
return(String.Format(SuccessMessge, userDto.Username));
}
public IHttpActionResult RegisterIndividualUser([FromBody] RegisterUserDto registerUserDto)
{
// Model Binding Validation
if (!ModelState.IsValid)
{
return(BadRequest(GeneralErrorMessages.MODEL_STATE_ERROR));
}
try
{
var userManager = new UserManager();
var response = userManager.CreateIndividualUser(registerUserDto);
if (response.Error != null)
{
return(BadRequest(response.Error));
}
// Sending HTTP response 201 Status
return(Created("Individual user has been created: ", registerUserDto.UserAccountDto.Username));
}
// Catch exceptions
catch (Exception)
{
return(InternalServerError());
}
}
