public async Task <IActionResult> Login([FromBody] UserLoginDto model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var result = await signInManager.PasswordSignInAsync(model.Email, model.Password, false, false);
if (result.Succeeded)
{
//sending response if succeeded
var appUser = userManager.Users.Single(r => r.Email == model.Email);
if (appUser.IsBlocked)
{
return(Unauthorized("Sorry! your account is blocked!"));
}
var token = await GenerateJwtToken(model.Email, appUser);
var response = new TokenResponseDto
{
Token = token,
Email = model.Email,
Role = model.Role
};
return(Ok(response));
}
return(BadRequest("Oops! Login failed. Please enter correct email and password."));
}
private async Task GetDeviceData(TokenResponseDto token)
{
var client = new RestClient("https://api.netatmo.com");
var request = new RestRequest("/api/getstationsdata");
request.AddQueryParameter("access_token", token.AccessToken);
var data = await client.GetTaskAsync <StationDataResponseDto>(request);
if (data?.Body?.Devices == null)
{
return;
}
lock (_deviceLock)
{
foreach (var dataDevice in data.Body.Devices)
{
var station = dataDevice.StationName;
dataDevice.BatteryPercent = 100;
UpdateDevice(station, dataDevice);
if (dataDevice.Modules == null)
{
continue;
}
foreach (var module in dataDevice.Modules)
{
UpdateDevice(station, module);
}
}
}
}
public void GivenWrongAuthenticationResult_WhenMapping_ThenGetFailure(AuthenticateResult authResult)
{
var dto = TokenResponseDto.Create(authResult, Username);
dto.Failure.Should().NotBeNull();
((int)dto.Failure).Should().Be((int)authResult);
}
public void GivenGoodAuthenticationResult_WhenMapping_ThenGetSuccess()
{
var authResult = AuthenticateResult.Ok;
var dto = TokenResponseDto.Create(authResult, Username);
dto.Failure.Should().BeNull();
}
private TokenResponseDto SetResponse(string token, bool authenticated, DateTime?createDate, DateTime?expirationDate, string message)
{
TokenResponseDto response = new TokenResponseDto
{
AccessToken = token,
Authenticated = authenticated,
CreateDate = createDate,
ExpirationDate = expirationDate,
Message = message
};
return(response);
}
public async Task ExecuteAsync(IdentityServerContext context)
{
var dto = new TokenResponseDto
{
id_token = TokenResponse.IdentityToken,
access_token = TokenResponse.AccessToken,
refresh_token = TokenResponse.RefreshToken,
expires_in = TokenResponse.AccessTokenLifetime,
token_type = Constants.TokenTypes.Bearer
};
context.HttpContext.Response.SetNoCache();
await context.HttpContext.Response.WriteJsonAsync(dto);
}
public async Task ExecuteAsync(IdentityServerContext context)
{
var dto = new TokenResponseDto
{
id_token = TokenResponse.IdentityToken,
access_token = TokenResponse.AccessToken,
refresh_token = TokenResponse.RefreshToken,
expires_in = TokenResponse.AccessTokenLifetime,
token_type = Constants.TokenTypes.Bearer
};
context.HttpContext.Response.SetNoCache();
await context.HttpContext.Response.WriteJsonAsync(dto);
}
public static TokenResponseDto ConvertToTokenResponseDto(UserBo bo)
{
TokenResponseDto tokenUserDto = new TokenResponseDto();
tokenUserDto.Id = bo.Id;
tokenUserDto.FirstName = bo.FirstName;
tokenUserDto.MiddleName = bo.MiddleName;
tokenUserDto.LastName = bo.LastName;
tokenUserDto.EmailAddress = bo.EmailAddress;
tokenUserDto.OrganizationId = bo.OrganizationId;
tokenUserDto.LastLoginTime = bo.LastLoginTime;
tokenUserDto.UserTypeId = bo.UserTypeId;
return(tokenUserDto);
}
private async Task <ServiceResult <TokenResponseDto> > GetTokenResponseAsync(UserBo user)
{
string accessToken = "";
string refreshToken = GenerateRefreshToken();
ServiceResult <TokenResponseDto> response = null;
UserTokenBo userTokenBo = GenerateUserToken(user);
userTokenBo.RefreshToken = refreshToken;
userTokenBo.AccessToken = "";
ServiceResult <UserTokenBo> userTokenResult = await serviceManager.UserToken_Service.CreateAsync(userTokenBo);
if (!userTokenResult.Success)
{
response = new ServiceResult <TokenResponseDto>(null, false, "User Token Create Failed!");
return(response);
}
userTokenBo = userTokenResult.Data;
try
{
//sign your token here here..
accessToken = GenerateAccessToken(userTokenBo.Id, user);
}
catch (Exception ex)
{
response = new ServiceResult <TokenResponseDto>(null, false, "Token Create Failed! " + (ex.Message));
return(response);
}
userTokenBo.AccessToken = accessToken;
await serviceManager.UserToken_Service.UpdateAsync(userTokenBo.Id, userTokenBo);
await serviceManager.UserLogin_Service.CreateAsync(new UserLoginBo()
{
UserId = user.Id, LoginTime = DateTime.UtcNow
});
TokenResponseDto tokenResponseDto = UserBo.ConvertToTokenResponseDto(user);
tokenResponseDto.AccessToken = accessToken;
tokenResponseDto.RefreshToken = refreshToken;
response = new ServiceResult <TokenResponseDto>(tokenResponseDto, true, "");
return(response);
}
public async Task <IActionResult> Register([FromBody] RegisterUserDto model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = new UserModel
{
UserName = model.Email,
Email = model.Email,
Name = model.Name,
PhoneNumber = model.PhoneNumber,
Experience = model.Experience,
LinkedInUrl = model.LinkedinUrl,
IsBlocked = false
};
var result = await userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
// role name
var roleName = roleManager.Roles.
FirstOrDefault(r => r.Id == model.Role.ToString()).NormalizedName;
var res = await userManager.AddToRoleAsync(user, roleName);
if (res.Succeeded)
{
//sending response if succeeded
var appUser = userManager.Users.Single(r => r.Email == model.Email);
var token = await GenerateJwtToken(model.Email, appUser);
var response = new TokenResponseDto
{
Token = token,
Email = model.Email,
Role = model.Role
};
return(Ok(response));
}
return(BadRequest(res.Errors));
}
return(BadRequest(result.Errors));
}
private HttpResponseMessage Execute()
{
var dto = new TokenResponseDto
{
id_token = _response.IdentityToken,
access_token = _response.AccessToken,
refresh_token = _response.RefreshToken,
expires_in = _response.AccessTokenLifetime,
token_type = _response.TokenType,
alg = _response.Algorithm
};
var jobject = JObject.FromObject(dto, Serializer);
// custom entries
if (_response.Custom != null && _response.Custom.Any())
{
foreach (var item in _response.Custom)
{
JToken token;
if (jobject.TryGetValue(item.Key, out token))
{
throw new Exception("Item does already exist - cannot add it via a custom entry: " + item.Key);
}
if (item.Value.GetType().IsClass)
{
jobject.Add(new JProperty(item.Key, JToken.FromObject(item.Value)));
}
else
{
jobject.Add(new JProperty(item.Key, item.Value));
}
}
}
var response = new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent(jobject.ToString(Formatting.None), Encoding.UTF8, "application/json")
};
Logger.Info("Returning token response.");
return(response);
}
private HttpResponseMessage Execute()
{
var dto = new TokenResponseDto
{
id_token = _response.IdentityToken,
access_token = _response.AccessToken,
refresh_token = _response.RefreshToken,
expires_in = _response.AccessTokenLifetime,
token_type = _response.TokenType,
alg = _response.Algorithm
};
var jobject = JObject.FromObject(dto, Serializer);
// custom entries
if (_response.Custom != null && _response.Custom.Any())
{
foreach (var item in _response.Custom)
{
JToken token;
if (jobject.TryGetValue(item.Key, out token))
{
throw new Exception("Item does already exist - cannot add it via a custom entry: " + item.Key);
}
if (item.Value.GetType().IsClass)
{
jobject.Add(new JProperty(item.Key, JToken.FromObject(item.Value)));
}
else
{
jobject.Add(new JProperty(item.Key, item.Value));
}
}
}
var response = new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent(jobject.ToString(Formatting.None), Encoding.UTF8, "application/json")
};
Logger.Info("Returning token response.");
return response;
}
public async Task <IActionResult> Post([FromBody] AuthenticationDto dto)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var responseDto = await Envelope(async() =>
{
var result = await _identityService.Authenticate(dto.Username, dto.Password);
var response = TokenResponseDto.Create(result, dto.Username);
if (result == AuthenticateResult.Ok)
{
var identity = await _identityRepository.GetByEmail(dto.Username);
var claims = new[]
{
new Claim(JwtRegisteredClaimNames.Sub, identity.Id.ToString()),
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()),
new Claim(ClaimTypes.Email, identity.Email),
new Claim(ClaimTypes.Name, identity.Username),
new Claim(ClaimTypes.Actor, identity.IdType.ToString()),
new Claim(ClaimTypes.Role, IdentityRoles.ToRole(identity.IdType))
};
var token = new JwtSecurityToken(
_configurationProvider.TokenConfiguration.Issuer,
_configurationProvider.TokenConfiguration.Audience,
claims,
expires: DateTime.UtcNow.AddHours(1),
signingCredentials: new SigningCredentials(
_configurationProvider.TokenConfiguration.SigningKey,
SecurityAlgorithms.HmacSha256));
response.Token = new JwtSecurityTokenHandler().WriteToken(token);
}
return(response);
});
responseDto.IsSuccessful = responseDto.Payload.Token.HasValue();
return(Ok(responseDto));
}
private HttpResponseMessage Execute()
{
var dto = new TokenResponseDto
{
id_token = _response.IdentityToken,
access_token = _response.AccessToken,
refresh_token = _response.RefreshToken,
expires_in = _response.AccessTokenLifetime,
token_type = Constants.TokenTypes.Bearer
};
var response = new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new ObjectContent <TokenResponseDto>(dto, Formatter)
};
Logger.Info("Returning token response.");
return(response);
}
private HttpResponseMessage Execute()
{
var dto = new TokenResponseDto
{
id_token = _response.IdentityToken,
access_token = _response.AccessToken,
refresh_token = _response.RefreshToken,
expires_in = _response.AccessTokenLifetime,
token_type = Constants.TokenTypes.Bearer
};
var response = new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new ObjectContent<TokenResponseDto>(dto, Formatter)
};
Logger.Info("Returning token response.");
return response;
}
private HttpResponseMessage Execute()
{
var dto = new TokenResponseDto
{
id_token = _response.IdentityToken,
access_token = _response.AccessToken,
expires_in = _response.AccessTokenLifetime,
token_type = Constants.TokenTypes.Bearer
};
var formatter = new JsonMediaTypeFormatter();
formatter.SerializerSettings.DefaultValueHandling = DefaultValueHandling.Ignore;
var response = new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new ObjectContent<TokenResponseDto>(dto, formatter)
};
return response;
}
private HttpResponseMessage Execute()
{
var dto = new TokenResponseDto
{
id_token = _response.IdentityToken,
access_token = _response.AccessToken,
expires_in = _response.AccessTokenLifetime,
token_type = Constants.TokenTypes.Bearer
};
var formatter = new JsonMediaTypeFormatter();
formatter.SerializerSettings.DefaultValueHandling = DefaultValueHandling.Ignore;
var response = new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new ObjectContent <TokenResponseDto>(dto, formatter)
};
return(response);
}
private TokenResponseDto CreateTokenResponse(JwtSecurityToken token, User user)
{
if (user == null || token == null)
{
return(null);
}
var tokenResponse = new TokenResponseDto
{
IsAccountActive = user.EmailConfirmed,
Token = !user.EmailConfirmed
? null
: new TokenDto
{
Token = new JwtSecurityTokenHandler().WriteToken(token),
BoardsExists = user.Boards != null && user.Boards.Any(x => !x.IsDeleted &&
!x.Board.IsDeleted &&
x.LastTimeVisited > DateTime.MinValue)
}
};
return(tokenResponse);
}
private HttpResponseMessage Execute()
{
var dto = new TokenResponseDto
{
id_token = _response.IdentityToken,
access_token = _response.AccessToken,
refresh_token = _response.RefreshToken,
expires_in = _response.AccessTokenLifetime,
token_type = Constants.TokenTypes.Bearer
};
var jobject = JObject.FromObject(dto, Serializer);
// custom entries
if (_response.Custom != null && _response.Custom.Any())
{
foreach (var item in _response.Custom)
{
JToken token;
if (jobject.TryGetValue(item.Key, out token))
{
throw new Exception("Item does already exist - cannot add it via a custom entry: " + item.Key);
}
jobject.Add(new JProperty(item.Key, item.Value));
}
}
var response = new HttpResponseMessage(HttpStatusCode.OK)
{
//Content = new ObjectContent<JObject>(jobject, new JsonMediaTypeFormatter())
Content = new StringContent(jobject.ToString(), Encoding.UTF8, "application/json")
};
Logger.Info("Returning token response.");
return response;
}
private HttpResponseMessage Execute()
{
var dto = new TokenResponseDto
{
id_token = _response.IdentityToken,
access_token = _response.AccessToken,
refresh_token = _response.RefreshToken,
expires_in = _response.AccessTokenLifetime,
token_type = Constants.TokenTypes.Bearer
};
var jobject = JObject.FromObject(dto, Serializer);
// custom entries
if (_response.Custom != null && _response.Custom.Any())
{
foreach (var item in _response.Custom)
{
JToken token;
if (jobject.TryGetValue(item.Key, out token))
{
throw new Exception("Item does already exist - cannot add it via a custom entry: " + item.Key);
}
jobject.Add(new JProperty(item.Key, item.Value));
}
}
var response = new HttpResponseMessage(HttpStatusCode.OK)
{
//Content = new ObjectContent<JObject>(jobject, new JsonMediaTypeFormatter())
Content = new StringContent(jobject.ToString(), Encoding.UTF8, "application/json")
};
Logger.Info("Returning token response.");
return(response);
}
private async Task <TokenResponseDto> GenerateToken(string username)
{
var user = await _userManager.FindByNameAsync(username);
var roles = from ur in _context.UserRoles
join r in _context.Roles on ur.RoleId equals r.Id
where ur.UserId == user.Id
select new { ur.UserId, ur.RoleId, r.Name };
var claims = new List <Claim>
{
new Claim(ClaimTypes.Name, username),
new Claim(ClaimTypes.NameIdentifier, user.Id),
new Claim(JwtRegisteredClaimNames.Nbf, new DateTimeOffset(DateTime.Now).ToUnixTimeSeconds().ToString()),
new Claim(JwtRegisteredClaimNames.Exp, new DateTimeOffset(DateTime.Now.AddMinutes(_tokenLifetime)).ToUnixTimeSeconds().ToString())
};
foreach (var role in roles)
{
claims.Add(new Claim(ClaimTypes.Role, role.Name));
}
var token = new JwtSecurityToken(
new JwtHeader(
new SigningCredentials(
new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_securityKey)),
SecurityAlgorithms.HmacSha256)),
new JwtPayload(claims));
var output = new TokenResponseDto()
{
AccessToken = new JwtSecurityTokenHandler().WriteToken(token),
UserName = username
};
return(output);
}
private async Task <TokenResponseDto> RefreshTokenAsync(TokenResponseDto dto)
{
var policy = GetRetryPolicy();
return(await policy.ExecuteAsync(async() =>
{
var client = new RestClient("https://api.netatmo.com");
var request = new RestRequest("/oauth2/token");
request.AddHeader("Content-Type", "application/x-www-form-urlencoded;charset=UTF-8");
request.AddParameter("grant_type", dto.RefreshToken);
request.AddParameter("client_id", _clientId);
request.AddParameter("client_secret", _clientSecret);
var token = await client.PostTaskAsync <TokenResponseDto>(request);
if (token?.AccessToken == null)
{
return null;
}
token.Expiration = DateTime.UtcNow.AddSeconds(token.ExpiresIn);
return token;
}));
}
private async Task<TokenResponseDto> RefreshTokenAsync(TokenResponseDto dto)
{
var policy = GetRetryPolicy();
return await policy.ExecuteAsync(async () =>
{
var client = new RestClient("https://api.netatmo.com");
var request = new RestRequest("/oauth2/token");
request.AddHeader("Content-Type", "application/x-www-form-urlencoded;charset=UTF-8");
request.AddParameter("grant_type", dto.RefreshToken);
request.AddParameter("client_id", _clientId);
request.AddParameter("client_secret", _clientSecret);
var token = await client.PostTaskAsync<TokenResponseDto>(request);
if (token?.AccessToken == null)
{
return null;
}
token.Expiration = DateTime.UtcNow.AddSeconds(token.ExpiresIn);
return token;
});
}
private async Task GetDeviceData(TokenResponseDto token)
{
var client = new RestClient("https://api.netatmo.com");
var request = new RestRequest("/api/getstationsdata");
request.AddQueryParameter("access_token", token.AccessToken);
var data = await client.GetTaskAsync<StationDataResponseDto>(request);
if (data?.Body?.Devices == null)
{
return;
}
lock (_deviceLock)
{
foreach (var dataDevice in data.Body.Devices)
{
var station = dataDevice.StationName;
dataDevice.BatteryPercent = 100;
UpdateDevice(station, dataDevice);
if (dataDevice.Modules == null)
{
continue;
}
foreach (var module in dataDevice.Modules)
{
UpdateDevice(station, module);
}
}
}
}
private async Task <IActionResult> GetToken(TokenRequestDto tokenRequestDto)
{
try {
// Check if there's an user with the given email
var user = await UserManager.FindByEmailAsync(tokenRequestDto.Email);
// or username
if (user == null)
{
user = await UserManager.FindByNameAsync(tokenRequestDto.Email);
}
if (user == null ||
!await UserManager.CheckPasswordAsync(user, tokenRequestDto.Password))
{
// User doesn't exists or password mismatch.
return(new UnauthorizedResult());
}
// Email and password matches. Create and return the JWT token.
DateTime now = DateTime.UtcNow;
// Add the registered claims for JWT.
var claims = new List <Claim> {
new Claim(JwtRegisteredClaimNames.Sub, user.Id),
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()),
new Claim(JwtRegisteredClaimNames.Iat, new DateTimeOffset(now).ToUnixTimeSeconds().ToString()),
new Claim("Username", user.UserName)
// TODO:
// Add additional claims here.
};
// Get user claims from database.
var claimsFromDb = new List <Claim>(await UserManager.GetClaimsAsync(user));
claims.AddRange(claimsFromDb);
var tokenExpirationMins = Configuration.GetValue <int>("Auth:Jwt:TokenExpirationInMinutes");
var issuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(Configuration["Auth:Jwt:Key"]));
var token = new JwtSecurityToken(
issuer: Configuration["Auth:Jwt:Issuer"],
audience: Configuration["Auth:Jwt:Audience"],
claims: claims,
notBefore: now,
expires: now.Add(TimeSpan.FromMinutes(tokenExpirationMins)),
signingCredentials: new SigningCredentials(issuerSigningKey, SecurityAlgorithms.HmacSha256)
);
var encodedToken = new JwtSecurityTokenHandler().WriteToken(token);
// Build and return the response.
var response = new TokenResponseDto()
{
Token = encodedToken,
Expiration = tokenExpirationMins
};
return(Ok(response));
}
catch {
return(new UnauthorizedResult());
}
}
