private async Task SaveNewCredential()
{
await CredentialService.AddCredentialAsync(NewCredential);
SavedCredentials = await CredentialService.GetCredentialsAsync();
NewCredential = new JiraCredential();
}
public async Task <AuthData> Login(JiraCredential jiraCredential)
{
//var loginApi = $"{AppConstant.BaseUrl}api/auth/login";
var loginApi = $"{AppConstant.BaseUrl}api/Login";
_httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
return(await _httpClientHelper.PostAsync <JiraCredential, AuthData>(_httpClient, loginApi, jiraCredential));
}
public async Task AddCredentialAsync(JiraCredential credential)
{
var credentials = await GetCredentialsAsync();
credential.Id = Guid.NewGuid();
credentials.Add(credential);
await _localStorage.SetItem(STORAGE_KEY, credentials);
}
public async Task <Stream> GetAvatar(JiraCredential jiraCredential, string avatarUrl)
{
// Get avatar according to user profile
var avatarResponse = await _jiraIntegrationHelper.GetAsync(jiraCredential, avatarUrl);
if (!avatarResponse.IsSuccessStatusCode)
{
return(null);
}
return(avatarResponse.Content.ReadAsStreamAsync().Result);
}
public async Task <AccountInfo> GetAccountInfoByUserKey(JiraCredential jiraCredential)
{
if (jiraCredential == null)
{
throw new ArgumentNullException(nameof(jiraCredential));
}
// Get user profile from jira
var userProfileResponse = await _jiraIntegrationHelper.GetAsync(jiraCredential, AppConstant.UserProfileUrl + jiraCredential.UserName);
if (!userProfileResponse.IsSuccessStatusCode)
{
return(null);
}
var jsonString = userProfileResponse.Content.ReadAsStringAsync().Result;
var replaceJsonString = jsonString.Replace("16x16", "_16x16").Replace("24x24", "_24x24").Replace("32x32", "_32x32").Replace("48x48", "_48x48");
// Parse response json to list of user profile
var userProfiles = JsonConvert.DeserializeObject <List <UserProfile> >(replaceJsonString);
// Get first in list of user profile
var userProfile = userProfiles != null && userProfiles.Count > 0 ? userProfiles.FirstOrDefault() : null;
if (userProfile == null)
{
return(null);
}
// Get UPS infomation of user
var accountDto = await _accountRepository.GetAccountInfoByUserKey(jiraCredential.UserName);
return(new AccountInfo {
AdId = accountDto.AdId,
AvatarUrl = userProfile.AvatarUrls._48x48,
ContactPointName = accountDto.ContactPointName,
ContactPointPhone = accountDto.ContactPointPhone,
DisplayName = userProfile.DisplayName,
GdId = accountDto.GdId,
GeneralInfo = accountDto.GeneralInfo,
HomeAddress = accountDto.HomeAddress,
PassCode = accountDto.PassCode,
RanId = accountDto.RanId,
TokenId = accountDto.TokenId,
UpsMail = accountDto.UpsMail,
WorkAddress = accountDto.WorkAddress
});
}
public async Task <HttpResponseMessage> Login(JiraCredential jiraCredential)
{
if (jiraCredential == null)
{
throw new ArgumentNullException(nameof(jiraCredential));
}
var isExist = await _userRepository.IsExistUserKey(jiraCredential.UserName);
if (!isExist)
{
return(null);
}
return(await _jiraIntegrationHelper.GetAsync(jiraCredential, AppConstant.LoginUrl));
}
public async Task <AuthData> Login([FromBody] JiraCredential jiraCredential)
{
var httpResponseMessage = await _userBusiness.Login(jiraCredential);
if (!httpResponseMessage.IsSuccessStatusCode)
{
return(null);
}
var requestAt = DateTime.UtcNow;
var expiresIn = requestAt + TimeSpan.FromMinutes(_options.AuthenticationExpiryTimeInMinutes);
return(new AuthData {
ExpiresIn = expiresIn,
Token = GenerateToken(jiraCredential, expiresIn)
});
}
private async Task <JiraTask> GetTaskAsync(string key, JiraCredential credential)
{
var queryBuilder = new QueryBuilder
{
{ "key", key },
{ "site", credential.SiteUrl },
{ "email", credential.Email },
{ "token", credential.ApiToken }
};
try
{
return(await _httpClient.GetFromJsonAsync <JiraTask>(_baseUrl + queryBuilder.ToQueryString()));
}
catch
{
return(null);
}
}
protected string GenerateToken(JiraCredential jiraCredential, DateTime expires)
{
var handler = new JwtSecurityTokenHandler();
ClaimsIdentity identity = new ClaimsIdentity(
new GenericIdentity(jiraCredential.UserName, "TokenAuth"),
new[] {
new Claim(MyUpsClaimType.UserKey, jiraCredential.UserName),
new Claim(MyUpsClaimType.Password, jiraCredential.Password)
}
);
var securityToken = handler.CreateToken(new SecurityTokenDescriptor {
Issuer = TokenAuthOption.Issuer,
Audience = TokenAuthOption.Audience,
SigningCredentials = TokenAuthOption.SigningCredentials,
Subject = identity,
Expires = expires
});
return(handler.WriteToken(securityToken));
}
public async Task <HttpResponseMessage> GetAsync(JiraCredential jiraCredential, string apiUrl)
{
if (jiraCredential == null)
{
throw new ArgumentNullException(nameof(jiraCredential));
}
if (apiUrl == null)
{
throw new ArgumentNullException(nameof(apiUrl));
}
var authData = $"{jiraCredential.UserName}:{jiraCredential.Password}";
var authHeaderValue = Convert.ToBase64String(Encoding.UTF8.GetBytes(authData));
// HttpClient implement IDisposable interface therefor we need to use using block to release memory after usage
using (var httpClient = new HttpClient()) {
httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", authHeaderValue);
httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
httpClient.Timeout = TimeSpan.FromSeconds(AppConstant.HttpClientTimeOut);
return(await httpClient.GetAsync(apiUrl));
}
}
