public async Task <JsonResult> LoginUser([FromBody] UserAuthenticationVM Loginuser)
{
if (Loginuser.Username != "" && Loginuser.Password != "")
{
var user = await _userManager.FindByNameAsync(Loginuser.Username) ?? await _userManager.FindByEmailAsync(Loginuser.Username);
if (user != null)
{
try
{
var result = await _signInManager.PasswordSignInAsync(user.UserName,
Loginuser.Password, Loginuser.RememberMe, false);
if (result.Succeeded)
{
var returnVal = new { success = true, msg = $"Welcome {Loginuser.Username}" };
return(Json(returnVal));
}
else
{
var returnVal = new { success = false, msg = $"Username and password does not match, Please try again." };
return(Json(returnVal));
}
}
catch
{
var returnVal = new { success = false, msg = $"Something went wrong, Try again later" };
return(Json(returnVal));
}
}
else
{
var returnVal = new { success = false, msg = $"There is no user with the username {Loginuser.Username}" };
return(Json(returnVal));
}
}
else
{
if (Loginuser.Username == "")
{
var returnVal = new { success = false, msg = $"Please enter your username!" };
return(Json(returnVal));
}
else if (Loginuser.Password == "")
{
var returnVal = new { success = false, msg = $"Please enter your password!" };
return(Json(returnVal));
}
else
{
return(Json(new { susuccess = false, msg = $"Something went wrong, Try again later" }));
}
}
}
public async Task <JsonResult> Register([FromBody] UserRegisterVM model)
{
if (!ModelState.IsValid)
{
return(new JsonAPIResult(_apiResult.CreateVMWithModelState(modelStateDictionary: ModelState),
StatusCodes.Status400BadRequest));
}
User entity = _mapper.Map <UserRegisterVM, User>(model);
entity.Id = Guid.NewGuid();
entity.CreateDateTime = DateTime.UtcNow;
var claims = new Claim[] {
new Claim(JwtRegisteredClaimNames.Sub, entity.Id.ToString()),
new Claim(JwtRegisteredClaimNames.UniqueName, entity.UserName),
new Claim("UserId", entity.Id.ToString())
};
TokenCacheVM authData = new TokenCacheVM();
authData.AccessToken = _tokenService.GenerateAccessToken(claims);
authData.RefreshToken = _tokenService.GenerateRefreshToken();
authData.AccessTokenExpiryTime = new JwtSecurityTokenHandler().ReadToken(authData.AccessToken)?.ValidTo ?? DateTime.MinValue;
authData.RefreshTokenExpiryTime = DateTime.UtcNow.AddDays(1);
authData.Id = entity.Id;
var identityResult = await _userManager.CreateAsync(entity, model.Password);
if (!identityResult.Succeeded)
{
return(new JsonAPIResult(_apiResult.CreateVMWithIdentityErrors(errors: identityResult.Errors),
StatusCodes.Status422UnprocessableEntity));
}
TimeSpan expiryTimeSpan = TimeSpan.FromSeconds(_tokenService.GetTokenExpiryDuration());
var cacheResult = _tokenService.Redis.Insert(authData, expiryTimeSpan);
if (!cacheResult.IsSuccessful)
{
return(new JsonAPIResult(_apiResult.CreateVMWithStatusCode(null, false, APIStatusCode.ERR01011),
StatusCodes.Status409Conflict));
}
await _signInManager.SignInAsync(entity, isPersistent : false);
UserAuthenticationVM returnVM = new UserAuthenticationVM();
returnVM = _mapper.Map <User, UserAuthenticationVM>(entity);
returnVM.TokenData = authData;
return(new JsonAPIResult(_apiResult.CreateVMWithRec <UserAuthenticationVM>(returnVM, entity.Id, true),
StatusCodes.Status201Created));
}
private async Task <UserAuthenticationVM> GetAccessToken()
{
HttpClient httpClient = new HttpClient();
UserLoginVM loginVM = new UserLoginVM()
{
UserName = "******",
Password = "******"
};
var url = GetHostAddress();
url.Path = "/api/tokens/create";
var response = await httpClient.PostAsJsonAsync(url.ToString(), loginVM);
var responseString = await response.Content.ReadAsStringAsync();
UserAuthenticationVM authModel = null;
APIResultVM apiResult = null;
try
{
if (responseString.Contains("Errors", StringComparison.CurrentCultureIgnoreCase))
{
apiResult = JsonSerializer.Deserialize <APIResultVM>(responseString);
if (apiResult.Errors != null && apiResult.Errors.Any(a => a.ErrorCode == APIStatusCode.ERR02025))
{
var user = await _userManager.FindByNameAsync("testuser");
if (user == null)
{
throw new Exception("GetAccessToken for HealthChecks or UnitTests, is failed, user not found");
}
var database = _redis.GetDatabase();
var tokenDataResult = database.StringGet(user.Id.ToString());
if (!tokenDataResult.HasValue)
{
throw new Exception("GetAccessToken for HealthChecks or UnitTests, is failed, user token data not found");
}
TokenCacheVM tokenData = JsonSerializer.Deserialize <TokenCacheVM>(tokenDataResult);
return(new UserAuthenticationVM()
{
TokenData = tokenData,
Id = tokenData.Id
});
}
else
{
return(default(UserAuthenticationVM));
}
}
else if (responseString.Contains("UserName", StringComparison.CurrentCultureIgnoreCase))
{
authModel = JsonSerializer.Deserialize <UserAuthenticationVM>(responseString);
return(authModel);
}
else
{
SentrySdk.CaptureEvent(new SentryEvent()
{
Message = "GetAccessToken for HealthChecks or UnitTests, is failed",
Level = Sentry.Protocol.SentryLevel.Error
});
return(default(UserAuthenticationVM));
}
}
catch (System.Exception e)
{
SentrySdk.CaptureException(e);
return(default(UserAuthenticationVM));
}
}
