// [Route("RegisterUser")]
public async Task <IActionResult> Post(UserRegistrationRequestDto request)
{
ServiceResponse result = null;
try
{
result = await _registrationService.UserRegistration(request);
return(Ok(result));
}
catch (BadRequestException brEx)
{
result = new ServiceResponse {
Msg = brEx.Message, Success = false
};
return(BadRequest(result));
}
catch (NotFoundException nfEx)
{
result = new ServiceResponse {
Msg = nfEx.Message, Success = false
};
return(NotFound(result));
}
catch (Exception ex)
{
return(HandleError(ex, MethodBase.GetCurrentMethod()?.Name));
}
}
public async Task <IActionResult> Register([FromBody] UserRegistrationRequestDto user)
{
// Check if the incoming request is valid
if (ModelState.IsValid)
{
// check i the user with the same email exist
var existingUser = await _userManager.FindByEmailAsync(user.Email);
if (existingUser != null)
{
return(BadRequest(new RegistrationResponse()
{
Result = false,
Errors = new List <string>()
{
"Email already exist"
}
}));
}
var newUser = new IdentityUser()
{
Email = user.Email, UserName = user.Email
};
var isCreated = await _userManager.CreateAsync(newUser, user.Password);
if (isCreated.Succeeded)
{
var jwtToken = GenerateJwtToken(newUser);
return(Ok(new RegistrationResponse()
{
User = newUser,
Result = true,
Token = jwtToken
}));
}
return(new JsonResult(new RegistrationResponse()
{
Result = false,
Errors = isCreated.Errors.Select(x => x.Description).ToList()
}
)
{
StatusCode = 500
});
}
return(BadRequest(new RegistrationResponse()
{
Result = false,
Errors = new List <string>()
{
"Invalid payload"
}
}));
}
public async Task <IActionResult> CreateUser([FromBody] UserRegistrationRequestDto registrationRequest, CancellationToken cancellationToken)
{
var currentUserName = User.FindFirst(ClaimTypes.NameIdentifier).Value;
await _authenticationService
.CreateUserAsync(currentUserName, _mapper.Map <UserRegistrationRequest>(registrationRequest));
return(Created("", registrationRequest.Username));
}
public DataResult <User> Register(UserRegistrationRequestDto registrationRequest)
{
UnitOfWork.Begin();
var result = _authenticationWorkflow.Register(registrationRequest);
UnitOfWork.End();
return(result);
}
public async Task <ActionResult <UserRegistrationResponseDto> > Registration(
[FromBody] UserRegistrationRequestDto requestDto,
[FromHeader(Name = "User-Agent")] string userAgent,
[FromHeader(Name = "X-Application-Version")]
string appVersion
)
{
requestDto.UserAgent = userAgent;
requestDto.AppVersion = appVersion;
return(await ProcessResultAsync(() => _authenticationService.Register(requestDto)));
}
/// <summary>
/// User registration
/// </summary>
/// <param name="requestDto" class="UserRegistrationResponseDto">UserRegistrationResponseDto</param>
/// <returns></returns>
public async Task <Result <UserRegistrationResponseDto> > Register(
UserRegistrationRequestDto requestDto)
{
var userEmailExists = await _userRepository.GetByEmail(requestDto.Email);
if (userEmailExists != null)
{
return(Result <UserRegistrationResponseDto> .FromIError(new ApiError(ErrorCodes.UserEmailExists, nameof(requestDto.Email))));
}
var userPhoneExists = await _userRepository.GetByPhone(requestDto.Phone);
if (userPhoneExists != null)
{
return(Result <UserRegistrationResponseDto> .FromIError(new ApiError(ErrorCodes.UserEmailExists, nameof(requestDto.Phone))));
}
using var scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled);
var res = await _userRepository.Create(new UserModel
{
NameFirst = requestDto.NameFirst,
NameSecond = requestDto.NameSecond,
NamePatronymic = requestDto.NamePatronymic,
Password = _cryptoHelper.GetHash(requestDto.Password),
Phone = requestDto.Phone,
Email = requestDto.Email.ToLower()
}
);
var sessionId = Guid.NewGuid();
var token = _tokenService.GenerateToken(res.Id, sessionId, _secretKey);
await _tokenRepository.Create(new TokenModel
{
Id = sessionId,
UserAgent = requestDto.UserAgent,
Token = token,
UserId = res.Id,
AppVersion = requestDto.AppVersion
}
);
scope.Complete();
return(new Result <UserRegistrationResponseDto>(
new UserRegistrationResponseDto
{
Id = res.Id,
AuthToken = token
}
));
}
public async Task <ActionResult> Registration([FromBody] UserRegistrationRequestDto requestDto)
{
requestDto.UserAgent = Request.Headers["User-Agent"].ToString();
requestDto.AppVersion = Request.Headers["X-Application-Version"].ToString();
var result = await _authenticateService.Registration(requestDto);
if (result.Error != null)
{
var error = result.Error ?? ErrorCodes.NotFound;
BadRequest(error, result.ErrorField);
}
return(Ok(result));
}
public DataResult <User> Register(UserRegistrationRequestDto registrationRequest)
{
if (!registrationRequest.Password.Equals(registrationRequest.PasswordConfirmation))
{
return(new DataResult <User>(DataResultType.ValidationError,
"The password and confirmation password must be the same."));
}
var saltBytes = new byte[128];
new RNGCryptoServiceProvider().GetBytes(saltBytes);
var systemLogin = new SystemLogin
{
CreatedDate = DateTime.Now,
EmailAddress = registrationRequest.EmailAddress,
PasswordHash = Convert.ToBase64String(GetSaltedHash(registrationRequest.Password, saltBytes)),
PasswordSalt = Convert.ToBase64String(saltBytes),
EmailConfirmationToken = registrationRequest.ConfirmationToken,
IsEmailConfirmed = false
};
_databaseContext.SystemLogins.Add(systemLogin);
_databaseContext.SaveChanges();
if (systemLogin.SystemLoginId == 0)
{
return(new DataResult <User>(DataResultType.UnableToCreateRecord, "Unable to create system login"));
}
var user = new User
{
CreatedDate = DateTime.Now,
SystemLoginId = systemLogin.SystemLoginId,
FirstName = registrationRequest.FirstName,
Surname = registrationRequest.Surname,
DateOfBirth = registrationRequest.DateOfBirth,
SystemRoleId = (int)SystemRoles.Unknown,
BranchId = 1
};
_databaseContext.Users.Add(user);
_databaseContext.SaveChanges();
if (user.UserId == 0)
{
return(new DataResult <User>(DataResultType.UnableToCreateRecord, "Unable to create user"));
}
return(new DataResult <User>(user, new DataResult(DataResultType.Success, "Successfully created user")));
}
public async Task <IActionResult> Register([FromBody] UserRegistrationRequestDto user)
{
if (ModelState.IsValid)
{
var existingUser = await _userManager.FindByEmailAsync(user.Email);
if (existingUser != null)
{
return(BadRequest(new RegistrationResponse
{
Success = false,
Errors = new List <string>()
{
"Email already exist"
}
}));
}
var newUser = new IdentityUser(user.Email)
{
Email = user.Email
};
var isCreated = await _userManager.CreateAsync(newUser, user.Password);
if (isCreated.Succeeded)
{
return(Ok(await GenerateJwtAsync(newUser)));
}
return(new JsonResult(new RegistrationResponse()
{
Success = false,
Errors = isCreated.Errors.Select(x => x.Description).ToList()
})
{
StatusCode = 500
});
}
return(BadRequest(new RegistrationResponse()
{
Success = false,
Errors = new List <string>()
{
"Invalid payload"
}
}));
}
public async Task <ServiceResponse> UserRegistration(UserRegistrationRequestDto request)
{
var response = new ServiceResponse {
ErrorList = new List <ErrorMessage>()
};
request.FirstName = request.FirstName?.TitleCase();
request.LastName = request.LastName?.TitleCase();
request.UserName = request.UserName?.LowerCase();
request.Password = _encryptData.EncryptPassword(request.Password);
request.UserEmail = request.UserEmail?.LowerCase();
request.Remarks = request.Remarks?.TitleCase();
request.Active = true;
var user = _mapper.Map <IM_USERS>(request);
// to fix an issue related to claims generation during login
if (string.IsNullOrEmpty(user.LASTNAME))
{
user.LASTNAME = "";
}
user.CreatedBy = "SYSTEM";
user.CreatedDate = DateTime.Now;
user.ID = Guid.NewGuid().ToString();
_transactionalUnitOfWork.SetIsActive(false);
await _transactionalUnitOfWork.CommitAsync();
_userRepository.Add(user);
var contributorGroup = await _groupsRepository.GetReadOnlyAsync(x => x.NAME == "CONTRIBUTORS");
if (contributorGroup == null)
{
throw new BadRequestException("Unable to assign access to user");
}
var addUserGroup = new IM_USERS_GROUPS
{
ID = Guid.NewGuid().ToString(),
CreatedBy = "ADMIN",
CreatedDate = DateTime.Now,
GROUP_ID = contributorGroup.ID,
ACTIVE = true,
USER_NAME = user.USERNAME
};
_transactionalUnitOfWork.SetIsActive(true);
_usersGroupsRepository.Add(addUserGroup);
var committedRows = await _transactionalUnitOfWork.CommitAsync();
if (committedRows > 0)
{
response.Success = true;
response.Msg = "User registered successfully";
}
else
{
response.Success = false;
response.Msg = "Failed to register user";
}
var recipients = new List <EmailRecipientDto>
{
new EmailRecipientDto
{
RecipientName = $"{user.FIRSTNAME} {user.LASTNAME}",
RecipientEmailAddress = user.USEREMAIL
}
};
var newUserRegistrationEmailTemplate =
await _templateSettingRepository.GetReadOnlyAsync(x => x.KEY == "NEW_USER_TEMPLATE");
if (newUserRegistrationEmailTemplate != null)
{
var emailTemplateString = newUserRegistrationEmailTemplate.VALUE;
if (!string.IsNullOrEmpty(emailTemplateString))
{
var emailHtmlBody = emailTemplateString.Replace("{username}", $"{user.FIRSTNAME} {user.LASTNAME}")
// TODO: get application ui url from appsettings
.Replace("{link}", "https://www.google.com");
await EmailNotificationHelper.SendEmailNotification(_configuration.GetSection("SendGridAPIKey").Value,
newUserRegistrationEmailTemplate.NAME, emailHtmlBody, "", recipients);
}
}
return(await Task.Run(() => response));
}
public async Task <IdentityResult> RegisterAsync(UserRegistrationRequestDto userRegistrationDto)
{
var user = _mapper.Map <ApplicationUser>(userRegistrationDto);
return(await _userManager.CreateAsync(user, userRegistrationDto?.Password).ConfigureAwait(false));
}
public async Task <IActionResult> Register([FromBody] UserRegistrationRequestDto registrationDto)
{
// Check the model or obj is valid
if (ModelState.IsValid)
{
// Check email existing
var existingUser = await _userManager.FindByEmailAsync(registrationDto.Email);
if (existingUser is not null)
{
return(BadRequest(
new UserRegistrationResponseDto()
{
Success = false,
Errors = new List <string>()
{
"Email already in use"
}
}
));
}
// Add the user
var newUser = new IdentityUser()
{
Email = registrationDto.Email,
UserName = registrationDto.Email,
EmailConfirmed = true // Todo: send user to confirm email
};
// Add user to database
var isCreated = await _userManager.CreateAsync(newUser, registrationDto.Password);
if (!isCreated.Succeeded)
{
return(BadRequest(
new UserRegistrationResponseDto()
{
Success = false,
Errors = isCreated.Errors.Select(x => x.Description).ToList()
}
));
}
// Add Khach hang to db
var _khachHang = new Customer();
_khachHang.CustomerId = 1;
_khachHang.CustomerName = registrationDto.TenKhachHang;
_khachHang.Email = registrationDto.Email;
await _context.Customers.AddAsync(_khachHang);
await _context.SaveChangesAsync();
//Create Roles
if (!await _roleManager.RoleExistsAsync(RoleConstants.Admin))
{
await _roleManager.CreateAsync(new IdentityRole(RoleConstants.Admin));
}
if (!await _roleManager.RoleExistsAsync(RoleConstants.Khach))
{
await _roleManager.CreateAsync(new IdentityRole(RoleConstants.Khach));
}
if (!await _roleManager.RoleExistsAsync(RoleConstants.TaiXe))
{
await _roleManager.CreateAsync(new IdentityRole(RoleConstants.TaiXe));
}
if (!await _roleManager.RoleExistsAsync(RoleConstants.CuaHang))
{
await _roleManager.CreateAsync(new IdentityRole(RoleConstants.CuaHang));
}
if (await _roleManager.RoleExistsAsync(RoleConstants.Khach))
{
await _userManager.AddToRoleAsync(newUser, RoleConstants.Khach);
}
// Create a jwt token
var userRoles = await _userManager.GetRolesAsync(newUser);
var token = GenerateJwtToken(newUser, userRoles);
// return the new user
return(Ok(new UserRegistrationResponseDto()
{
Success = true,
Token = token
}
));
}
else
{
return(BadRequest(
new UserRegistrationResponseDto
{
Success = false,
Errors = new List <string>()
{
"Invalid payload"
}
}
));
}
}
public async Task <UserRegistrationResponseDto> Registration(UserRegistrationRequestDto requestDto)
{
var userEmailExists = await _userRepository.GetByEmail(requestDto.Email);
if (userEmailExists != null)
{
return(new UserRegistrationResponseDto
{
Error = ErrorCodes.UserEmailExists,
ErrorField = new List <string> {
nameof(requestDto.Email)
}
});
}
var userPhoneExists = await _userRepository.GetByPhone(requestDto.Phone);
if (userPhoneExists != null)
{
return(new UserRegistrationResponseDto
{
Error = ErrorCodes.UserPhoneExists,
ErrorField = new List <string> {
nameof(requestDto.Phone)
}
});
}
try
{
using var scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled);
var res = await _userRepository.Create(new UserModel
{
NameFirst = requestDto.NameFirst,
NameSecond = requestDto.NameSecond,
NamePatronymic = requestDto.NamePatronymic,
Password = _cryptoHelper.GetHash(requestDto.Password),
Phone = requestDto.Phone,
Email = requestDto.Email.ToLower()
}
);
var sessionId = Guid.NewGuid();
var token = _tokenService.GenerateToken(res.Id, sessionId, _secretKey);
await _tokenRepository.Create(new TokenModel
{
Id = sessionId,
UserAgent = requestDto.UserAgent,
Token = token,
UserId = res.Id,
AppVersion = requestDto.AppVersion
}
);
scope.Complete();
return(new UserRegistrationResponseDto
{
Id = res.Id,
AuthToken = token
});
}
catch (Exception e)
{
return(new UserRegistrationResponseDto
{
Error = ErrorCodes.ServerError
});
//TODO логирование
}
}
public async Task <IActionResult> Register([FromBody] UserRegistrationRequestDto user)
{
// Check if the incoming request is valid
if (ModelState.IsValid)
{
// check if the user with the same username exist
var existingUser = await _userManager.FindByNameAsync(user.UserName);
if (existingUser != null)
{
return(BadRequest(new RegistrationResponse()
{
Success = false,
Errors = new List <string>()
{
"Username already exist"
}
}));
}
var newUser = new ApplicationUser()
{
UserName = user.UserName,
FirstName = user.FirstName,
LastName = user.LastName,
Address = user.Address,
TRN = user.TRN,
Role = user.Role,
PhoneNumber = user.PhoneNumber,
Email = user.Email
};
var isCreated = await _userManager.CreateAsync(newUser, user.Password);
if (isCreated.Succeeded)
{
var isAddToRole = await _userManager.AddToRoleAsync(newUser, user.Role);
if (isAddToRole.Succeeded)
{
return(Ok());
}
}
return(new JsonResult(new RegistrationResponse()
{
Success = false,
Errors = isCreated.Errors.Select(x => x.Description).ToList()
}
)
{
StatusCode = 500
});
}
return(BadRequest(new RegistrationResponse()
{
Success = false,
Errors = new List <string>()
{
"Invalid payload"
}
}));
}
