// Token: 0x060054E7 RID: 21735 RVA: 0x001D4730 File Offset: 0x001D2B30
private void OnRequestTokenCallback(bool success, RequestTokenResponse response)
{
if (success)
{
this.m_RequestTokenResponse = response;
API.OpenAuthorizationPage(response.Token);
this.connectButton.gameObject.SetActive(false);
this.disconnectButton.gameObject.SetActive(false);
this.inputField.gameObject.SetActive(true);
this.inputField.onEndEdit.AddListener(delegate(string text)
{
this.GetAccessToken(text);
this.connectButton.gameObject.SetActive(false);
this.disconnectButton.gameObject.SetActive(true);
this.inputField.gameObject.SetActive(false);
this.inputField.text = string.Empty;
this.statusText.text = "Connecting...";
});
}
else
{
MonoBehaviour.print("OnRequestTokenCallback - failed.");
this.connectButton.gameObject.SetActive(true);
this.disconnectButton.gameObject.SetActive(false);
this.inputField.gameObject.SetActive(false);
this.statusText.text = "Not Connected";
}
}
/// <summary>
/// Creates a Status with ResponseType Complete and the complete <see cref="RequestTokenResponse"/>.
/// Indicates that the MobileConnect process is complete and the user is authenticated.
/// </summary>
/// <param name="response">RequestTokenResponse returned from <see cref="IAuthentication"/></param>
/// <returns>MobileConnectStatus with ResponseType Complete</returns>
public static MobileConnectStatus Complete(RequestTokenResponse response)
{
return(new MobileConnectStatus
{
ResponseType = MobileConnectResponseType.Complete,
TokenResponse = response
});
}
//Get Request Token
public async Task <RequestTokenResponse> GetRequestToken()
{
var requestTokenResponse = new RequestTokenResponse();
var client = _clientFactory.CreateClient("twitter");
var consumerKey = _twitterConfig.Value.AppId;
var consumerSecret = _twitterConfig.Value.AppSecret;
var callbackUrl = "http://localhost:4200/login";
client.DefaultRequestHeaders.Accept.Clear();
var oauthClient = new OAuthRequest
{
Method = "POST",
Type = OAuthRequestType.RequestToken,
SignatureMethod = OAuthSignatureMethod.HmacSha1,
ConsumerKey = consumerKey,
ConsumerSecret = consumerSecret,
RequestUrl = "https://api.twitter.com/oauth/request_token",
Version = "1.0a",
Realm = "twitter.com",
CallbackUrl = callbackUrl
};
string auth = oauthClient.GetAuthorizationHeader();
client.DefaultRequestHeaders.Add("Authorization", auth);
try
{
var content = new StringContent("", Encoding.UTF8, "application/json");
using (var response = await client.PostAsync(oauthClient.RequestUrl, content))
{
response.EnsureSuccessStatusCode();
var responseString = response.Content.ReadAsStringAsync()
.Result.Split("&");
requestTokenResponse = new RequestTokenResponse
{
oauth_token = responseString[0],
oauth_token_secret = responseString[1],
oauth_callback_confirmed = responseString[2]
};
}
}
catch (Exception ex)
{
throw;
}
return(requestTokenResponse);
}
void OnRequestTokenCallback(bool success, Twitter.RequestTokenResponse response)
{
if (success)
{
// 認証要求
Request = response;
API.OpenAuthorizationPage(response.Token);
}
}
/// <summary>
/// Creates a Status with ResponseType Complete and the complete <see cref="RequestTokenResponse"/>.
/// Indicates that the MobileConnect process is complete and the user is authenticated.
/// </summary>
/// <param name="response">RequestTokenResponse returned from <see cref="IAuthenticationService"/></param>
/// <param name="caller">Name of calling method</param>
/// <returns>MobileConnectStatus with ResponseType Complete</returns>
public static MobileConnectStatus Complete(RequestTokenResponse response, [CallerMemberName] string caller = null)
{
Log.Info(() => $"MobileConnectStatus Complete returned caller={caller}");
return(new MobileConnectStatus
{
ResponseType = MobileConnectResponseType.Complete,
TokenResponse = response
});
}
public Task <TwitterApi> AccessToken(RequestTokenResponse response, string verifier)
{
if (response == null)
{
throw new ArgumentNullException(nameof(response));
}
return(this.AccessToken(response.OAuthToken, verifier));
}
public HttpResponseMessage RequestTokenResponse(string callbackUri)
{
RequestTokenResponse tokenResponse = RequestToken(callbackUri);
const string redirectFormat = "https://api.twitter.com/oauth/authenticate?oauth_token={0}";
Uri redirect = new Uri(string.Format(redirectFormat, tokenResponse.oauth_token));
HttpResponseMessage response = new HttpResponseMessage(HttpStatusCode.Redirect);
response.Headers.Location = redirect;
return(response);
}
public async Task Authentication(Uri instanceUri, string consumerKey, string consumerSecret)
{
this._api = string.IsNullOrEmpty(consumerKey)
? new TwitterApi(Conf.ConsumerKey, Conf.ConsumerSecret)
: new TwitterApi(consumerKey, consumerSecret);
this._session = await this._api.OAuth.RequestToken().ConfigureAwait(false);
this.AuthorizeUrl = this._session.GetAuthorizeUrl();
App.Open(this._session.GetAuthorizeUrl());
}
public void ResponseConverterShouldHandleCompleteStatus()
{
var response = new RequestTokenResponse(_responses["token"]);
var status = MobileConnectStatus.Complete(response);
var actual = ResponseConverter.Convert(status);
Assert.IsNotNull(actual);
Assert.AreEqual("success", actual.Status);
Assert.AreEqual("complete", actual.Action);
Assert.AreEqual(status.TokenResponse.ResponseData, actual.Token);
}
public void ValidateTokenResponseShouldValidateIfIdTokenIsInvalid()
{
var jwksJson = "{\"keys\":[{\"alg\":\"RS256\",\"e\":\"AQAB\",\"n\":\"hzr2li5ABVbbQ4BvdDskl6hejaVw0tIDYO-C0GBr5lRA-AXtmCO7bh0CEC9-R6mqctkzUhVnU22Vrj-B1J0JtJoaya9VTC3DdhzI_-7kxtIc5vrHq-ss5wo8-tK7UqtKLSRf9DcyZA0H9FEABbO5Qfvh-cfK4EI_ytA5UBZgO322RVYgQ9Do0D_-jf90dcuUgoxz_JTAOpVNc0u_m9LxGnGL3GhMbxLaX3eUublD40aK0nS2k37dOYOpQHxuAS8BZxLvS6900qqaZ6z0kwZ2WFq-hhk3Imd6fweS724fzqVslY7rHpM5n7z5m7s1ArurU1dBC1Dxw1Hzn6ZeJkEaZQ\",\"kty\":\"RSA\",\"use\":\"sig\"}]}";
var rawResponse = new RestResponse(System.Net.HttpStatusCode.Accepted, "{\"access_token\":\"966ad150-16c5-11e6-944f-43079d13e2f3\",\"token_type\":\"Bearer\",\"expires_in\":3600,\"id_token\":\"eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJub25jZSI6IjEyMzQ1Njc4OTAiLCJhdWQiOiJ4LWNsaWVudGlkLXgiLCJhenAiOiJ4LWNsaWVudGlkLXgiLCJpc3MiOiJodHRwOi8vbW9iaWxlY29ubmVjdC5pbyIsImV4cCI6MjE0NzQ4MzY0NywiYXV0aF90aW1lIjoyMTQ3NDgzNjQ3LCJpYXQiOjE0NzEwMDczMjd9.U9c5iuybG4GIvrbQH5BT9AgllRbPL6SuIzL4Y3MW7VlCVIQOc_HFfkiLa0LNvqZiP-kFlADmnkzuuQxPq7IyaOILVYct20mrcOb_U_zMli4jg-t9P3BxHaq3ds9JlLBjz0oewd01ZQtWHgRnrGymfKAIojzHlde-aePuL1M26Eld5zoKQvCLcKAynZsjKsWF_6YdLk-uhlC5ofMOaOoPirPSPAxYvbj91z3o9XIgSHoU-umN7AJ6UQ4H-ulfftlRGK8hz0Yzpf2MHOy9OHg1u3ayfCaaf8g5zKGngcz0LgK9VAw2B31xJw-RHkPPh0Hz82FgBc4588oEFC1c22GGTw\"}");
var tokenResponse = new RequestTokenResponse(rawResponse);
var jwks = JsonConvert.DeserializeObject <JWKeyset>(jwksJson);
string nonce = "1234567890";
string clientId = "x-clientid-x";
int? maxAge = 36000;
var actual = _authentication.ValidateTokenResponse(tokenResponse, clientId, "notissuer", nonce, maxAge, jwks, "mc_v1.2");
Assert.AreEqual(TokenValidationResult.InvalidIssuer, actual);
}
public void ValidateTokenResponseShouldNotValidateIfResponseIsIncomplete()
{
var jwksJson = "{\"keys\":[{\"alg\":\"RS256\",\"e\":\"AQAB\",\"n\":\"hzr2li5ABVbbQ4BvdDskl6hejaVw0tIDYO-C0GBr5lRA-AXtmCO7bh0CEC9-R6mqctkzUhVnU22Vrj-B1J0JtJoaya9VTC3DdhzI_-7kxtIc5vrHq-ss5wo8-tK7UqtKLSRf9DcyZA0H9FEABbO5Qfvh-cfK4EI_ytA5UBZgO322RVYgQ9Do0D_-jf90dcuUgoxz_JTAOpVNc0u_m9LxGnGL3GhMbxLaX3eUublD40aK0nS2k37dOYOpQHxuAS8BZxLvS6900qqaZ6z0kwZ2WFq-hhk3Imd6fweS724fzqVslY7rHpM5n7z5m7s1ArurU1dBC1Dxw1Hzn6ZeJkEaZQ\",\"kty\":\"RSA\",\"use\":\"sig\"}]}";
var rawResponse = new RestResponse(System.Net.HttpStatusCode.Accepted, "");
var tokenResponse = new RequestTokenResponse(rawResponse);
var jwks = JsonConvert.DeserializeObject <JWKeyset>(jwksJson);
string nonce = "1234567890";
string clientId = "x-clientid-x";
string issuer = "http://mobileconnect.io";
int? maxAge = 36000;
var actual = _authentication.ValidateTokenResponse(tokenResponse, clientId, issuer, nonce, maxAge, jwks, "mc_v1.2");
Assert.AreEqual(TokenValidationResult.IncompleteTokenResponse, actual);
}
public static void performLogin()
{
lock (syncLock)
{
var request = new RestRequest("oidc/v1/token", Method.POST);
request.AddParameter("grant_type", "client_credentials");
request.AddParameter("client_id", "b0781e40-2821-4a2d-baed-9b33dbb4167c@apps_vw-dilab_com");
request.AddParameter("client_secret", "9bc2116f0bce1f43ff47632d2b497928a175d3886ad1e5cfc603c6728bb2f36e");
// execute the request
IRestResponse response = accessClient.Execute(request);
var content = response.Content;
sessionInfo = RequestTokenResponse.FromJson(content);
}
}
// Token: 0x06002F1A RID: 12058 RVA: 0x000E4E64 File Offset: 0x000E3264
private void OnRequestTokenCallback(bool success, RequestTokenResponse response)
{
if (success)
{
string text = "OnRequestTokenCallback - succeeded";
text = text + "\n Token : " + response.Token;
text = text + "\n TokenSecret : " + response.TokenSecret;
MonoBehaviour.print(text);
this.m_RequestTokenResponse = response;
API.OpenAuthorizationPage(response.Token);
}
else
{
MonoBehaviour.print("OnRequestTokenCallback - failed.");
}
}
private async void GetRequestTokenButton_Click(object sender, RoutedEventArgs e)
{
try
{
RequestTokenResponse response = await this.twitterOAuth.GetRequestToken();
this.WriteLog(string.Format("ReqestToken: Token={0}, Secret={1}",
response.OAuthRequestToken, response.OAuthRequestTokenSecret));
this.requestToken = response;
}
catch (Exception ex)
{
this.WriteLog(String.Format("ReqestToken: exception: {0}", ex.Message));
}
return;
}
private void OnRequestTokenCallback(bool success, RequestTokenResponse response)
{
if (success)
{
string log = "OnRequestTokenCallback - succeeded";
log += "\n Token : " + response.Token;
log += "\n TokenSecret : " + response.TokenSecret;
print(log);
m_RequestTokenResponse = response;
API.OpenAuthorizationPage(response.Token);
}
else
{
print("OnRequestTokenCallback - failed.");
}
}
internal static async Task <MobileConnectStatus> RefreshToken(IAuthenticationService authentication, string refreshToken, DiscoveryResponse discoveryResponse, MobileConnectConfig config)
{
Validate.RejectNull(discoveryResponse, "discoveryResponse");
Validate.RejectNullOrEmpty(refreshToken, "refreshToken");
if (!IsUsableDiscoveryResponse(discoveryResponse))
{
return(MobileConnectStatus.StartDiscovery());
}
string refreshTokenUrl = discoveryResponse.OperatorUrls.RefreshTokenUrl ?? discoveryResponse.OperatorUrls.RequestTokenUrl;
var notSupported = IsSupported(refreshTokenUrl, "Refresh", discoveryResponse.ProviderMetadata?.Issuer);
if (notSupported != null)
{
return(notSupported);
}
string clientId = discoveryResponse.ResponseData.response.client_id ?? config.ClientId;
string clientSecret = discoveryResponse.ResponseData.response.client_secret ?? config.ClientSecret;
try
{
RequestTokenResponse requestTokenResponse = await authentication.RefreshTokenAsync(clientId, clientSecret, refreshTokenUrl, refreshToken);
ErrorResponse errorResponse = requestTokenResponse.ErrorResponse;
if (errorResponse != null)
{
Log.Error(() => $"Responding with responseType={MobileConnectResponseType.Error} for refreshToken for authentication service responded with error={errorResponse.Error}");
return(MobileConnectStatus.Error(errorResponse));
}
else
{
Log.Info(() => $"Refresh token success");
return(MobileConnectStatus.Complete(requestTokenResponse));
}
}
catch (Exception e)
{
Log.Error(() => $"RefreshToken failed", e);
return(MobileConnectStatus.Error(ErrorCodes.Unknown, "Refresh token error", e));
}
}
private void OnRequestTokenCallback(bool success, RequestTokenResponse response)
{
if (success)
{
Alert.Singleton.CloseAlert(true);
token = response.Token;
Twitter.API.OpenAuthorizationPage(response.Token);
}
else
{
Alert.Singleton.ShowAlert(Alert.Message.ERROR);
}
}
/// <summary>
/// SDK:
/// Get the user's request token and store it in the current user session.
/// </summary>
public RequestTokenResponse GetRequestTokenReponse(string callbackUrl = "http://www.google.com")
{
var oauthParams = OAuthParametersFactory();
oauthParams.addParameter(OAUTH_CALLBACK, callbackUrl);
//oauthParams.addParameter(REALM, "eWallet");
var resp = doRequest(GetURL(), WebRequestMethods.Http.Post, oauthParams, null);
var returnParams = parseOAuthResponseParameters(resp[Connector.MESSAGE]);
var response = new RequestTokenResponse();
response.AuthorizeUrl = HttpUtility.UrlDecode(returnParams["xoauth_request_auth_url"]);
response.RequestToken = returnParams["oauth_token"];
response.CallbackConfirmed = ("true" == returnParams["oauth_callback_confirmed"]);
response.OAuthExpiresIn = returnParams["oauth_expires_in"];
response.OAuthSecret = returnParams["oauth_token_secret"];
return(response);
}
public async Task <EboTradeResponse> CancelTrade(CancelTrade cancelTrade, RequestTokenResponse requestTokenResponse, IEquiasConfiguration equiasConfiguration)
{
try
{
var httpClient = httpClientFactory.CreateClient();
httpClient.BaseAddress = new Uri(equiasConfiguration.ApiDomain);
httpClient.DefaultRequestHeaders.Add("token", requestTokenResponse?.Token);
return(await DeleteAsync <CancelTrade, EboTradeResponse>(httpClient, equiasConfiguration.CancelTradeUri, cancelTrade, false));
}
catch (Exception ex)
{
logger.LogError(ex, "{Message}", ex.Message);
return(new EboTradeResponse
{
IsSuccessStatusCode = false,
Message = ex.Message
});
}
}
public async Task <ConfirmationResponse> SendConfirmation(string method, string companyId, ConfirmationRequest confirmationRequest,
RequestTokenResponse requestTokenResponse, IFidectusConfiguration fidectusConfiguration)
{
async Task <ConfirmationResponse> PostConfirmationAsync(HttpClient httpClient)
{
return(await PostAsync <ConfirmationRequest, ConfirmationResponse>(httpClient, fidectusConfiguration.FidectusConfirmationUrl, confirmationRequest, false));
}
async Task <ConfirmationResponse> PutConfirmationAsync(HttpClient httpClient)
{
return(await PutAsync <ConfirmationRequest, ConfirmationResponse>(httpClient, $"{fidectusConfiguration.FidectusConfirmationUrl}/{confirmationRequest.TradeConfirmation?.DocumentId}", confirmationRequest, false));
}
async Task <ConfirmationResponse> HttpMethod(string httpMethod, HttpClient httpClient)
{
return(httpMethod switch
{
"POST" => await PostConfirmationAsync(httpClient),
"PUT" => await PutConfirmationAsync(httpClient),
_ => throw new Exception($"Unknown HTTP method ({method})")
});
}
public async Task <EboTradeResponse> ModifyPhysicalTrade(PhysicalTrade physicalTrade, RequestTokenResponse requestTokenResponse, IEquiasConfiguration equiasConfiguration)
{
try
{
logger.LogInformation("Physical Trade: {PhysicalTrade}", TradeCubeJsonSerializer.Serialize(physicalTrade));
var httpClient = httpClientFactory.CreateClient();
httpClient.BaseAddress = new Uri(equiasConfiguration.ApiDomain);
httpClient.DefaultRequestHeaders.Add("token", requestTokenResponse?.Token);
return(await PostAsync <PhysicalTrade, EboTradeResponse>(httpClient, equiasConfiguration.ModifyPhysicalTradeUri, physicalTrade, false));
}
catch (Exception ex)
{
logger.LogError(ex, "{Message}", ex.Message);
return(new EboTradeResponse
{
IsSuccessStatusCode = false,
Message = ex.Message
});
}
}
public async Task <EboGetTradeStatusResponse> EboGetTradeStatus(IEnumerable <string> tradeIds, RequestTokenResponse requestTokenResponse, IEquiasConfiguration equiasConfiguration)
{
try
{
var httpClient = httpClientFactory.CreateClient();
httpClient.BaseAddress = new Uri(equiasConfiguration.ApiDomain);
httpClient.DefaultRequestHeaders.Add("token", requestTokenResponse?.Token);
return(await PostAsync <IEnumerable <string>, EboGetTradeStatusResponse>(httpClient, equiasConfiguration.GetTradeStatusUri, tradeIds, false));
}
catch (Exception ex)
{
logger.LogError(ex, "{Message}", ex.Message);
throw;
}
}
/// <summary>
/// Creates a Status with ResponseType error and error related properties filled.
/// Indicates that the MobileConnect process has been aborted due to an issue encountered.
/// </summary>
/// <param name="error">Error code</param>
/// <param name="message">User friendly error message</param>
/// <param name="ex">Exception encountered (allows null)</param>
/// <param name="response">RequestTokenResponse if returned from <see cref="IAuthentication"/></param>
/// <returns>MobileConnectStatus with ResponseType Error</returns>
public static MobileConnectStatus Error(string error, string message, Exception ex, RequestTokenResponse response)
{
var status = Error(error, message, ex);
status.TokenResponse = response;
return(status);
}
private async Task <EboTradeResponse> ModifyPhysicalTradeAsync(PhysicalTrade physicalTrade, RequestTokenResponse requestTokenResponse, string apiJwtToken)
{
return(await equiasService.ModifyPhysicalTrade(physicalTrade, requestTokenResponse, new EquiasConfiguration(await GetEquiasDomainAsync(apiJwtToken))));
}
private static MobileConnectStatus HandleTokenResponse(IAuthenticationService authentication, RequestTokenResponse response, string clientId, string issuer, string expectedNonce,
string version, JWKeyset jwks, MobileConnectRequestOptions options)
{
if (response.ErrorResponse != null)
{
return(MobileConnectStatus.Error(response.ErrorResponse.Error, response.ErrorResponse.ErrorDescription, null, response));
}
response.ValidationResult = authentication.ValidateTokenResponse(response, clientId, issuer, expectedNonce, options?.MaxAge, jwks, version);
var validationOptions = options?.TokenValidationOptions ?? new TokenValidationOptions();
if (!validationOptions.AcceptedValidationResults.HasFlag(response.ValidationResult))
{
Log.Error(() => $"A generated tokenResponse was invalid issuer={issuer} version={version} result={response.ValidationResult}");
return(MobileConnectStatus.Error(ErrorCodes.InvalidToken, $"The token was found to be invalid with the validation result {response.ValidationResult}", null, response));
}
else if (response.ValidationResult != TokenValidationResult.Valid)
{
Log.Warning(() => $"A generated tokenResponse was invalid but accepted issuer={issuer} version={version} result={response.ValidationResult}");
}
return(MobileConnectStatus.Complete(response));
}
internal static async Task <MobileConnectStatus> RequestHeadlessAuthentication(IAuthenticationService authentication, IJWKeysetService jwks, IIdentityService identity, DiscoveryResponse discoveryResponse, string encryptedMSISDN,
string state, string nonce, MobileConnectConfig config, MobileConnectRequestOptions options, CancellationToken cancellationToken = default(CancellationToken))
{
if (!IsUsableDiscoveryResponse(discoveryResponse))
{
return(MobileConnectStatus.StartDiscovery());
}
MobileConnectStatus status;
try
{
string clientId = discoveryResponse.ResponseData.response.client_id ?? config.ClientId;
string clientSecret = discoveryResponse.ResponseData.response.client_secret;
string authorizationUrl = discoveryResponse.OperatorUrls.AuthorizationUrl;
string tokenUrl = discoveryResponse.OperatorUrls.RequestTokenUrl;
string issuer = discoveryResponse.ProviderMetadata.Issuer;
SupportedVersions supportedVersions = discoveryResponse.ProviderMetadata.MobileConnectVersionSupported;
AuthenticationOptions authOptions = options?.AuthenticationOptions ?? new AuthenticationOptions();
authOptions.ClientName = discoveryResponse.ApplicationShortName;
var jwksTask = jwks.RetrieveJWKSAsync(discoveryResponse.OperatorUrls.JWKSUrl);
var tokenTask = authentication.RequestHeadlessAuthentication(clientId, clientSecret, authorizationUrl, tokenUrl, config.RedirectUrl, state, nonce,
encryptedMSISDN, supportedVersions, authOptions, cancellationToken);
// execute both tasks in parallel
await Task.WhenAll(tokenTask, jwksTask).ConfigureAwait(false);
RequestTokenResponse response = tokenTask.Result;
status = HandleTokenResponse(authentication, response, clientId, issuer, nonce,
discoveryResponse.ProviderMetadata.MobileConnectVersionSupported.MaxSupportedVersionString, jwksTask.Result, options);
}
catch (MobileConnectInvalidArgumentException e)
{
Log.Error(() => $"An invalid argument was passed to RequestHeadlessAuthentication arg={e.Argument}");
return(MobileConnectStatus.Error(ErrorCodes.InvalidArgument, string.Format("An argument was found to be invalid during the process. The argument was {0}.", e.Argument), e));
}
catch (MobileConnectEndpointHttpException e)
{
Log.Error(() => $"A general http error occurred in RequestHeadlessAuthentication state={state} nonce={nonce} authUrl={discoveryResponse.OperatorUrls.AuthorizationUrl} tokenUrl={discoveryResponse.OperatorUrls.RequestTokenUrl}");
return(MobileConnectStatus.Error(ErrorCodes.HttpFailure, "An HTTP failure occured while calling the discovery endpoint, the endpoint may be inaccessible", e));
}
catch (Exception e)
{
Log.Error(() => $"A general error occurred in RequestHeadlessAuthentication state={state} nonce={nonce} authUrl={discoveryResponse.OperatorUrls.AuthorizationUrl} tokenUrl={discoveryResponse.OperatorUrls.RequestTokenUrl}");
return(MobileConnectStatus.Error(ErrorCodes.Unknown, "An unknown error occured while generating an authorization url", e));
}
if (status.ResponseType == MobileConnectResponseType.Error ||
!options.AutoRetrieveIdentityHeadless || string.IsNullOrEmpty(discoveryResponse.OperatorUrls.PremiumInfoUrl))
{
return(status);
}
var identityStatus = await RequestIdentity(identity, discoveryResponse, status.TokenResponse.ResponseData.AccessToken, config, options);
status.IdentityResponse = identityStatus.IdentityResponse;
return(status);
}
/// <summary>
/// Creates a Status with ResponseType error and error related properties filled.
/// Indicates that the MobileConnect process has been aborted due to an issue encountered.
/// </summary>
/// <param name="error">Error code</param>
/// <param name="message">User friendly error message</param>
/// <param name="ex">Exception encountered (allows null)</param>
/// <param name="response">RequestTokenResponse if returned from <see cref="IAuthenticationService"/></param>
/// <param name="caller">Name of calling method</param>
/// <returns>MobileConnectStatus with ResponseType Error</returns>
public static MobileConnectStatus Error(string error, string message, Exception ex, RequestTokenResponse response, [CallerMemberName] string caller = null)
{
var status = Error(error, message, ex, caller);
status.TokenResponse = response;
return(status);
}
public string GetoAuthToken()
{
string response = string.Empty;
//string gotoAddress = string.Empty;
try
{
EventfuloAuthModel GetrequestToken = GetRequestToken();
if (GetrequestToken.oauth_callback_confirmed.ToUpper() == "TRUE")
{
RequestTokenResponse tokenResponse = new RequestTokenResponse();
tokenResponse.URL = URLConstants.AuthorizeTokenBaseURI + "" + GetrequestToken.oauth_token;
tokenResponse.RequestTokenSecret = GetrequestToken.oauth_token_secret;
var json = new JavaScriptSerializer().Serialize(tokenResponse);
response = json.ToString();
}
//response = AuthorizeToken(GetrequestToken.oauth_token);
Console.WriteLine(response);
#region browser
//if (response.Contains("DOCTYPE html"))
//{
// //HTMLDocument hTMLDocument = new HTMLDocument();
// //hTMLDocument.
// //doc.LoadHtml(response);
// //doc.GetElementbyId("inp-username").SetAttributeValue("value", "varunMiddleware");
// //doc.GetElementbyId("inp-password").SetAttributeValue("value", "Billion@12");
// //string gotoAddress = doc.GetElementbyId("signin-form").SelectSingleNode("//input[@type='hidden' and @name='goto']").Attributes["value"].Value;
// //var button = doc.GetElementbyId("inp-signin").SetAttributeValue("click", "true");
// //HtmlButton htmlButton = (HtmlButton)button;
// var browser = new Browser();
// browser.SetContent(response);
// browser.Url = new Uri("http://eventful.com/signin?goto=/oauth/authorize?oauth_token="+ GetrequestToken.oauth_token);
// //browser.CurrentState.Url = new Uri("http://eventful.com/signin");
// if (browser.Find("inp-username").Exists)
// {
// var username = browser.Find("inp-username");
// username.Value = ""+Globals.username;
// }
// if (browser.Find("inp-password").Exists)
// browser.Find("inp-password").Value = Globals.password;
// if (browser.Find(ElementType.TextField, "name", "goto").Exists)
// gotoAddress = browser.Find(ElementType.TextField,"name","goto").Value;
// browser.Find("signin-form").SubmitForm();
// if (LastRequestFailed(browser)) throw new Exception();
// if (browser.ContainsText("Incorrect login or password"))
// {
// browser.Log("Login failed!", LogMessageType.Error);
// }
// else
// {
// browser.Log("* Login Success!!!");
// }
// //string data = Globals.username + '&' + Globals.password + '&' + gotoAddress;
// //response = PostResponseFromWeb(URLConstants.EventfulBaseURI + "signin", data);
//}
#endregion
}
catch (Exception Ex)
{
throw Ex;
}
return(response);
}
public async Task <OAuth2Token> RequestTokenAsync(Uri tokenEndpoint, string authorizationCode, string redirectUri)
{
/* STEP 1: validate all arguments */
// validate our tokenEndpoint uri
if (tokenEndpoint == null)
{
throw new ArgumentNullException(nameof(tokenEndpoint));
}
else if (tokenEndpoint.Scheme.ToLowerInvariant() != "https")
{
throw new ArgumentException("tokenEndpoint must be secured with the https protocol.", nameof(tokenEndpoint));
}
if (authorizationCode == null)
{
throw new ArgumentNullException(nameof(authorizationCode));
}
/* validate redirectUri: make sure that the redirectUri uses HTTPS or a non-HTTP protocol (e.g. an app-specific protocol on a mobile
* device). HTTP is also valid with a redirectUri--but only for the localhost. */
if (redirectUri != null)
{
// break the redirectUri down into its components (scheme, host, etc.)
Uri uri;
try
{
uri = new Uri(redirectUri);
}
catch
{
throw new ArgumentException("redirectUri is a malformed redirect uri.", nameof(redirectUri));
}
//
if (uri.Host == null)
{
throw new ArgumentException("redirectUri is a malformed redirect uri.", nameof(redirectUri));
}
//
switch (uri.Scheme.ToLowerInvariant())
{
case "http":
// HTTP scheme is okay as long as the server is localhost (i.e. communication is on the loopback interface).
if (uri.Host != "127.0.0.1" && uri.Host != "::1" && uri.Host.ToLowerInvariant() != "localhost")
{
throw new ArgumentException("redirectUri must be secured with the https protocol.", nameof(redirectUri));
}
break;
case "https":
// HTTPS scheme is okay
break;
default:
// custom app-specific schemes are okay
break;
}
}
/* STEP 2: create our WwwFormUrlencoded request payload */
Dictionary <string, string> formParameters = new Dictionary <string, string>();
formParameters["grant_type"] = OAuth2Convert.ConvertGrantTypeToString(OAuth2GrantType.AuthorizationCode);
formParameters["code"] = authorizationCode;
if (redirectUri != null)
{
formParameters["redirect_uri"] = redirectUri;
}
// if we have a client secret, we will authenticate via HTTP BASIC auth; otherwise, pass in our client_id as a form paramter
if (this.Secret == null)
{
formParameters["client_id"] = this.Id;
}
/* STEP 3: send our access token request */
try
{
using (HttpClient httpClient = new HttpClient())
{
// create request
var requestMessage = new HttpRequestMessage(HttpMethod.Post, tokenEndpoint);
requestMessage.Content = new HttpFormUrlEncodedContent(formParameters);
requestMessage.Headers.Accept.Clear();
requestMessage.Headers.Accept.Add(new Windows.Web.Http.Headers.HttpMediaTypeWithQualityHeaderValue("application/json"));
// if we have a client secret, add our client_id and client_secret to authenticate via HTTP Basic authentication
if (this.Secret != null)
{
string authorizationCredentialString = this.Id + ":" + this.Secret;
requestMessage.Headers.Authorization = new Windows.Web.Http.Headers.HttpCredentialsHeaderValue("Basic", Convert.ToBase64String(System.Text.Encoding.ASCII.GetBytes(authorizationCredentialString)));
}
// send request
HttpResponseMessage responseMessage = await httpClient.SendRequestAsync(requestMessage);
// process response
switch (responseMessage.StatusCode)
{
case HttpStatusCode.Ok:
{
// token was requested; parse response
RequestTokenResponse responsePayload = JsonConvert.DeserializeObject <RequestTokenResponse>(await responseMessage.Content.ReadAsStringAsync());
if (responsePayload.token_type.ToLowerInvariant() != "bearer")
{
throw new OAuth2ServerErrorException();
}
OAuth2Token token = new OAuth2Token()
{
Id = responsePayload.access_token
};
if (responsePayload.expires_in != null)
{
token.ExpiresAt = DateTimeOffset.UtcNow.AddSeconds(long.Parse(responsePayload.expires_in.Value.ToString()));
}
//if (responsePayload.refresh_token != null)
//{
// token.RefreshTokenId = responsePayload.refresh_token;
//}
//if (responsePayload.scope != null)
//{
// token.Scope = responsePayload.scope;
//}
return(token);
}
case HttpStatusCode.BadRequest:
{
// process the "bad request" response
OAuth2ErrorResponse responsePayload = JsonConvert.DeserializeObject <OAuth2ErrorResponse>(await responseMessage.Content.ReadAsStringAsync());
if (responsePayload.error == null)
{
throw new OAuth2ServerErrorException();
}
switch (responsePayload.error.ToLowerInvariant())
{
case "invalid_request":
throw new ArgumentException(responsePayload.error_description ?? responsePayload.error);
case "invalid_client":
throw new OAuth2InvalidClientException(responsePayload.error_description ?? responsePayload.error);
case "invalid_grant":
throw new ArgumentException(responsePayload.error_description ?? responsePayload.error, nameof(authorizationCode));
case "unauthorized_client":
throw new OAuth2UnauthorizedClientException(responsePayload.error_description ?? responsePayload.error);
//case "unsupported_grant_type":
// // NOTE: this error should never occur when requesting a token via authorization_code
//case "invalid_scope":
// // NOTE: this error should never occur when requesting a token via authorization_code
default:
throw new OAuth2HttpException(responseMessage.StatusCode);
}
}
case HttpStatusCode.TooManyRequests:
throw new OAuth2TooManyRequestsException();
case HttpStatusCode.InternalServerError:
throw new OAuth2ServerErrorException();
case HttpStatusCode.ServiceUnavailable:
throw new OAuth2ServiceUnavailableException();
default:
throw new OAuth2HttpException(responseMessage.StatusCode);
}
}
}
catch (JsonException)
{
// JSON parsing error; this is catastrophic.
throw new OAuth2ServerErrorException();
}
catch
{
// NOTE: callers must catch non-HTTP networking exceptions
throw;
}
}
