protected void identifierBox_LoggedIn(object sender, OpenIdEventArgs e)
{
this.RegisterAsyncTask(
new PageAsyncTask(
async ct => {
State.FetchResponse = e.Response.GetExtension <FetchResponse>();
var serviceDescription = new ServiceProviderDescription {
TokenRequestEndpoint = new Uri(e.Response.Provider.Uri, "/access_token.ashx"),
};
var consumer = CreateConsumer();
consumer.ServiceProvider = serviceDescription;
AccessTokenResponse accessToken = await consumer.ProcessUserAuthorizationAsync(e.Response);
if (accessToken != null)
{
this.MultiView1.SetActiveView(this.AuthorizationGiven);
// At this point, the access token would be somehow associated with the user
// account at the RP.
////Database.Associate(e.Response.ClaimedIdentifier, accessToken.AccessToken);
}
else
{
this.MultiView1.SetActiveView(this.AuthorizationDenied);
}
// Avoid the redirect
e.Cancel = true;
}));
}
// Token: 0x060054E8 RID: 21736 RVA: 0x001D47F8 File Offset: 0x001D2BF8
private void OnAccessTokenCallback(bool success, AccessTokenResponse response)
{
if (success)
{
string text = "OnAccessTokenCallback - succeeded";
text = text + "\n UserId : " + response.UserId;
text = text + "\n ScreenName : " + response.ScreenName;
text = text + "\n Token : " + response.Token;
text = text + "\n TokenSecret : " + response.TokenSecret;
MonoBehaviour.print(text);
Tweeter.Instance.accessTokenResponse = response;
PlayerPrefs.SetString("TwitterUserID", response.UserId);
PlayerPrefs.SetString("TwitterUserScreenName", response.ScreenName);
PlayerPrefs.SetString("TwitterUserToken", response.Token);
PlayerPrefs.SetString("TwitterUserTokenSecret", response.TokenSecret);
this.connectButton.gameObject.SetActive(false);
this.disconnectButton.gameObject.SetActive(true);
this.inputField.gameObject.SetActive(false);
this.statusText.text = response.ScreenName;
}
else
{
MonoBehaviour.print("OnAccessTokenCallback - failed.");
this.connectButton.gameObject.SetActive(true);
this.disconnectButton.gameObject.SetActive(false);
this.inputField.text = string.Empty;
this.inputField.gameObject.SetActive(false);
this.statusText.text = "Bad Pin";
}
}
void Start()
{
if (!File.Exists(FileName))
{
return;
}
// 読込
string config = File.ReadAllText(FileName);
config = AESCryption.Decrypt(config);
string[] token = config.Split(',');
Access = new AccessTokenResponse
{
Token = token[0],
TokenSecret = token[1],
UserId = token[2],
ScreenName = token[3]
};
// 認証済
Text.text = Ready;
Input.placeholder.GetComponent <Text>().text = PlaceholderReady;
}
/// <summary>
/// This method will get the BlizzardAccess token using my credentials.
/// </summary>
/// <returns></returns>
public static async Task GetBlizzardAccessToken()
{
// Get my blizzard token from environmentvariable
string clientSecret = Environment.GetEnvironmentVariable("BLIZZARDTOKEN");
// Create our client
using (HttpClient client = new HttpClient())
{
// Authorization
string auth = Convert.ToBase64String(Encoding.ASCII.GetBytes($"4329a43854634303a426830ceabb767d:{clientSecret}"));
// Headers
client.DefaultRequestHeaders.Add("cache-control", "no-cache");
client.DefaultRequestHeaders.Add("Authorization", $"Basic {auth}");
// Content
HttpContent hc = new StringContent("grant_type=client_credentials", Encoding.UTF8, "application/x-www-form-urlencoded");
// Request our data and record response
HttpResponseMessage response = await client.PostAsync("https://eu.battle.net/oauth/token", hc);
if (response.IsSuccessStatusCode)
{
// Deserialize the token
AccessTokenResponse tokenResponse = await response.Content.ReadAsAsync <AccessTokenResponse>();
// Store Token
BlizzAccessToken = tokenResponse.AccessToken;
}
}
}
public static AccessTokenResponse postAccessTokenFromAuthCode()
{
AccessTokenResponse result = null;
try
{
configDictionary = GetConfiguration();
configDictionary["authenticationType"] = "Mutual_Auth";
var clientConfig = new CyberSource.Client.Configuration(merchConfigDictObj: configDictionary);
var requestObj = new CreateAccessTokenRequest(
Code: code,
GrantType: grantType,
ClientId: configDictionary["clientId"],
ClientSecret: configDictionary["clientSecret"]
);
var apiInstance = new OAuthApi(clientConfig);
result = apiInstance.PostAccessTokenRequest(requestObj);
Console.WriteLine(result);
return(result);
}
catch (Exception e)
{
Console.WriteLine("Exception on calling the API : " + e.Message);
return(null);
}
}
/// <summary>
/// Check if authentication succeeded after user is redirected back from the service provider.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>
/// An instance of <see cref="AuthenticationResult" /> containing authentication result.
/// </returns>
public virtual async Task <AuthenticationResult> VerifyAuthenticationAsync(HttpContextBase context, CancellationToken cancellationToken = default(CancellationToken))
{
AccessTokenResponse response = await this.WebWorker.ProcessUserAuthorizationAsync(context, cancellationToken);
if (response == null)
{
return(AuthenticationResult.Failed);
}
AuthenticationResult result = await this.VerifyAuthenticationCoreAsync(response, cancellationToken);
if (result.IsSuccessful && result.ExtraData != null)
{
// add the access token to the user data dictionary just in case page developers want to use it
var wrapExtraData = new NameValueCollection(result.ExtraData);
wrapExtraData["accesstoken"] = response.AccessToken.Token;
wrapExtraData["accesstokensecret"] = response.AccessToken.Secret;
AuthenticationResult wrapResult = new AuthenticationResult(
result.IsSuccessful,
result.Provider,
result.ProviderUserId,
result.UserName,
wrapExtraData);
result = wrapResult;
}
return(result);
}
// NOTE: this is ultimately the method that gets called by other controllers to ensure user has authorized the app
// STATUS [ June 8, 2019 ] : this works
// STEP 3
/// <summary>
/// Retrieve response from Yahoo.
/// Create a new instance of AccessTokenResponse from yahoo response
/// </summary>
/// <returns> A new AccessTokenResponse that includes: AccessToken, TokenType, ExpiresIn, RefreshToken, XOAuthYahooGuid</returns>
public AccessTokenResponse GetYahooAccessTokenResponse()
{
// _helpers.StartMethod();
JObject responseToJson;
bool userHasRefreshToken = CheckIfUserHasExistingRefreshToken();
// userHasRefreshToken = false;
Console.WriteLine($"User has refresh token?: {userHasRefreshToken}");
if (!userHasRefreshToken)
{
responseToJson = CreateYahooAccessTokenResponseJObject();
AccessTokenResponse finalAccessTokenResponse = GenerateYahooAccessTokenResponse(responseToJson);
_helpers.Dig(finalAccessTokenResponse);
return(finalAccessTokenResponse);
}
if (userHasRefreshToken)
{
responseToJson = ExchangeRefreshTokenForNewAccessTokenJObject();
AccessTokenResponse finalAccessTokenResponse = GenerateYahooAccessTokenResponse(responseToJson);
return(finalAccessTokenResponse);
}
else
{
Console.WriteLine("ERROR IN: YahooAuthController.GetYahooAccessTokenResponse()");
return(null);
}
}
public void UpsertCustomer(AccessTokenResponse response)
{
using (var uow = GetUnitOfWork())
{
var customer =
uow.Repository <ZY_Customer>()
.Query()
.Filter(x => x.OpenId == response.openid)
.Get()
.FirstOrDefault();
if (customer == null)
{
customer = new ZY_Customer
{
OpenId = response.openid,
UserName = "",
TokenId = response.access_token
};
uow.Repository <ZY_Customer>().Insert(customer);
}
else
{
customer.TokenId = response.access_token;
uow.Repository <ZY_Customer>().Update(customer);
}
uow.Save();
//todo load name
}
}
public async Task <string> GetReadAccessTokenAsync()
{
var readAccessUrl = GetReadAccessUrl();
AccessTokenResponse accessToken = await _vimeoClient.GetAccessTokenAsync(readAccessUrl, _vimeoCredential?.RedirectionUrl);
return(accessToken.AccessToken);
}
/// <summary>
/// Generate a JWT Token Response Object for specified User Identity
/// </summary>
/// <returns>Response Object containing JWT Token and Expiry Time</returns>
public async Task <AccessTokenResponse> GenerateJWTokenResponseAsync(ApplicationUser user)
{
// Set Token Timeouts
var now = DateTime.UtcNow;
var dateTimeOffset = new DateTimeOffset(now);
var unixNow = dateTimeOffset.ToUnixTimeSeconds().ToString();
// Get the Users Claims / Roles
List <Claim> claims = new List <Claim>
{
new Claim(JwtRegisteredClaimNames.NameId, user.Id.ToString()),
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()),
new Claim(JwtRegisteredClaimNames.Iat, unixNow, ClaimValueTypes.Integer64),
// new Claim(ClaimTypes.Role, "TestRole"),
};
// Add Roles to Claims
var roles = await _userService.GetRolesForUserAsync(user);
foreach (var role in roles)
{
claims.Add(new Claim(ClaimTypes.Role, role));
}
var response = new AccessTokenResponse
{
AccessToken = GetToken(now, claims),
ExpiresIn = (int)_appSettings.JWTConfiguration.Expiration,
Id = user.Id,
Name = user.Email
};
// Serialize and return the response
return(response);
}
public async Task <string> GetFullAccessTokenAsync()
{
var fullAccessUrl = GetFullAccessUrl();
AccessTokenResponse accessToken = await _vimeoClient.GetAccessTokenAsync("thfthfgh", _vimeoCredential?.RedirectionUrl);
return(accessToken.AccessToken);
}
private AccessTokenResponse AuthenticateByUsernameAndPassword(UserAuthentication userAuthen)
{
var user = repository.GetUserByUsername(userAuthen.Username);
AccessTokenResponse token = null;
UserAuthenticationValidation validation = new UserAuthenticationValidation();
var validationResult = validation.Validate(userAuthen);
if (!validationResult.IsValid || user == null)
{
throw new BaseException(ErrorMessage.CREDENTIALS_NOT_MATCH);
}
var result = PasswordManipulation.VerifyPasswordHash(userAuthen.Password,
user.PasswordHash, user.PasswordSalt);
if (user != null && result)
{
token = CreateToken(user);
}
else
{
throw new BaseException(ErrorMessage.CREDENTIALS_NOT_MATCH);
}
return(token);
}
// privates
private async Task <AccessTokenResponse> GetAccessTokenAsync(HttpClient client)
{
/*
*** If success, returns something as follows:
***{
*** "access_token": "AQAAANCMnd8BFdERjHoAwE_Cl-sBAAAAL0Tx4aDDzEy32ulnOq3LdwAAAAACAAAAAAADZgAAwAAAABAAAAANbKP3adQpekCa-oSGJn8ZAAAAAASAAACgAAAAEAAAAH3Rzt0q4gfIsP4XhjB7cScIAQAAmj0CKW5XuJx2nadjiZcFRYLZPbF3NRUZnuc5C0-BQS4iJ04LQgErgv-bAYpO8WuDLW9RRUjFWAEpvWSY8ohmAPojWqNWrHcwe3bMeXLK7lBT12YJo0EgbeWKRgKer-yhctn3HybHuf43fGrej7RgzTca_0aKXQRV38uIv6LN7t9_ebx1Ov7QYZmoTZPqbbXhFPvjr0hRxEljUrJbABU_lS3FOz5hMTs0k8pz5WfH4BBJr2oqTMwxRrstQDUKUs0gcFAJKSOpjxbuKyqVbD7cFHJEKhbRQZO_9T_oQY29BxRXFysxCDWrWkJj0Crn1RB3Tw4v-ytZ1jDDTeOOBtJnXHIzBNvC-1vuFAAAAM3K3bYpIoId8XWs6JNc3O7vQD2I",
*** "token_type": "bearer",
*** "expires_in": 1209600,
*** "refresh_token": "AQAAANCMnd8BFdERjHoAwE_Cl-sBAAAAL0Tx4aDDzEy32ulnOq3LdwAAAAACAAAAAAADZgAAwAAAABAAAAAVRydlGVhaZNrxt4-oNdyxAAAAAASAAACgAAAAEAAAAEqR-EIUM99O9sMHbJkeJPoIAQAAeddehchEbWjQiLCH8DiPRbZ_KLCBbhwPufIH7sGgBSAeZI9RDPwYTt0ThzOt6Ea9XCmPgv63WNY86UdlwUDy4fIY2g4sRxL9MrB0TEYt90tOJQojxVWFAvDOkxn_E5Mz5IuAJ3cGuZYLaxCxGJW4G_eBOrFsDPlOCQll1Pd6VEI_DYGFzfmVR3KsW41OyAyKnO-388zylouaM31chOC0aj6JiOW2YwJMhfGxKBZgq6gSZba2oMW327LT0vGLm4c3rHVvU5TkeyfgnRIO7s4mUh4FyEgmLFR32a9NyRDQj5ir3i86U2SMPPuJiR8F8trT_6E07_ASYQdtEnQr-pHQUgM46IWWJOD4FAAAAECwQpRIKa_rKdOtYawVhw8H3Fs9"
***}
*/
using (HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, "http://localhost:12345/token"))
{
List <KeyValuePair <string, string> > values = new List <KeyValuePair <string, string> > {
new KeyValuePair <string, string>(Constants.Parameters.GrantType, Constants.GrantTypes.Password),
new KeyValuePair <string, string>(Constants.Parameters.Username, UserName),
new KeyValuePair <string, string>(Constants.Parameters.Password, Password),
new KeyValuePair <string, string>(Constants.Parameters.Scope, "Read Write")
};
// client_id and client_secret: http://tools.ietf.org/html/rfc6749#section-2.3.1
request.Headers.Authorization = new AuthenticationHeaderValue("Basic", EncodeToBase64(string.Format("{0}:{1}", ClientId, ClientSecret)));
request.Content = new FormUrlEncodedContent(values);
using (HttpResponseMessage response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
AccessTokenResponse result = await response.Content.ReadAsAsync <AccessTokenResponse>();
return(result);
}
}
}
public object Get(AccessToken request)
{
AccessTokenResponse rsp = new AccessTokenResponse();
_wxService.GetAccessToken(request, rsp);
return(rsp);
}
public ActionResult <IEnumerable <string> > Get()
{
_logger.LogInformation("你访问了首页");
_logger.LogWarning("警告信息");
_logger.LogError("错误信息");
string CorpID = "dingb578e1d0be14c3f135c2f4657eb6378f"; // ConfigHelper.FetchCorpID();
string CorpSecret = "p_FeZ6xm3cnnDDdcvvbFbWc9uKyimvZjzmAAJ-csDkwE5oE7XeeHY-WLtLuvWbeM"; // ConfigHelper.FetchCorpSecret();
string TokenUrl = "https://oapi.dingtalk.com/gettoken";
string apiurl = $"{TokenUrl}?corpid={CorpID}&corpsecret={CorpSecret}";
WebRequest request = WebRequest.Create(@apiurl);
request.Method = "GET";
WebResponse response = request.GetResponse();
Stream stream = response.GetResponseStream();
Encoding encode = Encoding.UTF8;
StreamReader reader = new StreamReader(stream, encode);
string resultJson = reader.ReadToEnd();
AccessTokenResponse tokenResult = JsonConvert.DeserializeObject <AccessTokenResponse>(resultJson);
if (tokenResult.ErrCode == ErrCodeEnum.OK)
{
}
return(new string[] { "value1", "value2" });
}
public async Task <AccessTokenResponse> RequestAccessToken(string idToken)
{
AccessTokenResponse response;
try
{
response = await b2cBaseUrl
.AppendPathSegment("token")
.PostUrlEncodedAsync(new
{
client_id = ClientId,
code_verifier = httpContext.Request.Cookies["c"],
client_secret = ClientSecret,
code = idToken,
grant_type = "authorization_code",
redirect_uri = RedirectUrl,
scope = string.Join(" ", Scopes)
}, CancellationToken.None).ReceiveJson <AccessTokenResponse>();
AddToCache("accessToken", response);
}
catch (FlurlHttpException e)
{
response = new AccessTokenResponse
{
access_token = $"{e.Message} - {e.GetResponseStringAsync().Result}"
};
}
return(response);
}
public static void WriteToLocalJsonFile(this AccessTokenResponse tokenResponse)
{
string json = JsonConvert.SerializeObject(tokenResponse);
string jsonPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "token.json");
File.WriteAllText(jsonPath, json);
}
public bool SyncMessages(SyncMessageSettingsModel model, AccessTokenResponse token)
{
try
{
for (var i = 0; i < model.SyncMessageCount; i++)
{
var lastSyncedMessageCount = this.vkMessageRepository.All().Count();
var messagesList = this.vkApiProvider.LoadMessagesByUserId(token.AccessToken,
model.OwnerUserId.ToString(), 200, lastSyncedMessageCount);
var messagesDbList = Mapper.Map <List <DialogMessage>, List <VkMessage> >(messagesList.ToList());
foreach (var message in messagesDbList)
{
this.vkMessageRepository.Create(message);
}
}
this.vkMessageRepository.SaveChanges();
return(true);
}
catch (Exception ex)
{
return(false);
}
}
/// <summary>Processes the login using the specified username and password.</summary>
/// <param name="model">The login model.</param>
/// <returns>An action result.</returns>
public virtual async Task <ISentinelIdentity> ProcessLogin(LoginModel model)
{
AccessTokenResponse tokenResponse = null;
try
{
tokenResponse = await this.oauthClient.Authenticate(model.Username, model.Password, new[] { "openid" });
}
catch (HttpRequestException ex)
{
this.log.Error(ex);
this.ModelState.AddModelError("Common", "The server seems to be having some problems right now, please try again later");
return(SentinelIdentity.Anonymous);
}
catch (Exception ex)
{
this.log.Error(ex);
}
if (string.IsNullOrEmpty(tokenResponse?.AccessToken))
{
this.ModelState.AddModelError("Common", "Username or password is invalid");
return(SentinelIdentity.Anonymous);
}
return(await this.ProcessTokenResponse(tokenResponse, model.RememberMe, model.ReturnUrl));
}
/// <summary>Process the token response from the API.</summary>
/// <param name="tokenResponse">The access token response.</param>
/// <param name="rememberMe">true to remember login.</param>
/// <param name="returnUrl">The return url.</param>
/// <returns>A Task.</returns>
private async Task <ISentinelIdentity> ProcessTokenResponse(AccessTokenResponse tokenResponse, bool rememberMe, string returnUrl)
{
// Log in using Sentinel authentication handler
if (!string.IsNullOrEmpty(tokenResponse.IdToken))
{
var jwt = new JsonWebToken(tokenResponse.IdToken);
var props = new AuthenticationProperties()
{
IsPersistent = rememberMe,
RedirectUri = returnUrl
};
// Create identity
var cookieIdentity = jwt.ToIdentity(DefaultAuthenticationTypes.ApplicationCookie).ToClaimsIdentity();
cookieIdentity.AddClaim(new Claim("access_token", tokenResponse.AccessToken));
// Sign in temporarily
this.Authentication.SignIn(props, cookieIdentity);
return(new SentinelIdentity(cookieIdentity));
}
this.log.Warn($"No id_token received, unable to log in using {DefaultAuthenticationTypes.ApplicationCookie}");
return(SentinelIdentity.Anonymous);
}
/// <inheritdoc />
public async Task <PlaidResult <AccessTokenResponse> > ExchangePublicTokenForAccessTokenAsync(string publicToken)
{
//conditions
Condition.Requires(publicToken).IsNotNullOrWhiteSpace();
//create the payload to pass
var payload = new ExchangePublicTokenForAccessTokenRequest(clientId, clientSecret, publicToken);
//serialize object
HttpContent content = ContentExtensions.ToJsonContent(payload);
//post it and get the response
HttpResponseMessage response = await this.httpClient.PostAsync(PlaidInformation.LinkEndpoint_ExchangePublicToken, content);
//read the string
string responseJson = await response.Content.ReadAsStringAsync();
//create the result
PlaidResult <AccessTokenResponse> result = new PlaidResult <AccessTokenResponse>(responseJson);
//is it ok
if (response.StatusCode == HttpStatusCode.OK)
{
AccessTokenResponse exchangeTokenResponse = JsonConvert.DeserializeObject <AccessTokenResponse>(responseJson);
result.Value = exchangeTokenResponse;
}
//parse the exception
result.Exception = await this.ParseException(response, responseJson);
//return
return(result);
}
private static TimeSpan _expiresIn(AccessTokenResponse r)
{
var expAccessToken = _expiresIn(r.AccessToken);
var expIdToken = TimeSpan.FromSeconds(r.ExpiresIn);
return(new[] { expAccessToken, expIdToken }.Min());
}
private async Task <AccessToken> FilteredAuthenticate <T>(string token)
{
var jsonSerializerSettings = new JsonSerializerSettings();
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", "b7aecfae-1396-4e38-ad21-6d0ce569fe62 " + token);
string json = @"{""id"":""1"", ""method"":""user.Authenticate"", ""jsonrpc"":""2.0""}";
var content = new StringContent(json);
AccessTokenResponse accessTokenResponse = new AccessTokenResponse();
content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
using (var response = await client.PostAsync("https://api.sec.filtered.com/v2/jsonrpc/auth", content))
{
string apiResponse = await response.Content.ReadAsStringAsync();
try
{
accessTokenResponse = JsonConvert.DeserializeObject <AccessTokenResponse>(apiResponse);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
};
return(accessTokenResponse.Result);
}
private void OnAccessTokenCallback(bool success, AccessTokenResponse response)
{
if (success)
{
CeresitaWebService.Singleton.user.twitterId = response.UserId + "," + response.ScreenName + "," + response.Token + "," + response.TokenSecret;
CeresitaWebService.Singleton.UpdateUser(delegate(CeresitaWebService.WEBSERVICE_RETURN ret)
{
if (ret == CeresitaWebService.WEBSERVICE_RETURN.USER_UPDATED)
{
AccountManager.Singleton.UpdateInformation();
ShareImage();
}
else
{
Alert.Singleton.ShowAlert(Alert.Message.ERROR);
}
});
}
else
{
Alert.Singleton.ShowAlert(Alert.Message.ERROR);
}
}
public override Task <AccessTokenResponse> ObterAccessToken(AccessTokenRequest request, ServerCallContext context)
{
var response = new AccessTokenResponse();
try
{
var usuarioId = Guid.Parse(request.UsuarioId);
var redesocial = (RedeSocialEnum)request.RedeSocial;
var envelopeResponse = accessTokenServico.Obter(usuarioId, redesocial);
response.HttpStatusCode = (int)envelopeResponse.HttpStatusCode;
if (envelopeResponse.Success)
{
response.Token = envelopeResponse.Item.Token;
}
}
catch (EnvelopeException env)
{
response.HttpStatusCode = (int)env.HttpStatusCode;
}
catch (Exception)
{
response.HttpStatusCode = (int)HttpStatusCode.InternalServerError;
}
return(Task.FromResult(response));
}
public async Task TestUpdateCredential()
{
var secretPath = Guid.NewGuid().ToString();
var oldSecretPath = $"{_devOpsContext.BasePathPrefix}:{secretPath}";
var value = new Credential()
{
Username = Guid.NewGuid().ToString(), Password = Guid.NewGuid().ToString()
};
var tokenReturn = new AccessTokenResponse("access-token", 3600, tokenType: "bearer");
_tokensApi.Token("client_credentials", clientId: _devOpsContext.ClientId,
clientSecret: _devOpsContext.ClientSecret)
.Returns(tokenReturn);
var secretReturn = Task.FromResult(new SecretResponse(path: oldSecretPath));
_secretsApi.UpdateSecretAsync(oldSecretPath,
Arg.Is <SecretUpsert>(x => x.Data["password"].Equals(value.Password) && x.Data["username"].Equals(value.Username)))
.Returns(secretReturn);
var result = await _secureStore.UpdateCredentialsAsync(_ctxString, secretPath, oldSecretPath, value);
Assert.AreEqual(oldSecretPath, result);
}
public AccessTokenResponse Authorize(string clientId, string clientSecret)
{
var Request = new RestRequest("auth/token", Method.POST);
Request.AddHeader("Accept-Language", this.Language);
var Parameters = new
{
client_id = clientId,
client_secret = clientSecret,
grant_type = "client_credentials"
};
var Json = JsonConvert.SerializeObject(Parameters);
Request.AddJsonBody(Json);
var Response = this.Client.Execute(Request);
AccessTokenResponse ResponseObject = JsonConvert.DeserializeObject <AccessTokenResponse>(Response.Content);
if (ResponseObject.Errors == null)
{
this.AccessToken = ResponseObject.Data.AccessToken;
}
ResponseObject.HttpResponse = Response;
return(ResponseObject);
}
public async Task <IActionResult> Callback(
AuthorizationCodeResponseViewModel authorizationCodeResponseViewModel,
ImplicitFlowResponseQueryStringViewModel implicitFlowResponseQueryStringViewModel,
ErrorResponseViewModel errorResponseAtResponseViewModel)
{
if (!string.IsNullOrWhiteSpace(errorResponseAtResponseViewModel.Error))
{
var errorResponseAtCallback = OAuthMapper.Map(errorResponseAtResponseViewModel);
return(ProcessOAuthClientErrorResponse(errorResponseAtCallback));
}
var originalState = (string)TempData.ReadAndClear(Common.State);
var codeVerifier = (string)TempData.ReadAndClear(Common.CodeVerifier);
var authorizationCodeCallbackResponse = OAuthMapper.Map(authorizationCodeResponseViewModel);
var implicitFlowCallbackResponse = OAuthMapper.Map(implicitFlowResponseQueryStringViewModel);
var response = await _oAuthFlows.RunFlow(
_oAuthClientConfiguration,
authorizationCodeCallbackResponse,
implicitFlowCallbackResponse,
originalState : originalState,
codeVerifier : codeVerifier);
return(response switch
{
AccessTokenResponse accessTokenResponse => await SignInUser(accessTokenResponse, originalState),
ErrorResponse errorResponse => ProcessOAuthClientErrorResponse(errorResponse)
});
/// <summary>
/// Obtain a new access token using a refresh token
/// </summary>
/// <param name="refreshToken">The refresh token the client application already received.</param>
/// <param name="clientId">The Consumer Key from the connected app definition.</param>
/// <param name="clientSecret">The Consumer Secret from the connected app definition. Required unless the Require Secret for Web Server Flow setting is not enabled in the connected app definition.</param>
/// <param name="tokenRequestEndpointUrl"></param>
/// <returns></returns>
public async Task TokenRefreshAsync(string refreshToken, string clientId, string clientSecret = "", string tokenRequestEndpointUrl = TokenRequestEndpointUrl)
{
var uri = UriFormatter.RefreshTokenUrl(
tokenRequestEndpointUrl,
refreshToken,
clientId,
clientSecret);
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = uri
};
request.Headers.UserAgent.ParseAdd(string.Concat(UserAgent, "/", ApiVersion));
var responseMessage = await _httpClient.SendAsync(request).ConfigureAwait(false);
var response = await responseMessage.Content.ReadAsStringAsync().ConfigureAwait(false);
if (responseMessage.IsSuccessStatusCode)
{
this.AccessInfo = JsonConvert.DeserializeObject <AccessTokenResponse>(response);
this.AccessInfo.RefreshToken = refreshToken; //not included in reponse
}
else
{
var errorResponse = JsonConvert.DeserializeObject <AuthErrorResponse>(response);
throw new ForceAuthException(errorResponse.Error, errorResponse.ErrorDescription, responseMessage.StatusCode);
}
}
public async Task <Market> GetMarketAsync()
{
// TODO: ver alguna forma de que esto sea permanente, y se use el token que corresponda, bearer o refresh.
BearerToken = await GenerateAccessToken();
if (null == BearerToken)
{
// TODO: Log this exception.
throw new Exception("Cannot retrieve Market information: BearerToken not available.");
}
// antes de ejecutar la llamada normal, asociar el bearer token
// TODO: Hacer alguna forma de asociar esto, que sea mas reusable.
_client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", BearerToken.AccessToken);
//var httpResponse = await _client.GetAsync($"{urlMarket}");
var httpResponse = await _client.GetAsync($"{urlMarketReady}");
if (!httpResponse.IsSuccessStatusCode)
{
throw new Exception("Cannot retrieve Market information.");
}
var content = await httpResponse.Content.ReadAsStringAsync();
//TODO: Ver si no hay que hacer un mapping acá de alguna forma.
var item = JsonConvert.DeserializeObject <Market>(content);
// TODO: ver que onda Ok.
//var market = new Market();
//market.PanelTituloModel = item;
return(item);
//return market;
}
public static async Task<object> GetValuesAsync(HttpClient client, AccessTokenResponse accessTokenResponse)
{
using (HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, baseUrl + "/api/customer/1"))
{
request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", accessTokenResponse.AccessToken);
using (HttpResponseMessage response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var result = await response.Content.ReadAsAsync<object>();
return result;
}
}
}
