public async Task <IActionResult> Post([FromBody] UserAddViewModel model)
{
string id = null;
if (!ModelState.IsValid)
{
var errors = CustomValidator.GetErrorsByModel(ModelState);
return(BadRequest(errors));
}
var user = new DbUser()
{
UserName = model.Email, Email = model.Email
};
IdentityResult result = await _userManager.CreateAsync(user, model.Password);
if (!result.Succeeded)
{
var errors = CustomValidator.GetErrorsByIdentityResult(result);
return(BadRequest(errors));
}
string code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var callbackUrl = Url.Action(
"",
"resetpassword",
//pageHandler: null,
values: new { userId = user.Id, code = code },
protocol: Request.Scheme);
await _emailSender.SendEmailAsync(model.Email, "Reset Password",
$"Please reset your password by clicking here: <a href='{callbackUrl}'>link</a>");
return(Ok(new { answer = "Check your email" }));
//return Ok("S***N");
}
public async Task <IActionResult> Register([FromBody] CustomRegisterModel model)
{
if (!ModelState.IsValid)
{
var errors = CustomValidator.GetErrorsByModel(ModelState);
return(BadRequest(errors));
}
var user = new DbUser
{
UserName = model.Email,
Email = model.Email
};
var result = await _userManager
.CreateAsync(user, model.Password);
if (!result.Succeeded)
{
var errors = CustomValidator.GetErrorsByIdentityResult(result);
return(BadRequest(errors));
}
var roleName = "User";
var roleresult = _roleManager.CreateAsync(new DbRole
{
Name = roleName
}).Result;
result = _userManager.AddToRoleAsync(user, roleName).Result;
_userService.AddUserProfile(user.Id, model);
await _signInManager.SignInAsync(user, isPersistent : false);
return(Ok(CreateToken(user)));
}
public async Task <IActionResult> ResetPassword([FromBody] ResetPasswordViewModel model)
{
if (!ModelState.IsValid)
{
var errrors = CustomValidator.GetErrorsByModel(ModelState);
return(BadRequest(errrors));
}
var user = await _userManager.FindByIdAsync(model.UserId);
if (user == null)
{
return(BadRequest(new { invalid = "User is not found" }));
}
var result = await _userManager.ResetPasswordAsync(user, model.Code, model.Password);
if (!result.Succeeded)
{
var errrors = CustomValidator.GetErrorsByIdentityResult(result);
return(BadRequest(errrors));
}
return(Ok());
}
public async Task <ResultDto> ConfirmEmail(string userid, ConfirmEmailDto model)
{
var dictionaryResult = new Dictionary <string, string>();
var user = await _userManager.FindByIdAsync(userid);
if (user == null)
{
dictionaryResult.Add("user", "User is not found");
return(new ResultDto
{
IsSuccessful = false,
collectionResult = dictionaryResult,
});
}
var result = await _userManager.ConfirmEmailAsync(user, model.Code);
if (!result.Succeeded)
{
var errrors = CustomValidator.GetErrorsByIdentityResult(result);
return(new ResultDto
{
IsSuccessful = false,
collectionResult = errrors,
});
}
return(new ResultDto
{
IsSuccessful = true
});
}
public async Task <IActionResult> Google([FromBody] GoogleAuthViewModel model)
{
var userInfo = GoogleJsonWebSignature.ValidateAsync(model.TokenId, new GoogleJsonWebSignature.ValidationSettings()).Result;
var user = await _userManager.FindByEmailAsync(userInfo.Email);
if (user == null)
{
string path = _fileService.UploadAccountImage(userInfo.Picture);
user = new DbUser
{
FirstName = userInfo.GivenName,
LastName = userInfo.FamilyName,
Email = userInfo.Email,
UserName = userInfo.Email,
SignUpTime = DateTime.Now,
AvatarUrl = path
};
var result = await _userManager.CreateAsync(user, RandomPasswordGenerator.GenerateRandomPassword());
if (!result.Succeeded)
{
var errors = CustomValidator.GetErrorsByIdentityResult(result);
return(BadRequest(errors));
}
var roleName = "User";
var roleresult = _roleManager.CreateAsync(new DbRole
{
Name = roleName
}).Result;
result = _userManager.AddToRoleAsync(user, roleName).Result;
var invalid = new Dictionary <string, string>
{
{ "googleInvalid", "Error google login." }
};
if (!result.Succeeded)
{
return(BadRequest(invalid));
}
}
else
{
_fileService.UploadAccountImageIfNotExists(user, userInfo.Picture);
}
await _signInManager.SignInAsync(user, isPersistent : false);
return(Ok(
new
{
token = _jWTTokenService.CreateToken(user),
refToken = _jWTTokenService.CreateRefreshToken(user)
}));
}
public async Task <IActionResult> Register([FromBody] UserRegisterDto model)
{
if (!ModelState.IsValid)
{
return(BadRequest("Wrong password or mail"));
}
var emailCheck = context.Users.FirstOrDefault(t => t.Email == model.Email);
if (emailCheck != null)
{
return(BadRequest("Email already exists"));
}
var user = new User()
{
UserName = model.Email,
Email = model.Email,
Age = model.Age,
LastName = model.LastName,
Name = model.Name,
RegisteredDate = DateTime.Now.ToShortDateString()
};
IdentityResult result = await userManager.CreateAsync(user, model.Password);
if (!result.Succeeded)
{
return(BadRequest(CustomValidator.GetErrorsByIdentityResult(result)));
}
await userManager.AddToRoleAsync(user, "User");
context.SaveChanges();
var code = await userManager.GenerateEmailConfirmationTokenAsync(user);
var callbackUrl = Url.Action(
"ConfirmEmail",
"Account",
new { userId = user.Id, code = code },
protocol: HttpContext.Request.Scheme);
EmailService emailService = new EmailService();
await emailService.SendEmail(model.Email, "Confirm your account",
$"Confirm registration by clicking on the lin: <a href='{callbackUrl}'>link</a>");
return(Ok(
new
{
token = jwtTokenService.CreateToken(user)
}));
}
public async Task <ResultDTO> Register([FromBody] UserRegisterDTO model)
{
if (!ModelState.IsValid)
{
//ВАЛІДАЦІЯ
return(new ResultDTO
{
Status = 500,
Message = "ERROR",
Errors = CustomValidator.GetErrorsByModel(ModelState)
});
}
else
{
var user = new User()
{
Email = model.Email,
UserName = model.Email,
};
var userMoreInfo = new UserMoreInfo()
{
id = user.Id,
FullName = model.FullName,
Address = model.Address,
Age = model.Age,
Phone = model.PhoneNumber
};
var result = await _userManager.CreateAsync(user, model.Password);
if (!result.Succeeded)
{
//TYT БУде валідація
return(new ResultDTO
{
Status = 500,
Message = "Error",
Errors = CustomValidator.GetErrorsByIdentityResult(result)
});
}
else if (result.Succeeded)
{
result = _userManager.AddToRoleAsync(user, "User").Result;
_context.userMoreInfos.Add(userMoreInfo);
_context.SaveChanges();
}
return(new ResultDTO
{
Status = 200,
Message = "OK"
});
}
}
public async Task <ResultDto> Register([FromBody] UserRegisterDto model)
{
if (!ModelState.IsValid)
{
return(new ResultErrorDto
{
Status = 500,
Errors = CustomValidator.GetErrorsByModel(ModelState)
});
}
var user = new User()
{
UserName = model.Email,
Email = model.Email,
PhoneNumber = model.PhoneNumber
};
var userProfile = new UserMoreInfo()
{
Age = model.Age,
FullName = model.FullName,
Id = user.Id,
Address = model.Address
};
var result = await _userManager.CreateAsync(user, model.Password);
if (!result.Succeeded)
{
return(new ResultErrorDto
{
Status = 500,
Errors = CustomValidator.GetErrorsByIdentityResult(result)
});
}
else
{
result = _userManager.AddToRoleAsync(user, "User").Result;
_context.userMoreInfos.AddAsync(userProfile);
_context.SaveChanges();
}
return(new ResultDto
{
Status = 200
});
}
public async Task <IActionResult> Register([FromBody] CustomRegisterModel model)
{
if (!ModelState.IsValid)
{
var errors = CustomValidator.GetErrorsByModel(ModelState);
return(BadRequest(errors));
}
if (!CaptchaHelper.VerifyAndExpireSolution(this.HttpContext, model.CaptchaKey,
model.CaptchaText))
{
var invalid = new Dictionary <string, string>();
invalid.Add("captchaText", "Error captcha text. Renew captcha and repeat again.");
return(BadRequest(invalid));
}
string path = _fileService.UploadImage(model.ImageBase64);
var user = new DbUser
{
UserName = model.Email,
Email = model.Email,
DateOfBirth = model.DateOfBirth,
FirstName = model.FirstName,
MiddleName = model.MiddleName,
LastName = model.LastName,
SignUpTime = DateTime.Now,
AvatarUrl = path
};
var result = await _userManager
.CreateAsync(user, model.Password);
if (!result.Succeeded)
{
var errors = CustomValidator.GetErrorsByIdentityResult(result);
return(BadRequest(errors));
}
var roleName = "User";
var roleresult = _roleManager.CreateAsync(new DbRole
{
Name = roleName
}).Result;
result = _userManager.AddToRoleAsync(user, roleName).Result;
await _signInManager.SignInAsync(user, isPersistent : false);
return(Ok());
}
public async Task <ResultDTO> Register(UserRegisterDTO model)
{
if (!ModelState.IsValid)
{
return(new ErrorResultDTO()
{
StatusCode = 403,
Message = "Error",
Errors = CustomValidator.GetErrorsByModel(ModelState)
});
}
var user = new User()
{
UserName = model.Email,
Email = model.Email,
PhoneNumber = model.Phone
};
var userInfo = new UserInfo
{
Address = model.Address,
FullName = model.FullName,
Id = user.Id
};
var identityResult = await _userManager.CreateAsync(user, model.Password);
if (!identityResult.Succeeded)
{
return(new ErrorResultDTO
{
StatusCode = 500,
Message = "Registration Error",
Errors = CustomValidator.GetErrorsByIdentityResult(identityResult)
});
}
var result = await _userManager.AddToRoleAsync(user, "User");
_context.UserInfos.Add(userInfo);
await _context.SaveChangesAsync();
return(new ResultDTO
{
StatusCode = 200,
Message = "OK"
});
}
public async Task <IActionResult> Google([FromBody] GoogleAuthViewModel model)
{
var userInfo = GoogleJsonWebSignature.ValidateAsync(model.TokenId, new GoogleJsonWebSignature.ValidationSettings()).Result;
var user = await _userManager.FindByEmailAsync(userInfo.Email);
if (user == null)
{
string path = _fileService.UploadFacebookImage(userInfo.Picture);
user = new DbUser
{
FirstName = userInfo.GivenName,
LastName = userInfo.FamilyName,
Email = userInfo.Email,
UserName = userInfo.Email,
SignUpTime = DateTime.Now,
AvatarUrl = path
};
var result = await _userManager.CreateAsync(user, RandomPasswordGenerator.GenerateRandomPassword());
if (!result.Succeeded)
{
var errors = CustomValidator.GetErrorsByIdentityResult(result);
return(BadRequest(errors));
}
var roleName = "User";
var roleresult = _roleManager.CreateAsync(new DbRole
{
Name = roleName
}).Result;
result = _userManager.AddToRoleAsync(user, roleName).Result;
await _signInManager.SignInAsync(user, isPersistent : false);
if (!result.Succeeded)
{
return(BadRequest(new { invalid = "We can't create user" }));
}
}
await _signInManager.SignInAsync(user, isPersistent : false);
return(Ok(_jWTTokenService.CreateToken(_configuration, user, _userManager)));
}
public async Task <IActionResult> Post([FromBody] UserAddViewModel model)
{
string id = null;
if (!ModelState.IsValid)
{
var errors = CustomValidator.GetErrorsByModel(ModelState);
return(BadRequest(errors));
}
var userProfile = new UserProfile
{
FirstName = model.FirstName,
LastName = model.LastName,
Salary = model.Salary,
Age = model.Age
};
var user = new DbUser()
{
UserName = model.Email,
Email = model.Email,
UserProfile = userProfile
};
IdentityResult result = await _userManager.CreateAsync(user, model.Password);
if (!result.Succeeded)
{
var errors = CustomValidator.GetErrorsByIdentityResult(result);
return(BadRequest(errors));
}
string code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var frontEndURL = _configuration.GetValue <string>("FrontEndURL");
var callbackUrl =
$"{frontEndURL}/confirmemail?userId={user.Id}&" +
$"code={WebUtility.UrlEncode(code)}";
await _emailSender.SendEmailAsync(model.Email, "Confirm Email",
$"Please confirm your email by clicking here: " +
$"<a href='{callbackUrl}'>link</a>");
return(Ok("S***N"));
}
public async Task <IActionResult> Register([FromBody] CustomRegisterModel model)
{
if (!ModelState.IsValid)
{
var errors = CustomValidator.GetErrorsByModel(ModelState);
return(BadRequest(errors));
}
string path = _fileService.UploadImage(model.ImageBase64);
var user = new DbUser
{
UserName = model.Email,
Email = model.Email,
DateOfBirth = model.DateOfBirth,
FirstName = model.FirstName,
MiddleName = model.MiddleName,
LastName = model.LastName,
SignUpTime = DateTime.Now,
AvatarUrl = path
};
var result = await _userManager
.CreateAsync(user, model.Password);
if (!result.Succeeded)
{
var errors = CustomValidator.GetErrorsByIdentityResult(result);
return(BadRequest(errors));
}
var roleName = "User";
var roleresult = _roleManager.CreateAsync(new DbRole
{
Name = roleName
}).Result;
result = _userManager.AddToRoleAsync(user, roleName).Result;
await _signInManager.SignInAsync(user, isPersistent : false);
return(Ok(_jWTTokenService.CreateToken(_configuration, user, _userManager)));
}
public async Task <ResultDTO> Register([FromBody] UserRegisterDTO model)
{
if (!ModelState.IsValid)
{
return(new ResultErrorDTO
{
Status = 500,
Errors = CustomValidator.GetErrorsByModel(ModelState)
});
}
var user = new User()
{
UserName = model.Email,
Email = model.Email,
Balance = 0
};
var result = await _userManager.CreateAsync(user, model.Password);
if (!result.Succeeded)
{
_logger.LogInformation($"User: email: {user.Email} register failed");
return(new ResultErrorDTO
{
Status = 500,
Errors = CustomValidator.GetErrorsByIdentityResult(result)
});
}
else
{
_logger.LogInformation($"User registered: id: {user.Id} email: {user.Email}");
result = _userManager.AddToRoleAsync(user, "User").Result;
await _context.SaveChangesAsync();
}
return(new ResultDTO
{
Status = 200
});
}
public async Task <IActionResult> ConfirmEmail(string userid, [FromBody] ConfirmEmailViewModel model)
{
if (!ModelState.IsValid)
{
var errrors = CustomValidator.GetErrorsByModel(ModelState);
return(BadRequest(errrors));
}
var user = await _userManager.FindByIdAsync(userid);
if (user == null)
{
return(BadRequest(new { invalid = "User is not found" }));
}
var result = await _userManager.ConfirmEmailAsync(user, model.Code);
if (!result.Succeeded)
{
var errrors = CustomValidator.GetErrorsByIdentityResult(result);
return(BadRequest(errrors));
}
return(Ok());
}
public async Task <IActionResult> Facebook([FromBody] FacebookAuthViewModel model)
{
// 1.generate an app access token
var appAccessTokenResponse = await Client.GetStringAsync($"https://graph.facebook.com/oauth/access_token?client_id={_fbAuthSettings.AppId}&client_secret={_fbAuthSettings.AppSecret}&grant_type=client_credentials");
var appAccessToken = JsonConvert.DeserializeObject <FacebookAppAccessToken>(appAccessTokenResponse);
// 2. validate the user access token
var userAccessTokenValidationResponse = await Client.GetStringAsync($"https://graph.facebook.com/debug_token?input_token={model.AccessToken}&access_token={appAccessToken.AccessToken}");
var userAccessTokenValidation = JsonConvert.DeserializeObject <FacebookUserAccessTokenValidation>(userAccessTokenValidationResponse);
if (!userAccessTokenValidation.Data.IsValid)
{
return(BadRequest(new { invalid = "Invalid facebook token!" }));
}
// 3. we've got a valid token so we can request user data from fb
var userInfoResponse = await Client.GetStringAsync($"https://graph.facebook.com/v2.8/me?fields=id,email,first_name,last_name,name,gender,locale,birthday,picture&access_token={model.AccessToken}");
var userInfo = JsonConvert.DeserializeObject <FacebookUserData>(userInfoResponse);
// 4. ready to create the local user account (if necessary) and jwt
var user = await _userManager.FindByEmailAsync(userInfo.Email);
if (user == null)
{
string path = _fileService.UploadFacebookImage(userInfo.Picture.Data.Url);
user = new DbUser
{
FirstName = userInfo.FirstName,
LastName = userInfo.LastName,
Email = userInfo.Email,
UserName = userInfo.Email,
SignUpTime = DateTime.Now,
AvatarUrl = path
};
var result = await _userManager.CreateAsync(user, RandomPasswordGenerator.GenerateRandomPassword());
if (!result.Succeeded)
{
var errors = CustomValidator.GetErrorsByIdentityResult(result);
return(BadRequest(errors));
}
var roleName = "User";
var roleresult = _roleManager.CreateAsync(new DbRole
{
Name = roleName
}).Result;
result = _userManager.AddToRoleAsync(user, roleName).Result;
await _signInManager.SignInAsync(user, isPersistent : false);
if (!result.Succeeded)
{
return(BadRequest(new { invalid = "We can't create user" }));
}
}
else
{
user = await _userManager.FindByEmailAsync(userInfo.Email);
if (user == null)
{
return(BadRequest(new { invalid = "Failed to create local user account." }));
}
}
await _signInManager.SignInAsync(user, isPersistent : false);
return(Ok(_jWTTokenService.CreateToken(_configuration, user, _userManager)));
}
public async Task <IActionResult> RegisterUser([FromBody] RegisterDTO model)
{
// Auto return errors from viewModel and other global errors
return(await HandleRequestAsync(async() =>
{
if (!CaptchaHelper.VerifyAndExpireSolution(this.HttpContext,
model.CaptchaKey,
model.CaptchaText))
{
var invalid = new Dictionary <string, string>();
invalid.Add("captchaText", "Помилка вводу зображення на фото");
return BadRequest(invalid);
}
var user = _userManager.FindByEmailAsync(model.Email).Result;
if (user != null)
{
var invalid = new Dictionary <string, string>();
invalid.Add("email", "Користувач з даною електронною поштою уже зареєстрований");
return BadRequest(invalid);
}
string imageName = Path.GetRandomFileName() + ".jpg";
try
{
this._logger.LogDebug("Start register method RegisterUser...");
string pathSaveImages = InitStaticFiles
.CreateImageByFileName(_env, _configuration,
new string[] { "ImagesPath", "ImagesPathUser" },
imageName,
model.Photo);
this._logger.LogDebug("Save image complete method RegisterUser...");
if (pathSaveImages != null)
{
var profile = new UserProfile()
{
RegistrationDate = DateTime.Now,
FirstName = model.FirstName,
LastName = model.LastName,
Photo = imageName,
};
user = new DbUser()
{
UserName = model.Email,
Email = model.Email,
PhoneNumber = model.Phone,
UserProfile = profile
};
var result = _userManager.CreateAsync(user, model.Password).Result;
if (!result.Succeeded)
{
var errors = CustomValidator.GetErrorsByIdentityResult(result);
return BadRequest(errors);
}
await _signInManager.SignInAsync(user, isPersistent: false);
// Return token
JwtInfo jwtInfo = new JwtInfo()
{
Token = _jwtTokenService.CreateToken(user),
RefreshToken = _jwtTokenService.CreateRefreshToken(user)
};
this._logger.LogDebug("End method RegisterUser...");
return Ok(jwtInfo);
}
else
{
throw new Exception("Помила додавання фото в БД");
}
}
catch (Exception ex)
{
InitStaticFiles.DeleteImageByFileName(_env, _configuration,
new string[] { "ImagesPath", "ImagesPathUser" },
imageName);
var errors = new Dictionary <string, string>();
errors.Add("invalid", ex.Message);
return BadRequest(errors);
}
}));
}
public async Task <IActionResult> Register([FromBody] RegisterViewModel model)
{
if (!ModelState.IsValid)
{
var errors = CustomValidator.GetErrorsByModel(ModelState);
return(BadRequest(errors));
}
var user = _context.Users.FirstOrDefault(u => u.Email == model.Email);
if (user != null)
{
return(BadRequest(new { invalid = "Електронна адреса вже використовується" }));
}
var str = "";
DateTime model_date = DateTime.Parse(model.DateOfBirth);
//DateTime model_date = DateTime.ParseExact(model.DateOfBirth, "yyyy.MM.dd", CultureInfo.InvariantCulture);
if (model_date.Month == 3 && model_date.Day >= 21 || model_date.Month == 4 && model_date.Day <= 20)
{
str = "Овен";
}
else if (model_date.Month == 4 && model_date.Day >= 21 || model_date.Month == 5 && model_date.Day <= 21)
{
str = "Телець";
}
else if (model_date.Month == 5 && model_date.Day >= 22 || model_date.Month == 6 && model_date.Day <= 21)
{
str = "Близнята";
}
else if (model_date.Month == 6 && model_date.Day >= 22 || model_date.Month == 7 && model_date.Day <= 22)
{
str = "Рак";
}
else if (model_date.Month == 7 && model_date.Day >= 23 || model_date.Month == 8 && model_date.Day <= 23)
{
str = "Лев";
}
else if (model_date.Month == 8 && model_date.Day >= 24 || model_date.Month == 9 && model_date.Day <= 22)
{
str = "Діва";
}
else if (model_date.Month == 9 && model_date.Day >= 23 || model_date.Month == 10 && model_date.Day <= 23)
{
str = "Терези";
}
else if (model_date.Month == 10 && model_date.Day >= 24 || model_date.Month == 11 && model_date.Day <= 22)
{
str = "Скорпіон";
}
else if (model_date.Month == 11 && model_date.Day >= 23 || model_date.Month == 12 && model_date.Day <= 21)
{
str = "Стрілець";
}
else if (model_date.Month == 12 && model_date.Day >= 22 || model_date.Month == 1 && model_date.Day <= 20)
{
str = "Козоріг";
}
else if (model_date.Month == 1 && model_date.Day >= 21 || model_date.Month == 2 && model_date.Day <= 20)
{
str = "Водолій";
}
else if (model_date.Month == 2 && model_date.Day >= 21 || model_date.Month == 3 && model_date.Day <= 20)
{
str = "Риби";
}
var zodiac = _context.Zodiac.FirstOrDefault(z => z.Name == str);
var city = _context.City.FirstOrDefault(z => z.Name == model.City);
Gender gender = _context.Gender.FirstOrDefault(z => z.Type == model.Gender);
var userProfile = new UserProfile()
{
DateOfRegister = DateTime.Now,
NickName = model.NickName,
DateOfBirth = DateTime.Parse(model.DateOfBirth),
ZodiacId = zodiac.Id,
CityId = city.Id,
GenderId = gender.Id
};
user = new DbUser()
{
UserName = model.Email,
Email = model.Email,
UserProfile = userProfile
};
var roleName = "User";
var result = _userManager.CreateAsync(user, model.Password).Result;
result = _userManager.AddToRoleAsync(user, roleName).Result;
if (!result.Succeeded)
{
var errors = CustomValidator.GetErrorsByIdentityResult(result);
return(BadRequest(errors));
}
await _signInManager.SignInAsync(user, isPersistent : false);
string name = $"{userProfile.NickName} ";
await _emailSender.SendEmailAsync(user.Email, "Ласкаво просимо, ",
$"Шановний(на) <strong>{name}</strong>" +
$"<br/>" +
$"Ви успішно пройшли реєстрацію" +
$"<br/>" +
$"<br/>");
//$"Для входу нажміть на посилання: <a href='https://idealcrud.azurewebsites.net/#/login'>Перейти</a>");
return(Ok(
new
{
token = _tokenService.CreateToken(user),
refToken = _tokenService.CreateRefreshToken(user)
}));
}
