public async Task <UserTokenResponse> RefreshTokenAsync(UserTokenRequest userTokenRequest)
{
var uri = new Uri($"{AuthUrl}/token/refresh");
try
{
var userJson = JsonConvert.SerializeObject(userTokenRequest);
var content = new StringContent(userJson, Encoding.UTF8, "application/json");
var response = await _client.PostAsync(uri, content).ConfigureAwait(false);
if (response.IsSuccessStatusCode)
{
var userTokenResponseJson = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
var userTokenResponse = JsonConvert.DeserializeObject <UserTokenResponse>(userTokenResponseJson);
return(await Task.FromResult(userTokenResponse).ConfigureAwait(false));
}
}
catch (Exception e)
{
Debug.WriteLine(e.Message);
}
return(null);
}
/// <summary>
/// 檢查登出資料中是不是有空值存在
/// </summary>
/// <param name="data"></param>
/// <returns></returns>
private bool PassLogoutDataCheck(UserTokenRequest data)
{
if (string.IsNullOrEmpty(data.Account) ||
string.IsNullOrEmpty(data.Code) ||
string.IsNullOrEmpty(data.ICanToken))
{
return(false);
}
return(true);
}
/// <summary>
/// Gets user token
/// </summary>
/// <param name="context">context</param>
/// <param name="userTokenRequest">user token request</param>
/// <returns>user token</returns>
public UserToken GetUserToken(Context context, UserTokenRequest userTokenRequest)
{
var request = userTokenRequest as UserTokenRequestWithCredentials;
Debug.Assert(request != null, "request != null");
var userToken = LoadUserToken(context, request.TenantName, request.AccountName, request.Password);
return(userToken);
}
public void UpdateUserToken(UserTokenRequest request, out string errMsg)
{
errMsg = "";
var result = Clients.UserService.UpdateUserToken(request);
if (result.Code == StatusFail)
{
errMsg = "Token信息更新失败";
}
}
protected override async Task RemoveUserTokenAsync(ApplicationUserToken token)
{
var userToken = new UserTokenRequest
{
LoginProvider = token.LoginProvider,
Name = token.Name,
Value = token.Value,
UserId = token.UserId
};
await _authenticationService.RemoveUserTokenAsync(userToken);
}
public void Create(UserTokenRequest request)
{
var userToken = new UserToken
{
LoginProvider = request.LoginProvider,
Name = request.Name,
Value = request.Value,
UserId = request.UserId,
ExpiryTime = request.ExpiryTime
};
_userTokenRepository.Add(userToken);
}
protected override Task AddUserTokenAsync(ApplicationUserToken token)
{
var userToken = new UserTokenRequest
{
LoginProvider = token.LoginProvider,
Name = token.Name,
Value = token.Value,
UserId = token.UserId,
ExpiryTime = token.ExpiryTime
};
_authenticationService.CreateUserToken(userToken);
return(Task.CompletedTask);
}
public string UpdateUserToken(string openId, string deviceKey, out string errMsg)
{
var request = new UserTokenRequest()
{
OpenId = openId,
Token = GenerateToken(),
ExpireTime = DateTime.Now.AddDays(1),
DeviceKey = deviceKey
};
errMsg = "";
_dal.UpdateUserToken(request, out errMsg);
return(request.Token);
}
public APIResponseBase ValidateUserToken()
{
try
{
UserTokenRequest tokenRequest = new UserTokenRequest();
tokenRequest.UserID = _authContext.UserID;
tokenRequest.SessionToken = _authContext.Token;
return(_AccountService.AuthenticateUser(tokenRequest));
}
catch (Exception ex)
{
LogUtil.Error(ex);
return(null);
}
}
public async Task DeleteTokenAsync(UserTokenRequest userTokenRequest)
{
// var uri = new Uri($"{AuthUrl}/token/refresh");
// try
// {
// var userJson = JsonConvert.SerializeObject(userTokenRequest);
// var content = new StringContent(userJson, Encoding.UTF8, "application/json");
//
// var response = await _client.DeleteAsync(uri, content);
// if (response.IsSuccessStatusCode)
// {
// var userTokenResponseJson = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
// var userTokenResponse = JsonConvert.DeserializeObject<UserTokenResponse>(userTokenResponseJson);
// return await Task.FromResult(userTokenResponse).ConfigureAwait(false);
// }
// }
// catch (Exception e)
// {
// Debug.WriteLine(e.Message);
// }
}
public async Task AuthenticateUserAsync(HttpClient httpClient, string emailAddress, string password, CancellationToken token = default)
{
httpClient.DefaultRequestHeaders.Clear();
if (_userToken == null)
{
var tokenRequest = new UserTokenRequest(emailAddress, password);
var json = JsonConvert.SerializeObject(tokenRequest);
var payload = new StringContent(json, new UTF8Encoding(), "application/json");
var response = await HttpClient.PostAsync(ClientConfig.UserAuthEndpoint, payload, token);
if (response.IsSuccessStatusCode)
{
var tokenRequestResult = await response.Content.ReadFromJsonAsync <UserToken>(cancellationToken : token);
if (tokenRequestResult != null)
{
_userToken = tokenRequestResult;
}
else
{
throw new Exception("Invalid access token received");
}
}
else
{
var content = await response.Content.ReadFromJsonAsync <ApiFailResult>(cancellationToken : token);
throw new Exception($"Error getting access token for Onsight API: {response.StatusCode}, {content?.Message}");
}
}
httpClient.DefaultRequestHeaders.Add("XClientId", new List <string> {
ClientConfig.DeviceId
});
httpClient.DefaultRequestHeaders.Add("XSessionId", _userToken.SessionKey);
}
public async Task <IActionResult> Get([FromQuery] UserTokenRequest UserParam)
{
var browserCapabilities = HttpContext.Request.Headers["User-Agent"].ToString();
var ipAdderess = HttpContext.Connection.RemoteIpAddress;
var hostUrl = HttpContext.Request.Host.ToString();
var user = await context.User.Include(x => x.UserUserRole)
.ThenInclude(x => x.UserRole)
.FirstOrDefaultAsync(x => x.Username == UserParam.Username &&
x.Password == UserParam.Password);
if (user == null)
{
return(BadRequest(new { message = "Username or password is incorrect" }));
}
var userRoles = user.UserUserRole.Select(x => x.UserRole.Name);
var jwtTokenModule = new JwtTokenModule(user.Id, userRoles, context, appSettings);
var token = await jwtTokenModule.GetToken(browserCapabilities, ipAdderess.ToString(), hostUrl, UserParam.IsGenerateNewToken);
return(Ok(new { token_type = "Bearer", access_token = token }));
}
public UserTokenResponse RequestUserAuthToken(PerksModel model)
{
var request = GetRequestObject(ConfigurationManager.AppSettings["auth0:signup_request_url"], method: "POST");
var tokenRequest = new UserTokenRequest
{
client_id = ConfigurationManager.AppSettings["auth0:client_id"],
email = model.EmailAddress,
connection = ConfigurationManager.AppSettings["auth0:connection"],
password = model.Password,
user_metadata = new UserTokenRequestUserMeta
{
first_name = model.FirstName,
last_name = model.LastName,
mobile = "",
preferences = ""
},
email_verified = "true",
app_metadata = new UserTokenRequestAppMeta
{
source_ref = "app"
}
};
var jsonData = JsonConvert.SerializeObject(tokenRequest);
AddJSONDataToRequest(request, jsonData);
var apiResponse = GetAPIResponse(request);
var response = JsonConvert.DeserializeObject <UserTokenResponse>(apiResponse.JSONString);
response.URI = apiResponse.URI;
response.StatusCode = apiResponse.StatusCode;
log.Debug(JsonConvert.SerializeObject(response));
return(response);
}
/// <summary>
/// 登出資料處理
/// </summary>
/// <param name="data"></param>
/// <returns></returns>
public bool LogoutProxy(UserTokenRequest data)
{
var tokenService = new TokenService();
//判斷是否有遺漏資訊
if (!PassLogoutDataCheck(data))
{
return(false);
}
var accounts = GetSimulatorAccount(data.Account);
//取得登入者資訊
var memberInfo = accounts.Count() > 1 ? accounts.ToArray()[1] : accounts.FirstOrDefault();
//是否本來為有效的登入
var checkSuccess = CheckLoginSuccess(memberInfo.Id, null, data.Code.ToLower());
if (checkSuccess == null)
{
return(false);
}
//將過去的token設為失效
tokenService.DeleteUserToken(memberInfo.Id, data.Code);
return(true);
}
/// <summary>
/// Authenticate User
/// </summary>
/// <param name="request">User details</param>
/// <returns>Status</returns>
public APIResponseBase AuthenticateUser(UserTokenRequest request)
{
APIResponseBase response = new APIResponseBase();
try
{
var mobileUser = _UnitOfWork.IUserRepository.RetrieveAll().Where(u => u.UserID == request.UserID && u.SessionToken == request.SessionToken).FirstOrDefault();
if (mobileUser == null)
{
response.ErrorCode = LAMPConstants.API_USER_SESSION_EXPIRED;
response.ErrorMessage = ResourceHelper.GetStringResource(LAMPConstants.API_USER_SESSION_EXPIRED);
}
else
{
response.ErrorCode = LAMPConstants.API_SUCCESS_CODE;
}
}
catch (Exception ex)
{
LogUtil.Error(ex);
response.ErrorCode = LAMPConstants.API_UNEXPECTED_ERROR;
}
return(response);
}
public async Task RemoveByValueAsync(UserTokenRequest request)
{
await _userTokenRepository.Get(x => x.Value == request.Value &&
x.UserId == request.UserId)
.DeleteAsync();
}
public async Task RemoveUserTokenAsync(UserTokenRequest request)
{
await _userTokenRepository.RemoveAsync(request);
}
public async Task RemoveAuthenticationTokenByValueAsync(UserTokenRequest request)
{
await _userTokenRepository.RemoveByValueAsync(request);
}
public async Task RemoveAsync(UserTokenRequest request)
{
await _userTokenRepository.Get(x => x.LoginProvider == request.LoginProvider &&
x.Value == request.Value && x.Name == request.Name && x.UserId == request.UserId)
.DeleteAsync();
}
public void CreateUserToken(UserTokenRequest request)
{
_userTokenRepository.Create(request);
}
