public async Task <IActionResult> RegisterUser([FromBody] UserForRegistrationDto userForRegistration)
{
//var user = _mapper.Map<User>(userForRegistration);
var user = new User
{
FirstName = userForRegistration.FirstName,
LastName = userForRegistration.LastName,
UserName = userForRegistration.UserName,
Email = userForRegistration.Email,
PhoneNumber = userForRegistration.PhoneNumber
};
var result = await _userManager.CreateAsync(user, userForRegistration.Password);
if (!result.Succeeded)
{
foreach (var error in result.Errors)
{
ModelState.TryAddModelError(error.Code, error.Description);
}
return(BadRequest(ModelState));
}
await _userManager.AddToRolesAsync(user, userForRegistration.Roles);
return(StatusCode(201));
}
public async Task <IActionResult> Register([FromBody] UserForRegistrationDto userForRegisterDto)
{
if (!string.IsNullOrEmpty(userForRegisterDto.Username))
{
userForRegisterDto.Username = userForRegisterDto.Username.ToLower();
}
if (await _repo.UserExists(userForRegisterDto.Username))
{
ModelState.AddModelError("Username", "username already exists");
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var userToCreate = new User
{
UserName = userForRegisterDto.Username
};
var createUser = await _repo.Register(userToCreate, userForRegisterDto.Password);
return(StatusCode(201));
}
public async Task <IActionResult> Register(UserForRegistrationDto userForRegistrationDto)
{
var userToCreate = _mapper.Map <User>(userForRegistrationDto);
if (await _userManager.FindByEmailAsync(userForRegistrationDto.Email) != null)
{
return(Conflict("Email aleardy exist"));
}
var createUserResult = await _userManager.CreateAsync(userToCreate, userForRegistrationDto.Password);
if (createUserResult.Succeeded)
{
if (string.IsNullOrWhiteSpace(userForRegistrationDto.RoleName))
{
userForRegistrationDto.RoleName = "Customer";
}
var addRoleToUserResult = await _userManager.AddToRoleAsync(userToCreate, userForRegistrationDto.RoleName);
if (addRoleToUserResult.Succeeded)
{
var userToReturn = _mapper.Map <UserForDetailsDto>(userToCreate);
return(CreatedAtRoute("GetUser", new { controller = "Users", userId = userToCreate.Id }, userToReturn));
}
return(BadRequest(addRoleToUserResult.Errors));
}
return(BadRequest(createUserResult.Errors));
}
private User MapUserFromReqToUser(UserForRegistrationDto userFromReq)
{
User user = new User();
user.City = userFromReq.City;
user.CountryId = userFromReq.CountryId;
user.Email = userFromReq.Email;
user.Name = userFromReq.Name;
user.Phone = userFromReq.Phone;
user.PostalCode = userFromReq.PostalCode;
user.Street = userFromReq.Street;
user.Surname = userFromReq.Surname;
user.EmailConfirmationToken = Guid.NewGuid().ToString();
user.IsActivated = false;
// var country = _context.Countries.FirstOrDefault(c => c.Id == userFromReq.CountryId);
// user.Country = country;
byte[] passwordHash, passwordSalt;
_authService.CreatePasswordHash(userFromReq.Password, out passwordHash, out passwordSalt);
user.PasswordHash = passwordHash;
user.PasswordSalt = passwordSalt;
return(user);
}
//[ServiceFilter(typeof(ValidationFilterAttribute))]
public async Task <IActionResult> RegisterUser([FromBody] UserForRegistrationDto userForRegistration)
{
var user = _mapper.Map <User>(userForRegistration);
var result = await _userManager.CreateAsync(user, userForRegistration.Password);
if (!result.Succeeded)
{
foreach (var error in result.Errors)
{
ModelState.TryAddModelError(error.Code, error.Description);
}
return(BadRequest(ModelState));
}
if (!userForRegistration.Roles.Any())
{
_logger.LogInfo("Roles doesn't exist in the registration DTO object, adding the default one.");
await _userManager.AddToRoleAsync(user, "Manager");
}
else
{
await _userManager.AddToRolesAsync(user, userForRegistration.Roles);
}
return(StatusCode(201));
}
public async Task <RegistrationResponseDto> Registration(UserForRegistrationDto newUser)
{
var result = new RegistrationResponseDto();
var user = new IdentityUser {
UserName = newUser.Email, Email = newUser.Email
};
var createResult = await _userManager.CreateAsync(user, newUser.Password);
result.IsSuccessfulRegistration = createResult.Succeeded;
if (createResult.Succeeded)
{
if (_userManager.Options.SignIn.RequireConfirmedAccount)
{
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
result.ConfirmCodeForSample = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
}
}
foreach (var error in createResult.Errors)
{
result.Errors = createResult.Errors.Select(c => c.Description).ToList();
}
return(result);
}
public async Task <IActionResult> RegisterUser([FromBody] UserForRegistrationDto userForRegistrationDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(new RegistrationResponseDto
{
Errors = ModelState.Values.SelectMany(v => v.Errors.Select(b => b.ErrorMessage))
}));
}
var isEmailFree = await _userService.IsEmailFree(userForRegistrationDto?.Email !);
if (!isEmailFree)
{
return(BadRequest(new RegistrationResponseDto
{
Errors = new string[] { "Email is linked with an existing account" }
}));
}
var user = _mapper.Map <User>(userForRegistrationDto);
user !.UserId = await _userService.GetNextId();
user.Password = BC.HashPassword(user.Password);
await _userService.CreateUser(user);
return(StatusCode(201));
}
//-------------------------------------------------------------------------------------------------
public Result Registration(UserForRegistrationDto user)
{
Result res;
if (user == null)
{
res = new Result()
{
Content = "خطایی رخ داده است", Value = false
};
}
else if (
user.FirstName == null ||
user.Email == null ||
user.LastName == null ||
user.Username == null ||
user.password == null
)
{
res = new Result()
{
Content = "یکی از فیلد های اجباری پرنشده است", Value = false
};
}
else
{
res = _repository.Registration(user);
}
return(res);
}
/// <summary>
/// Registers new user <see cref="UserForRegistrationDto"/> in the system.
/// </summary>
/// <param name="user">User for registration</param>
/// <exception cref="ArgumentNullException"></exception>
/// <exception cref="InvalidOperationException"></exception>
public void Register(UserForRegistrationDto user)
{
if (user == null)
{
throw new ArgumentNullException(nameof(user), "User to register cannot be null.");
}
var query = @"INSERT INTO [User](Id, Username, Password, Email)
VALUES(NEWID(), @name, @password, @userEmail)";
using (SqlConnection connection = new SqlConnection(_connectionString))
{
DynamicParameters parameters = new DynamicParameters();
parameters.Add("@name", user.Username);
if (user.Password != user.ConfirmPassword)
{
throw new InvalidOperationException("Confirmation password is not equal to the password.");
}
string hashedPassword = BCrypt.Net.BCrypt.HashPassword(user.Password);
parameters.Add("@password", hashedPassword);
parameters.Add("@userEmail", user.Email);
if (IsUsernameUnique(connection, user.Username) && IsEmailUnique(connection, user.Email))
{
connection.Query(query, parameters);
}
else
{
throw new InvalidOperationException("User with this username or email already exists.");
}
}
}
public async Task <IActionResult> RegisterUser([FromBody] UserForRegistrationDto userForRegistration)
{
var user = _mapper.Map <User>(userForRegistration);
var result = await _userManager.CreateAsync(user, userForRegistration.Password);
if (!result.Succeeded)
{
foreach (var error in result.Errors)
{
ModelState.TryAddModelError(error.Code, error.Description);
}
throw ProblemDetailsErrorHelper.ProblemDetailsError(ModelState);
}
//https://stackoverflow.com/questions/6855624/plus-sign-in-query-string
// we need to url encode token because token is not url safe
var token = await _userManager.GenerateEmailConfirmationTokenAsync(user);
RedirectResult redirectResult = new RedirectResult($"{_frontendConfiguration.BaseUrl}{_frontendConfiguration.AuthenticationControllerName}" +
$"{_frontendConfiguration.RegisterConfirm}?email={user.Email}&token={HttpUtility.UrlEncode(token)}");
var message = new Message(user.Email, "Register confirm", redirectResult.Url, redirectResult.Url);
await _emailSender.SendEmail(message);
return(StatusCode(201));
}
public async Task <IActionResult> Register(UserForRegistrationDto newUser)
{
newUser.Username = newUser.Username.ToLower();
var userToCreate = _mapper.Map <User>(newUser);
IdentityResult createUsrResult = await _userManager.CreateAsync(userToCreate, newUser.Password);
if (!createUsrResult.Succeeded)
{
return(BadRequest(createUsrResult.Errors));
}
IdentityResult addRoleResult = await _userManager.AddToRoleAsync(userToCreate, RoleNames.Member);
if (!addRoleResult.Succeeded)
{
return(BadRequest(addRoleResult.Errors));
}
userToCreate = await _authRepo.CreateFirstEnvironment(userToCreate);
var token = await _userManager.GenerateEmailConfirmationTokenAsync(userToCreate);
await _mailer.SendConfirmationMail(userToCreate.Id, userToCreate.Email, token, false);
var userToReturn = _mapper.Map <UserForEditDto>(userToCreate);
Response.ExposeHeader("location");
return(CreatedAtRoute(nameof(UsersController.GetUser), new { controller = "Users", id = userToReturn.Id }, userToReturn));
}
public async Task <IActionResult> RegisterUser([FromBody] UserForRegistrationDto userForRegistration)
{
if (userForRegistration == null)
{
_logger.LogError($"Object sent from client is null.");
return(BadRequest());
}
if (!ModelState.IsValid)
{
_logger.LogError($"Invalid model state for the object.");
}
var user = _mapper.Map <User>(userForRegistration);
var result = await _userManager.CreateAsync(user, userForRegistration.Password);
if (!result.Succeeded)
{
foreach (var error in result.Errors)
{
ModelState.TryAddModelError(error.Code, error.Description);
}
return(BadRequest(ModelState));
}
await _userManager.AddToRolesAsync(user, userForRegistration.Roles);
return(StatusCode(201));
}
//-------------------------------------------------------------------------------------------------
public Result Registration(UserForRegistrationDto user)
{
Result res = new Result();
var userFromDb = new UserQ().GetUser(user.Username.Trim());
if (userFromDb != null)
{
res.Value = false;
res.Content = "نام کاربری موجود است";
}
else
{
using (_db = new IdeaManagmentDatabaseEntities())
{
var newUser = new USER()
{
EMAIL = user.Email.Trim(),
FIRST_NAME = user.FirstName.Trim(),
LAST_NAME = user.LastName.Trim(),
USERNAME = user.Username.Trim(),
PASSWORD = user.password.Trim(),
SAVE_DATE = DateTime.Now
};
_db.USERS.Add(newUser);
_db.SaveChanges();
res.Value = true;
res.Content = "کاربر ایجاد شد";
}
}
return(res);
}
public async Task <IActionResult> RegisterUser([FromBody] UserForRegistrationDto userForRegistration)
{
if (userForRegistration == null || !ModelState.IsValid)
{
return(BadRequest());
}
var user = _mapper.Map <User>(userForRegistration);
var result = await _userManager.CreateAsync(user, userForRegistration.Password);
if (!result.Succeeded)
{
var errors = result.Errors.Select(e => e.Description);
return(BadRequest(new RegistrationResponseDto {
Errors = errors
}));
}
var token = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var param = new Dictionary <string, string>
{
{ "token", token },
{ "email", user.Email }
};
var callback = QueryHelpers.AddQueryString(userForRegistration.ClientURI, param);
var message = new Message(new string[] { "*****@*****.**" }, "Email Confirmation token", callback, null);
await _emailSender.SendEmailAsync(message);
await _userManager.AddToRoleAsync(user, "Viewer");
return(StatusCode(201));
}
public async Task <IActionResult> RegisterUser([FromBody] UserForRegistrationDto userForRegistration)
{
var user = _mapper.Map <User>(userForRegistration);
var result = await _userManager.CreateAsync(user, userForRegistration.Password);
if (!result.Succeeded)
{
foreach (var error in result.Errors)
{
ModelState.TryAddModelError(error.Code, error.Description);
}
return(BadRequest(ModelState));
}
var confirmationToken = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var confirmationLink = Url.Action(nameof(ConfirmEmail), "Authentication", new { confirmationToken, email = user.Email }, Request.Scheme);
var message = new Message(new string[] { user.Email }, "Account confirmation email link", confirmationLink);
await _emailSender.SendEmailAsync(message);
await _userManager.AddToRolesAsync(user, userForRegistration.Roles);
return(StatusCode(201));
}
public async Task <bool> RegisterUser(UserForRegistrationDto userForRegistration, ModelStateDictionary modelState)
{
_user = _mapper.Map <User>(userForRegistration);
var result = await _userManager.CreateAsync(_user, userForRegistration.Password);
if (userForRegistration.Password != userForRegistration.ConfirmPassword)
{
modelState.TryAddModelError("error", "Password mismatch");
return(false);
}
if (!result.Succeeded)
{
foreach (var error in result.Errors)
{
modelState.TryAddModelError(error.Code, error.Description);
}
return(false);
}
// await CreateEmailToken(user);
userForRegistration.Roles ??= new List <string> {
"User"
};
await _userManager.AddToRolesAsync(_user, userForRegistration.Roles);
return(true);
}
public async Task <IActionResult> RegisterUser([FromBody] UserForRegistrationDto input)
{
// TODO: validate input object coming from client and send appropriate response.
var user = new User
{
FirstName = input.FirstName, // Custom property
LastName = input.LastName, // Custom property
UserName = input.UserName,
Email = input.Email,
PhoneNumber = input.PhoneNumber
};
var result = await _userManager.CreateAsync(user, input.Password);
if (!result.Succeeded)
{
foreach (var error in result.Errors)
{
ModelState.TryAddModelError(error.Code, error.Description);
}
return(BadRequest(ModelState));
}
// TODO: validate role exists. If not then add user to default role.
await _userManager.AddToRolesAsync(user, input.Roles);
return(StatusCode(201));
}
public async Task <IActionResult> CreateUser([FromForm] UserForRegistrationDto userRegistrationDetails)
{
if (userRegistrationDetails == null)
{
throw new ArgumentNullException(nameof(userRegistrationDetails));
}
var result = await _userAdminSvc.CreateUserAsync(userRegistrationDetails).ConfigureAwait(false);
string message;
if (result != null)
{
message = $"User successfully created. \"Username\"={userRegistrationDetails.Username}, \"UserId\"={result.UserId}";
_logger.LogInformation(message);
Alert(message, AlertType.success);
return(RedirectToAction("Index"));
}
message =
$"An error occurred. Could not create user. \"Username\"={userRegistrationDetails.Username}";
_logger.LogError(message);
Alert(message, AlertType.danger);
return(RedirectToAction("Index"));
}
//-------------------------------------------------------------------------------------------------
public Result Registration(UserForRegistrationDto user)
{
Result res;
if (user == null)
{
res = new Result()
{
content = "خطایی رخ داده است", value = false
};
}
else if (
user.FIRST_NAME == null ||
user.EMAIL == null ||
user.LAST_NAME == null ||
user.USERNAME == null ||
user.PASSWORD == null
)
{
res = new Result()
{
content = "یکی از فیلد های اجباری پرنشده است", value = false
};
}
else
{
res = _repository.Registration(user);
}
return(res);
}
public async Task <IActionResult> RegisterUser([FromBody] UserForRegistrationDto userForRegistration)
{
var user = _mapper.Map <User>(userForRegistration);
foreach (var role in userForRegistration.Roles)
{
if (!await _roleManager.RoleExistsAsync(role))
{
return(BadRequest($"{role} role doesn't exist in the database."));
}
}
var result = await _userManager.CreateAsync(user, userForRegistration.Password);
if (!result.Succeeded)
{
foreach (var error in result.Errors)
{
ModelState.TryAddModelError(error.Code, error.Description);
}
return(BadRequest(ModelState));
}
await _userManager.AddToRolesAsync(user, userForRegistration.Roles);
return(StatusCode(201));
}
public async Task <IActionResult> RegisterUser([FromBody] UserForRegistrationDto userForRegistration)
{
if (userForRegistration == null)
{
return(BadRequest(new RegistrationResponseDto {
Errors = new[] { "Please provide user info in the body" }
}));
}
if (!ModelState.IsValid)
{
var errors = ModelState.Values.SelectMany(v => v.Errors).Select(e => e.ErrorMessage);
return(BadRequest(new RegistrationResponseDto {
Errors = errors
}));
}
var user = _mapper.Map <User>(userForRegistration);
var result = await _userManager.CreateAsync(user, userForRegistration.Password);
if (!result.Succeeded)
{
var errors = result.Errors.Select(e => e.Description);
return(BadRequest(new RegistrationResponseDto {
Errors = errors
}));
}
return(StatusCode(201));
}
public async Task <RegistrationResponseDto> RegisterUser(UserForRegistrationDto userForRegistration)
{
var content = JsonSerializer.Serialize(userForRegistration);
var bodyContent = new StringContent(content, Encoding.UTF8, _applicationJson);
HttpResponseMessage registrationResult = await _client.PostAsync("api/user/registration", bodyContent);
string registrationContent = await registrationResult.Content.ReadAsStringAsync();
var result = JsonSerializer.Deserialize <RegistrationResponseDto>(registrationContent, new JsonSerializerOptions {
PropertyNameCaseInsensitive = true
});
if (!registrationResult.IsSuccessStatusCode)
{
return(result);
}
await _localStorage.SetItemAsync("authToken", result.Token);
await _localStorage.SetItemAsync("refreshToken", result.RefreshToken);
((AuthStateProvider)_authStateProvider).NotifyUserAuthentication(result.Token);
_client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("bearer", result.Token);
return(new RegistrationResponseDto {
IsSuccessfulRegistration = true
});
}
public async Task <IActionResult> RegisterUser([FromBody] UserForRegistrationDto userForRegistrationDto)
{
var user = _mapper.Map <User>(userForRegistrationDto);
var result = await _userManager.CreateAsync(user, userForRegistrationDto.Password);
if (!result.Succeeded)
{
foreach (var error in result.Errors)
{
ModelState.TryAddModelError(error.Code, error.Description);
}
return(BadRequest(ModelState));
}
else
{
EmailService emailService = new EmailService();
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
// создаем ссылку для подтверждения
var callbackUrl = Url.Action("authentication", "api", new { userId = user.Id, code = code },
protocol: Request.Scheme);
// отправка письма
await emailService.SendEmailAsync(user.Email, "Подтверждение электронной почты",
"Для завершения регистрации перейдите по ссылке:: <a href=\""
+ callbackUrl + "\">завершить регистрацию</a>");
}
await _userManager.AddToRolesAsync(user, userForRegistrationDto.Roles);
return(StatusCode(201));
}
public async Task <IActionResult> Createuser([FromBody] UserForRegistrationDto model)
{
var result = await _userManager.CreateAsync(
new ApplicationUser()
{
UserName = model.UserName,
DisplayName = model.DisplayName,
Created = DateTime.Now,
IsDeleted = false
}, model.Password
);
if (result.Succeeded)
{
var user = _userManager.FindByNameAsync(model.UserName).Result;
var selectedRoles = model.Roles;
selectedRoles = selectedRoles ?? new string[] { };
result = _userManager.AddToRolesAsync(user, selectedRoles).Result;
if (result.Succeeded)
{
return(Ok());
}
return(BadRequest("Failed to add roles"));
}
return(BadRequest("Failed to register user"));
}
public async Task <IActionResult> Register(UserForRegistrationDto userForRegistration)
{
await _authValidatorService.ValidateForRegistration(userForRegistration);
await _authService.Register(userForRegistration);
return(Ok());
}
public async Task <IActionResult> Registration([FromBody] UserForRegistrationDto userForRegistration)
{
if (await _userService.RegisterUser(userForRegistration, ModelState))
{
return(StatusCode(201));
}
return(BadRequest(ModelState));
}
public async Task <IActionResult> UpdateUser([FromForm] UserForRegistrationDto user)
{
if (Request.Form.Files.Count != 0)
{
user.SelecetdFile = Request.Form.Files[0];
}
else
{
user.SelecetdFile = null;
}
if (user.SelecetdFile != null)
{
var folderName = Path.Combine("wwwroot", "Images");
var pathToSave = Path.Combine(Directory.GetCurrentDirectory(), folderName);
if (user.SelecetdFile.Length > 0)
{
var objfiles = new DTOProductImage();
var fullPath = Path.Combine(pathToSave, user.SelecetdFile.FileName);
var dbPath = Path.Combine("Images", user.SelecetdFile.FileName);
using (var stream = new FileStream(fullPath, FileMode.Create))
{
user.SelecetdFile.CopyTo(stream);
}
using (var target = new MemoryStream())
{
user.SelecetdFile.CopyTo(target);
objfiles.Image = target.ToArray();
}
user.ProductImage = objfiles;
user.ProductImage.ImagePath = dbPath;
}
}
try
{
bool success = await _service.UpdateUser(user);
if (success)
{
return(Ok());
}
else
{
return(NotFound());
}
}
catch
{
return(NotFound());
}
}
public void CreateUserAsync_UserForRegistrationDtoValid_ReturnsUserFullDetailsDto()
{
var mockDal = Substitute.For <IUserDal>();
var mockLogger = Substitute.For <ILogger <UserAdministrationService> >();
var mockCryptoSvc = Substitute.For <ICryptographyService>();
var adminSvc = new UserAdministrationService(mockLogger, mockDal, mockCryptoSvc);
var mockRegistration = new UserForRegistrationDto()
{
Title = Title.Miss,
FirstName = "Aoife",
LastName = "McGonagle",
Username = "******",
Password = "******",
ConfirmPassword = "******",
JobDescription = "Head Honcho",
Role = UserRole.MedicalPractitioner,
State = AccountState.Active
};
var mockJobDescription = new JobDescription()
{
Description = "Head Honcho",
Role = UserRole.MedicalPractitioner
};
var mockEmployeeDetails = new Employee()
{
Firstname = "Aoife",
Lastname = "McGonagle",
Title = Title.Miss,
};
var mockUser = new User()
{
EmployeeDetails = mockEmployeeDetails,
Username = "******",
JobDescription = mockJobDescription,
State = AccountState.Active
};
mockDal.AddAsync(Arg.Any <User>()).Returns(mockUser);
var result = adminSvc.CreateUserAsync(mockRegistration).GetAwaiter().GetResult();
Assert.That(result, Is.Not.Null);
Assert.That(result.Title, Is.EqualTo(Title.Miss));
Assert.That(result.Firstname, Is.EqualTo("Aoife"));
Assert.That(result.Lastname, Is.EqualTo("McGonagle"));
Assert.That(result.Username, Is.EqualTo("amcg"));
Assert.That(result.JobDescription, Is.EqualTo("Head Honcho"));
Assert.That(result.Role, Is.EqualTo(UserRole.MedicalPractitioner));
Assert.That(result.State, Is.EqualTo(AccountState.Active));
}
public async Task <IActionResult> CreateUser(UserForRegistrationDto userForRegistrationDto)
{
var userToCreate = new User
{
Name = userForRegistrationDto.Name
};
var createdUser = await _userRepository.CreateUserAsync(userToCreate);
return(Ok());
}
public async System.Threading.Tasks.Task <IdentityResult> AddUserAsync(UserForRegistrationDto userForRegistration)
{
var user = _mapper.Map <User>(userForRegistration);
var result = await _userManager.CreateAsync(user, userForRegistration.Password);
if (result.Succeeded)
{
await _userManager.AddToRoleAsync(user, "Developer");
}
return(result);
}
