public async Task <IActionResult> Registration(RegistrationUserDTO user)
{
var result = await _userService.CreateUserAsync(user);
if (result.IsSuccess)
{
var code = await _userService.GenerateEmailConfirmationTokenAsync(user.Email);
var callbackUrl = Url.Action(
"confirmemail",
"authentication",
new { email = user.Email, code },
protocol: HttpContext.Request.Scheme);
var isEmailSend = await _emailService.SendEmailAsync(user.Email, "Confirm your account",
$"<p>Hello, {user.FirstName}!</p> <p>Confirm registration by clicking on the link: <a href='{callbackUrl}'>BloglullabyApi</a> </p><p>Sincerely, BlogLullaby website administration.</p>", $"{user.FirstName} {user.LastName}");
if (!isEmailSend)
{
return(BadRequest(new string[] { "Confirm token not send to email, but u can sign in." }));
}
var response = new
{
username = user.Email,
password = user.Password
};
return(Ok(response));
}
else
{
return(BadRequest(result.Descriptions));
}
}
public async Task <OperationDetails> CreateUserAsync(RegistrationUserDTO userDTO)
{
if (!userDTO.IsValid())
{
return(userDTO.GetValidateError());
}
var dbUser = await dataStore.UserProfiles.GetByNameAsync(userDTO.UserName);
if (dbUser != null)
{
return(new OperationDetails(false, new string[] { "This username used yet." }));
}
var applicationUser = userDTO.GetApplicationUser();
var result = await userManager.Create(applicationUser, userDTO.Password);
if (!result.IsSuccess)
{
return(new OperationDetails(false, result.ErrorList.Select(x => x.Description)));
}
var userProfile = userDTO.GetUserProfile();
userProfile.IdentityUserId = (await userManager.GetUserByEmailAsync(applicationUser.Email)).Id;
var createdProfile = await dataStore.UserProfiles.CreateAsync(userProfile);
if (createdProfile == null)
{
var errorUser = await userManager.GetUserByEmailAsync(applicationUser.Username);
var res = await userManager.DeleteUserAsync(errorUser);
return(new OperationDetails(false, new string[] { "Some error, try another data." }));
}
return(new OperationDetails(true));
}
public async Task <IActionResult> Register([FromBody] RegistrationUserDTO registration)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = await _userManager.FindByEmailAsync(registration.Email);
//if (registration.Email.Contains("admin"))
//{
// await _userManager.AddToRoleAsync(user, "Admin");
//}
if (user != null)
{
SerializableError serializableError = new SerializableError {
{ nameof(registration.Email), "Email already exist in the system" }
};
return(this.StatusCode((int)HttpStatusCode.Conflict, serializableError));
}
User newUser = new User
{
Email = registration.Email,
UserName = registration.Email,
Id = registration.Email
};
var result = await _userManager.CreateAsync(newUser, registration.Password);
if (!result.Succeeded)
{
foreach (var error in result.Errors)
{
ModelState.AddModelError(error.Code, error.Description);
}
return(BadRequest(ModelState));
}
user = await _userManager.FindByEmailAsync(registration.Email);
await _userManager.AddClaimAsync(user, new Claim("registration-date", DateTime.UtcNow.ToString("yy-MM-dd")));
return(Ok());
}
private CreditPrivateData GetPrivateCreditData(RegistrationUserDTO registrationUser)
{
var privateSummaryRating = this.scoreService.CalculatePrivateSummaryRating(registrationUser.NumberOfRegistratins);
var privateData = this.mapper.Map <PrivateData>(registrationUser);
var result = new CreditPrivateData
{
Registration = registrationUser.RegistrationNumber,
RatingData = new Rating {
RegistrationNumber = registrationUser.RegistrationNumber, SummaryRating = privateSummaryRating
},
PrivateData = privateData,
Recommendation = this.scoreService.MakeGeneralRecommendation(privateSummaryRating),
DebtCollectionRecommendation = this.scoreService.MakeDebtCollectionRecommendation(privateSummaryRating, CompanyType.Personal)
};
return(result);
}
public void Register(RegistrationUserDTO user, string password)//User u, string password)
{
var u = Mapper.Map <User>(user);
string salt = GenerateSalt(64);
string hash = GenerateHash(password, salt);
u.Salt = salt;
u.PassHash = hash;
Folder privateFolder = CreateRootFolder(u);
_users.Add(u);
_folders.Add(privateFolder);
_roles.AddRoleToUser(Role.Default, u);
_users.SaveChanges();
_folders.SaveChanges();
_roles.SaveChanges();
}
public async Task <ActionResult <RegistrationResponseDTO> > Register(RegistrationUserDTO registrationUserDTO)
{
try
{
var userEntity = _mapper.Map <UserEntity>(registrationUserDTO);
await _addableUser.AddAsync(userEntity);
var registrationResponseDTO = _mapper.Map <RegistrationResponseDTO>(userEntity);
var token = _jwtSystem.GenerateToken(userEntity);
registrationResponseDTO.Token = token;
return(Ok(registrationResponseDTO));
}
catch (InvalidFileFormatException ex)
{
return(BadRequest(ex.Message));
}
catch (ObjectAlreadyExistException ex)
{
return(BadRequest(ex.Message));
}
}
public async Task <IActionResult> RegistrationUser([FromBody] RegistrationUserDTO model, string storeId)
{
_logger.Log(LogLevel.Information, "call registration/{@storeId}", storeId);
await CheckIsSignoutedAsync();
string messager = string.Empty;
if (ModelState.IsValid)
{
// check store exist and open
Store store = await _context.Stores.FindAsync(storeId);
if (store == null)
{
messager = "Không tìm thấy cửa hàng hoặc cửa hàng đã đóng.";
_logger.Log(LogLevel.Information, messager);
throw new ApiException(messager, (int)HttpStatusCode.BadRequest);
}
// get role
Role role = await _context.Roles.FindAsync(storeId);
if (role == null)
{
messager = "Không tìm thấy role.";
_logger.Log(LogLevel.Information, messager);
throw new ApiException(messager, (int)HttpStatusCode.BadRequest);
}
// init user
var hashPass = Helpers.SercurityHelper.GenerateSaltedHash(model.Password);
User user = new User
{
Id = Guid.NewGuid().ToString(),
Age = model.Age,
Email = model.Email,
FirstName = model.FirstName,
LastName = model.LastName,
PhoneNumber = model.PhoneNumber,
UserName = model.Username,
StoreId = store.Id,
Gender = model.Gender,
IsActived = (int)TypeVerified.Verified,
HashPassword = hashPass.Hash,
SaltPassword = hashPass.Salt
};
// Add user to Role
UserToRole userToRole = new UserToRole();
userToRole.Role = role;
userToRole.User = user;
role.UserToRoles.Add(userToRole);
// save user create to database
try
{
_context.Roles.Add(role);
_context.Users.Add(user);
await _context.SaveChangesAsync();
messager = $"Đã khởi tạo nhân viên {role.Desc}: {user.FirstName} {user.LastName} cho cửa hàng của bạn.";
}
catch (Exception ex)
{
_logger.Log(LogLevel.Warning, $"Log when RegistrationUser {ex.Message}");
#if !DEBUG
throw new ApiException($"Có lỗi xảy ra khi đăng ký {user.FirstName}", (int)HttpStatusCode.BadRequest);
#else
throw new ApiException(ex, (int)HttpStatusCode.BadRequest);
#endif
}
}
_logger.Log(LogLevel.Information, messager);
return(Ok(new { data = messager }));
}
