public virtual async Task <JsonResult> Add([FromBody] A model)
{
if (!ModelState.IsValid)
{
return(new JsonAPIResult(_apiResult.CreateVMWithModelState(modelStateDictionary: ModelState),
StatusCodes.Status400BadRequest));
}
var result = await _service.AddAsync(model, User.GetId());
if (result.ResultIsNotTrue())
{
return(new JsonAPIResult(result, StatusCodes.Status422UnprocessableEntity));
}
return(new JsonAPIResult(_apiResult.CreateVM(result.RecId, result.ResultIsTrue()),
StatusCodes.Status200OK));
}
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));
}
public async Task <JsonResult> Update([FromRoute] Guid id, [FromBody] UserUpdateVM model)
{
if (id.IsEmptyGuid())
{
return(new JsonAPIResult(_apiResult.CreateVMWithStatusCode(null, false, APIStatusCode.ERR01003),
StatusCodes.Status400BadRequest));
}
else if (!ModelState.IsValid)
{
return(new JsonAPIResult(_apiResult.CreateVMWithModelState(modelStateDictionary: ModelState),
StatusCodes.Status400BadRequest));
}
var currentUser = await _userManager.FindByNameAsync(User.Identity.Name);
if (currentUser == null)
{
return(new JsonAPIResult(_apiResult.CreateVMWithStatusCode(null, false, APIStatusCode.ERR01004),
StatusCodes.Status404NotFound));
}
var user = await _userManager.FindByIdAsync(id.ToString());
if (user == null)
{
return(new JsonAPIResult(_apiResult.CreateVMWithStatusCode(null, false, APIStatusCode.ERR01004),
StatusCodes.Status404NotFound));
}
if (currentUser.Id != user.Id)
{
return(new JsonAPIResult(_apiResult.CreateVMWithStatusCode(null, false, APIStatusCode.ERR01007),
StatusCodes.Status403Forbidden));
}
user.About = model.About;
user.DisplayName = model.DisplayName;
IdentityResult result;
result = await _userManager.UpdateAsync(user);
if (!result.Succeeded)
{
return(new JsonAPIResult(_apiResult.CreateVMWithStatusCode(null, false, APIStatusCode.ERR01010),
StatusCodes.Status422UnprocessableEntity));
}
return(new JsonAPIResult(_apiResult.CreateVM(user.Id, true), StatusCodes.Status200OK));
}
public async Task <JsonResult> Create([FromBody] UserLoginVM model)
{
if (!ModelState.IsValid)
{
return(new JsonAPIResult(_apiResult.CreateVMWithModelState(modelStateDictionary: ModelState),
StatusCodes.Status400BadRequest));
}
var loginResult = await _signInManager.PasswordSignInAsync(model.UserName, model.Password,
isPersistent : false, lockoutOnFailure : false);
if (!loginResult.Succeeded)
{
return(new JsonAPIResult(_apiResult.CreateVMWithStatusCode(null, false, APIStatusCode.ERR01004),
StatusCodes.Status404NotFound));
}
TimeSpan expiryTimeSpan;
var user = await _userManager.FindByNameAsync(model.UserName);
var authData = _tokenService.Redis.GetById(user.Id);
if (!authData.IsNull() && !authData.Id.IsEmptyGuid())
{
return(new JsonAPIResult(_apiResult.CreateVMWithStatusCode(statusCode: APIStatusCode.ERR02025),
StatusCodes.Status400BadRequest));
}
if (authData == null || authData.AccessToken.IsNullOrEmptyString() || authData.AccessTokenExpiryTime < DateTime.UtcNow)
{
authData = new ViewModel.Auth.TokenCacheVM();
var claims = new Claim[] {
new Claim(JwtRegisteredClaimNames.Sub, user.Id.ToString()),
new Claim(JwtRegisteredClaimNames.UniqueName, user.UserName),
new Claim("UserId", user.Id.ToString())
};
authData.AccessToken = _tokenService.GenerateAccessToken(claims);
authData.AccessTokenExpiryTime = new JwtSecurityTokenHandler().ReadToken(authData.AccessToken)?.ValidTo ?? DateTime.MinValue;
authData.RefreshToken = _tokenService.GenerateRefreshToken();
authData.RefreshTokenExpiryTime = DateTime.UtcNow.AddDays(1);
authData.Id = user.Id;
expiryTimeSpan = TimeSpan.FromTicks(authData.AccessTokenExpiryTime.Ticks - DateTime.UtcNow.Ticks);
}
else
{
expiryTimeSpan = TimeSpan.FromSeconds(_tokenService.GetTokenExpiryDuration());
}
var updateResult = _tokenService.Redis.Insert(authData, expiryTimeSpan);
if (!updateResult.IsSuccessful)
{
return(new JsonAPIResult(_apiResult.CreateVMWithStatusCode(null, false, APIStatusCode.ERR01011),
StatusCodes.Status409Conflict));
}
var returnVM = _mapper.Map <Domain.User, UserAuthenticationVM>(user);
returnVM.TokenData = authData;
SentrySdk.CaptureMessage($"User {user.UserName} is created an access token", SentryLevel.Info);
return(new JsonAPIResult(returnVM, StatusCodes.Status200OK));
}
