public async Task GetAccessToken() { AuthTokenInfo access_tokenInfo = null; using (HttpClient hc = new HttpClient()) { hc.DefaultRequestHeaders.TryAddWithoutValidation("Authorization", $"Basic {_authorizarionToken}"); hc.DefaultRequestHeaders.TryAddWithoutValidation("Content-Type", "application/json"); Dictionary <string, string> dc = new Dictionary <string, string>(); dc.Add("grant_type", "client_credentials"); FormUrlEncodedContent content = new FormUrlEncodedContent(dc); HttpResponseMessage responseMessage = await hc.PostAsync(_uritoken, content); string jsonMessage = await responseMessage.Content.ReadAsStringAsync(); if (responseMessage.IsSuccessStatusCode) { access_tokenInfo = JsonConvert.DeserializeObject <AuthTokenInfo>(jsonMessage); } else { throw new Exception(jsonMessage); } } _token = access_tokenInfo?.AccessToken; }
public RESTReplyData user_tokens(RESTRequestData pReq, List <string> pArgs) { RESTReplyData replyData = new RESTReplyData(); // The HTTP response info if (pReq.Queries.TryGetValue("for_domain_server", out string oForDomainServer)) { if (Boolean.Parse(oForDomainServer)) { // Getting a token for a domain server if (Accounts.Instance.TryGetAccountWithAuthToken(pReq.AuthToken, out AccountEntity oAccount)) { AuthTokenInfo token = oAccount.CreateAccessToken(AuthTokenInfo.ScopeCode.domain); // The domain/account association is permenant... expiration is far from now token.TokenExpirationTime = new DateTime(2999, 12, 31); replyData.SetBody($"<center><h2>Your domain's access token is: {token.Token}</h2></center>"); replyData.MIMEType = "text/html"; } else { // If the user is not logged in, go to a page to login and set things up replyData.Status = (int)HttpStatusCode.Found; replyData.CustomOutputHeaders.Add("Location", Context.Params.P <string>(AppParams.P_DOMAIN_TOKENGEN_URL)); replyData.MIMEType = "text/html"; } } } return(replyData); }
private static async Task <AuthTokenInfo> GetToken() { var client = new HttpClient(); var content = new FormUrlEncodedContent(new[] { new KeyValuePair <string, string>("grant_type", "client_credentials"), new KeyValuePair <string, string>("redirect_uri", AppSettings.RedirectUri) }); var basicAuth = Convert.ToBase64String(Encoding.GetEncoding("ISO-8859-1").GetBytes($"{AppSettings.ClientID}:{AppSettings.ClientSecret}")); client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", basicAuth); var response = await client.PostAsync("https://login.mypurecloud.ie/oauth/token", content); var responseContent = await response.Content.ReadAsStringAsync(); var responseJObj = JObject.Parse(responseContent); var expires = responseJObj.GetValue("expires_in").ToString(); var tokenInfo = new AuthTokenInfo { AccessToken = responseJObj.GetValue("access_token").ToString(), TokenType = responseJObj.GetValue("token_type").ToString(), }; int expiresValue; if (Int32.TryParse(expires, NumberStyles.Integer, CultureInfo.InvariantCulture, out expiresValue)) { tokenInfo.ExpiresIn = expiresValue; } return(tokenInfo); }
public bodyTokenInfo(AuthTokenInfo pToken) { tokenid = pToken.TokenId; token = pToken.Token; refresh_token = pToken.RefreshToken; token_creation_time = XmlConvert.ToString(pToken.TokenCreationTime, XmlDateTimeSerializationMode.Utc); token_expiration_time = XmlConvert.ToString(pToken.TokenExpirationTime, XmlDateTimeSerializationMode.Utc); scope = pToken.Scope.ToString(); }
private string OAuthTokenResponseBody(AccountEntity pAccount, AuthTokenInfo pTokenInfo) { return(JsonConvert.SerializeObject(new bodyLoginReply() { access_token = pTokenInfo.Token, token_type = "Bearer", expires_in = (int)(pTokenInfo.TokenExpirationTime - pTokenInfo.TokenCreationTime).TotalSeconds, refresh_token = pTokenInfo.RefreshToken, scope = pTokenInfo.Scope.ToString(), created_at = ((DateTimeOffset)pTokenInfo.TokenCreationTime).ToUnixTimeSeconds(), account_id = pAccount.AccountID, account_name = pAccount.Username, account_type = pAccount.GetAccountType() })); }
/// <summary> /// Set the ApiClient using Default or ApiClient instance. /// </summary> /// <param name="apiClient">An instance of ApiClient.</param> /// <returns></returns> public void setApiClientUsingDefault(ApiClient apiClient = null) { AuthTokenInfo = new AuthTokenInfo(); if (apiClient == null) { if (Default != null && Default.ApiClient == null) Default.ApiClient = new ApiClient(this); ApiClient = Default != null ? Default.ApiClient : new ApiClient(this); } else { if (Default != null && Default.ApiClient == null) Default.ApiClient = apiClient; ApiClient = apiClient; } }
public RESTReplyData user_login(RESTRequestData pReq, List <string> pArgs) { RESTReplyData replyData = new RESTReplyData(); // The HTTP response info // The /oauth/token request doesn't return a regular respBody // Should verify that the content-type is "application/x-www-form-urlencoded" Dictionary <string, string> reqArgs = Tools.PostBody2Dict(pReq.RequestBody); string accessGrantType = reqArgs["grant_type"]; switch (accessGrantType) { case "password": { // There are several types of "password"s passed by Interface: // PLAIN PASSWORD string userName = reqArgs["username"]; string userPassword = reqArgs["password"]; // STEAM // string userPassword = reqArgs["steam_auth_ticket"]; // OCULUS // string userPassword = reqArgs["oculus_nonce"]; // string userPassword = reqArgs["oculus_id"]; AuthTokenInfo.ScopeCode userScope = AuthTokenInfo.ScopeCode.owner; if (reqArgs.ContainsKey("scope")) { try { userScope = Enum.Parse <AuthTokenInfo.ScopeCode>(reqArgs["scope"] ?? "owner"); } catch { Context.Log.Error("{0} /oauth/token: unknown scope code: {1}", _logHeader, reqArgs["scope"]); userScope = AuthTokenInfo.ScopeCode.owner; } } // Context.Log.Debug("{0} Get access token for {1} with password", _logHeader, userName); if (Accounts.Instance.TryGetAccountWithUsername(userName, out AccountEntity aAccount)) { if (Accounts.Instance.ValidPassword(aAccount, userPassword)) { Context.Log.Debug("{0} Login of user {1}", _logHeader, userName); AuthTokenInfo authInfo = aAccount.CreateAccessToken(userScope, pReq.SenderKey + ";" + userName); // The response does not follow the usual {status: , data: } form. replyData.SetBody(OAuthTokenResponseBody(aAccount, authInfo)); } else { Context.Log.Debug("{0} Login failed for user {1}", _logHeader, userName); // The password doesn't work. replyData.SetBody(OAuthResponseError("Login failed")); replyData.Status = (int)HttpStatusCode.Unauthorized; } } else { Context.Log.Error("{0} Attempt to get token for unknown user {1}. Sender={2}", _logHeader, userName, pReq.SenderKey); replyData.SetBody(OAuthResponseError("Unknown user")); replyData.Status = (int)HttpStatusCode.BadRequest; } break; } case "authorization_code": { string clientID = reqArgs["client_id"]; string clientSecret = reqArgs["client_secret"]; string clientAuthCode = reqArgs["code"]; string redirectURL = reqArgs["redirect_url"]; Context.Log.Error("{0} Attempt to login with 'authorization_code'. clientID={1}", _logHeader, clientID); replyData.SetBody(OAuthResponseError("Cannot process 'authorization_code'")); replyData.Status = (int)HttpStatusCode.Unauthorized; break; } case "refresh_token": { string refreshingToken = reqArgs["refresh_token"]; string userScope = reqArgs["scope"] ?? "owner"; if (Accounts.Instance.TryGetAccountWithAuthToken(pReq.AuthToken, out AccountEntity aAccount)) { Context.Log.Debug("{0} Refreshing access token for account {1}", _logHeader, aAccount.AccountID); AuthTokenInfo refreshToken = aAccount.RefreshAccessToken(refreshingToken); if (refreshToken != null) { replyData.SetBody(OAuthTokenResponseBody(aAccount, refreshToken)); } else { replyData.SetBody(OAuthResponseError("Cannot refresh")); replyData.Status = (int)HttpStatusCode.BadRequest; } } else { Context.Log.Error("{0} Attempt to refresh token for not logged in user", _logHeader); replyData.SetBody(OAuthResponseError("Unknown user")); replyData.Status = (int)HttpStatusCode.BadRequest; } break; } default: Context.Log.Error("{0} Attempt to login with unknown grant type. Type={1}", _logHeader, accessGrantType); replyData.SetBody(OAuthResponseError("Unknown grant type: " + accessGrantType)); replyData.Status = (int)HttpStatusCode.Unauthorized; break; } // Context.Log.Debug("{0} oauth/token replyBody={1}", _logHeader, replyData.Body); return(replyData); }
public RESTReplyData new_scope_token(RESTRequestData pReq, List <string> pArgs) { RESTReplyData replyData = new RESTReplyData(); // The HTTP response info ResponseBody respBody = new ResponseBody(); if (Sessions.Instance.ShouldBeThrottled(pReq.SenderKey, Sessions.Op.TOKEN_CREATE)) { respBody.RespondFailure("Throttled"); respBody.Data = new { operation = "throttled" }; } else { // Getting a token for a domain server if (Accounts.Instance.TryGetAccountWithAuthToken(pReq.AuthToken, out AccountEntity oAccount)) { AuthTokenInfo token = null; string scope = pReq.Queries.ContainsKey("scope") ? pReq.Queries["scope"] : "owner"; switch (scope) { case "domain": token = oAccount.CreateAccessToken(AuthTokenInfo.ScopeCode.domain); // The domain/account association lasts longer token.TokenExpirationTime = new DateTime(2999, 12, 31); break; case "owner": token = oAccount.CreateAccessToken(AuthTokenInfo.ScopeCode.owner); break; default: break; } if (token != null) { respBody.Data = new { token = token.Token, token_id = token.TokenId, refresh_token = token.RefreshToken, token_expiration_seconds = (int)(token.TokenExpirationTime - token.TokenCreationTime).TotalSeconds, account_name = oAccount.Username, account_type = oAccount.GetAccountType(), account_id = oAccount.AccountID }; } else { respBody.RespondFailure("Token could not be generated. Bad scope?"); } } else { // Not a known account. respBody.RespondFailure("Unknown requesting account"); } } replyData.SetBody(respBody, pReq); return(replyData); }
/// <summary> /// Initializes a new instance of the Configuration class with different settings /// </summary> /// <param name="apiClient">Api client</param> /// <param name="defaultHeader">Dictionary of default HTTP header</param> /// <param name="username">Username</param> /// <param name="password">Password</param> /// <param name="accessToken">accessToken</param> /// <param name="apiKey">Dictionary of API key</param> /// <param name="apiKeyPrefix">Dictionary of API key prefix</param> /// <param name="tempFolderPath">Temp folder path</param> /// <param name="dateTimeFormat">DateTime format string</param> /// <param name="timeout">HTTP connection timeout (in milliseconds)</param> /// <param name="shouldRefreshAccessToken">ShouldRefreshAccessToken</param> /// <param name="refreshTokenWaitTime">Refresh token wait time in seconds</param> /// <param name="userAgent">HTTP user agent</param> /// <param name="configFilePath">Config file path</param> /// <param name="autoReloadConfig">AutoReloadConfig</param> public Configuration(ApiClient apiClient = null, Dictionary<String, String> defaultHeader = null, string username = null, string password = null, string accessToken = null, Dictionary<String, String> apiKey = null, Dictionary<String, String> apiKeyPrefix = null, string tempFolderPath = null, string dateTimeFormat = null, int timeout = 100000, bool shouldRefreshAccessToken = true, int refreshTokenWaitTime = 10, string userAgent = "PureCloud SDK/dotnet", string configFilePath = null, bool autoReloadConfig = true ) { setApiClientUsingDefault(apiClient); Username = username; Password = password; AuthTokenInfo = new AuthTokenInfo(); AccessToken = accessToken; UserAgent = userAgent; if (defaultHeader != null) DefaultHeader = defaultHeader; if (apiKey != null) ApiKey = apiKey; if (apiKeyPrefix != null) ApiKeyPrefix = apiKeyPrefix; TempFolderPath = tempFolderPath; DateTimeFormat = dateTimeFormat; Timeout = timeout; ShouldRefreshAccessToken = shouldRefreshAccessToken; RefreshTokenWaitTime = refreshTokenWaitTime; Logger = new Logger(); if (String.IsNullOrEmpty(configFilePath)) { string homePath = (Environment.OSVersion.Platform == PlatformID.Unix || Environment.OSVersion.Platform == PlatformID.MacOSX) ? Environment.GetEnvironmentVariable("HOME") : Environment.ExpandEnvironmentVariables("%HOMEDRIVE%%HOMEPATH%"); ConfigFilePath = Path.Combine(homePath, ".genesysclouddotnet", "config"); } else { ConfigFilePath = configFilePath; } AutoReloadConfig = autoReloadConfig; if (AutoReloadConfig) { ThreadStart configCheckerRef = new ThreadStart(runConfigChecker); Thread configCheckerThread = new Thread(configCheckerRef); configCheckerThread.IsBackground = true; configCheckerThread.Start(); } }