public void Constructors() { QueryParameters query01 = new QueryParameters(); Console.WriteLine($"query01 = {query01}"); Console.WriteLine($"query01.ToString() = {query01.ToString()}"); Console.WriteLine($"query01.ToString(\"D\") = {query01.ToString("D")}"); Console.WriteLine($"query01.ToString(\"F\") = {query01.ToString("F")}"); Console.WriteLine($"query01.ToString(\"Q\") = {query01.ToString("Q")}"); Dictionary <string, string> oauth_authorization = new Dictionary <string, string>() { { "client_id", "client_id_obtained_string" }, { "response_type", "code" }, { "redirect_uri", "http://localhost" }, { "scope", "" }, { "state", "" }, }; QueryParameters query02 = new QueryParameters(oauth_authorization); Console.WriteLine($"query02 = {query02}"); Console.WriteLine($"query02.ToString() = {query02.ToString()}"); Console.WriteLine($"query02.ToString(\"D\") = {query02.ToString("D")}"); Console.WriteLine($"query02.ToString(\"F\") = {query02.ToString("F")}"); Console.WriteLine($"query02.ToString(\"Q\") = {query02.ToString("Q")}"); return; }
public void Merge() { Dictionary <string, string> d01 = new Dictionary <string, string>() { { "client_id", "client_id_obtained_string" }, { "response_type", "code-old" }, { "redirect_uri", "http://someotherhost" }, }; QueryParameters qp01 = new QueryParameters(d01); Console.WriteLine($"query01.ToString(\"D\") = {qp01.ToString("D")}"); Dictionary <string, string> d02 = new Dictionary <string, string>() { { "response_type", "code" }, { "redirect_uri", "http://localhost" }, { "scope", "" }, { "state", "" }, }; // Merge // adds new parameters from qp02 // and // overwrites existing ones in qp01 with values from qp02 Dictionary <string, string> d03 = qp01.Merge(d02); Console.WriteLine($"query01.ToString(\"D\") = {qp01.ToString("D")}"); Dictionary <string, Func <string, string> > parameter_encoding_map_01; parameter_encoding_map_01 = new Dictionary <string, Func <string, string> >() { { "response_type", qp01.DoNotEncode }, { "redirect_uri", qp01.UrlEncode }, { "scope", qp01.UrlEncode }, { "state", qp01.UrlEncode }, }; QueryParameters qp03 = new QueryParameters(d02) { DefaultParameterEncodings = parameter_encoding_map_01 }; qp03.ToString("D"); qp03.Encode().ToString("D"); return; }
public Task <LoanPipelineCursor> CreateCursorAsync(PipelineParameters parameters, CancellationToken cancellationToken = default) { Preconditions.NotNull(parameters, nameof(parameters)); var queryParameters = new QueryParameters( new QueryParameter("limit", "1"), new QueryParameter("cursorType", "randomAccess")); return(PostAsync(null, queryParameters.ToString(), JsonStreamContent.Create(parameters), nameof(CreateCursorAsync), null, cancellationToken, async response => { var headers = response.Headers; const string countHeaderName = "x-total-count"; if (!headers.TryGetValues(countHeaderName, out var counts)) { throw await EncompassRestException.CreateAsync($"{nameof(CreateCursorAsync)} missing {countHeaderName} header", response).ConfigureAwait(false); } var countString = counts.First(); if (!int.TryParse(countString, out var count) || count < 0) { throw await EncompassRestException.CreateAsync($"{nameof(CreateCursorAsync)} invalid {countHeaderName} header value", response).ConfigureAwait(false); } if (count == 0) { return null; } const string cursorIdHeaderName = "x-cursor"; if (!headers.TryGetValues(cursorIdHeaderName, out var cursorIds)) { throw await EncompassRestException.CreateAsync($"{nameof(CreateCursorAsync)} missing {cursorIdHeaderName} header", response).ConfigureAwait(false); } var cursorId = cursorIds.First(); return new LoanPipelineCursor(Client, cursorId, count, parameters.Fields); })); }
/// <summary> /// Preview calculations for a loan. This API calculates fields similar to the calculations performed in Update Loan, however, the transient calculations provide a preview and do not save to the loan file. /// </summary> /// <param name="loan">The loan to recalculate.</param> /// <param name="entities">The list of loan entities to populate for the loan.</param> /// <param name="calcAllOnly">Indicates whether calculations will be executed for all fields. The default is <c>true</c>.</param> /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param> /// <returns></returns> public Task CalculateLoanAsync(Loan loan, IEnumerable <string> entities, bool?calcAllOnly, CancellationToken cancellationToken = default) { Preconditions.NotNull(loan, nameof(loan)); Preconditions.NotNullOrEmpty(loan.EncompassId, $"{nameof(loan)}.{nameof(loan.EncompassId)}"); var queryParameters = new QueryParameters(); if (calcAllOnly.HasValue) { queryParameters.Add(nameof(calcAllOnly), calcAllOnly.ToString().ToLower()); } var body = new CalculateLoanBody { LoanData = loan, Entities = entities }; loan.Initialize(Client, loan.EncompassId); return(PostAsync("loan", queryParameters.ToString(), JsonStreamContent.Create(body), nameof(CalculateLoanAsync), loan.EncompassId, cancellationToken, async(HttpResponseMessage response) => { var loanAsJson = loan.ToString(SerializationOptions.Dirty); await response.Content.PopulateAsync(loan).ConfigureAwait(false); loan.Dirty = false; // Repopulate with original dirty loan to maintain loan dirtiness. // This may overwrite calculated values but they shouldn't have been dirty to begin with if they're calculated values. JsonHelper.PopulateFromJson(loanAsJson, loan); return string.Empty; })); }
public static async Task <List <Alumno> > Consultar(Dictionary <string, string> filtros = null) { var endpoint = new UriBuilder(Endpoint); if (filtros != null) { var endpointParams = new QueryParameters(endpoint.Query); endpointParams.Append(filtros); endpoint.Query = endpointParams.ToString(); } var client = new HttpClient(); var response = await client.GetAsync(endpoint.Uri); var content = await response.Content.ReadAsStringAsync(); if (response.IsSuccessStatusCode) { return(JsonConvert.DeserializeObject <List <Alumno> >(content)); } else { var result = JsonConvert.DeserializeObject <RestError>(content); throw new Exception(result.Error); } }
public Task AssignDocumentAttachmentsRawAsync(string documentId, string attachmentEntities, AssignmentAction action, CancellationToken cancellationToken = default) { action.Validate(nameof(action)); var queryParameters = new QueryParameters(new QueryParameter(nameof(action), action.AsString(EnumJsonConverter.CamelCaseNameFormat))); return(AssignDocumentAttachmentsRawAsync(documentId, attachmentEntities, queryParameters.ToString(), cancellationToken)); }
public static string AccessTokenRequestError(string url, QueryParameters collection) { string message = "An error occurred while requesting Access Token at " + url; if (collection != null) if (collection.Count > 0) message += Environment.NewLine + "with parameters " + collection.ToString(); return message; }
public void TestNegateSimpleQuery() { var query = new QueryParameters<Artist>(); query.Add("arid", "1", true); Assert.AreEqual("NOT arid:1", query.ToString()); }
public void TestAlreadyQuotedSimpleQuery() { var query = new QueryParameters<Artist>(); query.Add("artist", "\"rolling stones\""); Assert.AreEqual("artist:\"rolling stones\"", query.ToString()); }
public void TestQuoteSimpleQuery() { var query = new QueryParameters<Artist>(); query.Add("artist", "bob dylan"); Assert.AreEqual("artist:\"bob dylan\"", query.ToString()); }
public void TestInlineBracketsSimpleQuery() { var query = new QueryParameters<Artist>(); query.Add("artist", "(\"rolling stones\" OR jagger)"); Assert.AreEqual("artist:(\"rolling stones\" OR jagger)", query.ToString()); }
public void TestInlineSimpleQuery() { var query = new QueryParameters<Artist>(); query.Add("artist", "\"rolling stones\" OR jagger"); Assert.AreEqual("artist:(\"rolling stones\" OR jagger)", query.ToString()); }
public void TestQuoteMultiQuery() { var query = new QueryParameters<Artist>(); query.Add("artist", "rolling stones"); query.Add("tag", "rock"); Assert.AreEqual("artist:\"rolling stones\" AND tag:rock", query.ToString()); }
public void TestNegateMultiQuery() { var query = new QueryParameters<Artist>(); query.Add("artist", "stones"); query.Add("tag", "rock", true); Assert.AreEqual("artist:stones AND NOT tag:rock", query.ToString()); }
public void TestInlineMultiQuery() { var query = new QueryParameters<Artist>(); query.Add("artist", "\"rolling stones\" OR jagger"); query.Add("tag", "rock", true); Assert.AreEqual("artist:(\"rolling stones\" OR jagger) AND NOT tag:rock", query.ToString()); }
/// <inheritdoc/> public Task <List <EntityReference> > GetTemplateFilesAsync(string path, CancellationToken cancellationToken = default) { Preconditions.NotNullOrEmpty(path, nameof(path)); var queryParameters = new QueryParameters( new QueryParameter("path", path)); return(GetAsync <List <EntityReference> >("items", queryParameters.ToString(), nameof(GetTemplateFilesAsync), null, cancellationToken)); }
/// <summary> /// Adds or removes contacts in a contact group. /// </summary> /// <param name="groupId">The unique identifier of the contact group to update.</param> /// <param name="action">Whether to add or remove the contact.</param> /// <param name="contacts">The contacts to add or remove.</param> /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param> /// <returns></returns> public Task AssignGroupContactsAsync(string groupId, string action, IEnumerable <EntityReference> contacts, CancellationToken cancellationToken = default) { Preconditions.NotNullOrEmpty(groupId, nameof(groupId)); Preconditions.NotNullOrEmpty(action, nameof(action)); Preconditions.NotNullOrEmpty(contacts, nameof(contacts)); var queryParameters = new QueryParameters(new QueryParameter(nameof(action), action)); return(PatchAsync($"{groupId}/contacts", queryParameters.ToString(), JsonStreamContent.Create(contacts), nameof(AssignGroupContactsAsync), groupId, cancellationToken)); }
/// <summary> /// Gets the user's licenses and for a particular state if specified. /// </summary> /// <param name="state">The state code for which to return license information.</param> /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param> /// <returns></returns> public Task <List <UserLicenseDetail> > GetLicenseDetailsAsync(string state, CancellationToken cancellationToken = default) { var queryParameters = new QueryParameters(); if (!string.IsNullOrEmpty(state)) { queryParameters.Add("state", state); } return(GetDirtyListAsync <UserLicenseDetail>(null, queryParameters.ToString(), nameof(GetLicenseDetailsAsync), null, cancellationToken)); }
public Task AssignDocumentAttachmentsAsync(string documentId, AssignmentAction action, IEnumerable <EntityReference> attachmentEntities, CancellationToken cancellationToken = default) { Preconditions.NotNullOrEmpty(documentId, nameof(documentId)); action.Validate(nameof(action)); Preconditions.NotNullOrEmpty(attachmentEntities, nameof(attachmentEntities)); var queryParameters = new QueryParameters(new QueryParameter(nameof(action), action.AsString(EnumJsonConverter.CamelCaseNameFormat))); return(PatchAsync($"{documentId}/attachments", queryParameters.ToString(), JsonStreamContent.Create(attachmentEntities), nameof(AssignDocumentAttachmentsAsync), documentId, cancellationToken)); }
public Task <string> GetLoanRawAsync(string loanId, IEnumerable <string> entities, CancellationToken cancellationToken = default) { var queryParameters = new QueryParameters(); if (entities?.Any() == true) { queryParameters.Add("entities", string.Join(",", entities)); } return(GetLoanRawAsync(loanId, queryParameters.ToString(), cancellationToken)); }
public Task <List <ResourceLock> > GetResourceLocksAsync(string resourceId, string resourceType, CancellationToken cancellationToken = default) { Preconditions.NotNullOrEmpty(resourceId, nameof(resourceId)); Preconditions.NotNullOrEmpty(resourceType, nameof(resourceType)); var queryParameters = new QueryParameters( new QueryParameter("resourceType", resourceType), new QueryParameter("resourceId", resourceId)); return(GetAsync <List <ResourceLock> >(null, queryParameters.ToString(), nameof(GetResourceLocksAsync), null, cancellationToken)); }
public override string GetLoginUrl(string returnUrl) { if(string.IsNullOrEmpty(ConnectionToken.RequestToken)) RequestForRequestToken(); var oauthParameters = new QueryParameters { new QueryParameter("oauth_token", ConnectionToken.RequestToken) }; BeforeDirectingUserToServiceProvider(oauthParameters); return provider.UserLoginEndpoint + "?" + oauthParameters.ToString(); }
/// <summary> /// Gets the organization with the specified <paramref name="orgId"/> using the specified <paramref name="view"/>. /// </summary> /// <param name="orgId">The organization's id.</param> /// <param name="view">The view of the organization to get.</param> /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param> /// <returns></returns> public Task <Organization> GetOrganizationAsync(string orgId, string view, CancellationToken cancellationToken = default) { Preconditions.NotNullOrEmpty(orgId, nameof(orgId)); var queryParameters = new QueryParameters(); if (!string.IsNullOrEmpty(view)) { queryParameters.Add("view", view); } return(GetDirtyAsync <Organization>(orgId, queryParameters.ToString(), orgId == "root" ? nameof(GetRootOrganizationAsync) : nameof(GetOrganizationAsync), orgId, cancellationToken)); }
public Task <string> GetLoanSchemaRawAsync(bool includeFieldExtensions, IEnumerable <string> entities, CancellationToken cancellationToken = default) { var queryParameters = new QueryParameters(); if (entities?.Any() == true) { queryParameters.Add("entities", string.Join(",", entities)); } queryParameters.Add("includeFieldExtensions", includeFieldExtensions.ToString().ToLower()); return(GetLoanSchemaRawAsync(queryParameters.ToString(), cancellationToken)); }
/// <inheritdoc/> public Task <RateLockRequest> DenyRateLockRequestAsync(string requestId, RateLockCancelDenyOptions?denialOptions = null, CancellationToken cancellationToken = default) { Preconditions.NotNullOrEmpty(requestId, nameof(requestId)); denialOptions = denialOptions ?? new RateLockCancelDenyOptions(); var queryParameters = new QueryParameters(); queryParameters.Add("view", "entity"); return(PutAsync($"{requestId}/denial", queryParameters.ToString(), JsonStreamContent.Create(denialOptions), nameof(DenyRateLockRequestAsync), requestId, cancellationToken, FuncCache <RateLockRequest> .ReadAsFunc)); }
/// <summary> /// Returns details for a specified persona. /// </summary> /// <param name="id">Unique Identifier of the persona.</param> /// <param name="categories">The Persona Categories.</param> /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param> /// <returns></returns> public Task <Persona> GetPersonaAsync(string id, IEnumerable <string> categories, CancellationToken cancellationToken = default) { Preconditions.NotNullOrEmpty(id, nameof(id)); var queryParams = new QueryParameters(); if (categories != null) { queryParams.Add("categories", string.Join(",", categories)); } return(GetDirtyAsync <Persona>(id, queryParams.ToString(), nameof(GetPersonaAsync), id, cancellationToken)); }
/// <inheritdoc/> public Task UpdateMilestoneAsync(LoanMilestone milestone, string?action, CancellationToken cancellationToken = default) { Preconditions.NotNull(milestone, nameof(milestone)); Preconditions.NotNullOrEmpty(milestone.Id, $"{nameof(milestone)}.{nameof(milestone.Id)}"); var queryParameters = new QueryParameters(); if (!string.IsNullOrEmpty(action)) { queryParameters.Add("action", action); } return(PatchAsync(milestone.Id, queryParameters.ToString(), JsonStreamContent.Create(milestone), nameof(UpdateMilestoneAsync), milestone.Id, cancellationToken)); }
/// <inheritdoc/> public Task <RateLockRequest> GetRateLockAsync(string requestId, LockView?view = LockView.Summary, CancellationToken cancellationToken = default) { Preconditions.NotNullOrEmpty(requestId, nameof(requestId)); var queryParameters = new QueryParameters(); if (view.HasValue) { queryParameters.Add("view", view.ToString().ToLower()); } return(GetDirtyAsync <RateLockRequest>(requestId, queryParameters.ToString(), nameof(GetRateLockAsync), requestId, cancellationToken)); }
/// <summary> /// Retrieves all contact groups for a given contact type and group type. /// </summary> /// <param name="contactType">The contact type.</param> /// <param name="groupType">The contact group type.</param> /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param> /// <returns></returns> public Task <List <ContactGroup> > GetGroupsAsync(string contactType, string groupType = null, CancellationToken cancellationToken = default) { Preconditions.NotNullOrEmpty(contactType, nameof(contactType)); var queryParameters = new QueryParameters(); queryParameters.Add(nameof(contactType), contactType); if (!string.IsNullOrEmpty(groupType)) { queryParameters.Add(nameof(groupType), groupType); } return(GetDirtyListAsync <ContactGroup>(null, queryParameters.ToString(), nameof(GetGroupsAsync), null, cancellationToken)); }
/// <inheritdoc/> public Task <UserRights> GetRightsAsync(UserRightsType type, string?category, CancellationToken cancellationToken = default) { type.Validate(nameof(type)); var queryParameters = new QueryParameters(); if (!string.IsNullOrEmpty(category)) { queryParameters.Add("category", category); } var path = type.GetValue(); return(GetDirtyAsync <UserRights>(path, queryParameters.ToString(), nameof(GetRightsAsync), path, cancellationToken)); }
/// <inheritdoc/> public Task <List <LoanAssociate> > GetAssociatesAsync(string?userId, string?roleId, CancellationToken cancellationToken = default) { var queryParameters = new QueryParameters(); if (!string.IsNullOrEmpty(userId)) { queryParameters.Add("userId", userId); } if (!string.IsNullOrEmpty(roleId)) { queryParameters.Add("roleId", roleId); } return(GetDirtyListAsync <LoanAssociate>(null, queryParameters.ToString(), nameof(GetAssociatesAsync), null, cancellationToken)); }
/// <summary> /// Returns a list of subscriptions. /// </summary> /// <param name="resources">Resource names to include.</param> /// <param name="events">Include subscriptions with these specified events.</param> /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param> /// <returns></returns> public Task <List <WebhookSubscription> > GetSubscriptionsAsync(IEnumerable <string> resources, IEnumerable <string> events, CancellationToken cancellationToken = default) { var queryParameters = new QueryParameters(); if (resources?.Any() == true) { queryParameters.Add("resource", string.Join(",", resources)); } if (events?.Any() == true) { queryParameters.Add("events", string.Join(",", events)); } return(GetDirtyListAsync <WebhookSubscription>("subscriptions", queryParameters.ToString(), nameof(GetSubscriptionsAsync), null, cancellationToken)); }
/// <summary> /// Gets the user with the specified <paramref name="userId"/> and optionally includes the email signature in the response object. /// </summary> /// <param name="userId">The user's id.</param> /// <param name="viewEmailSignature">Indicates whether the email signature should be returned as part of the response.</param> /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param> /// <returns></returns> public async Task <User> GetUserAsync(string userId, bool?viewEmailSignature, CancellationToken cancellationToken = default) { Preconditions.NotNullOrEmpty(userId, nameof(userId)); var queryParameters = new QueryParameters(); if (viewEmailSignature.HasValue) { queryParameters.Add("viewEmailSignature", viewEmailSignature.ToString().ToLower()); } var user = await GetDirtyAsync <User>(userId, queryParameters.ToString(), nameof(GetUserAsync), userId, cancellationToken).ConfigureAwait(false); user.Initialize(Client, user.Id !); return(user); }
public Task <string> GetSubscriptionsRawAsync(IEnumerable <string> resources, IEnumerable <string> events, CancellationToken cancellationToken = default) { var queryParameters = new QueryParameters(); if (resources?.Any() == true) { queryParameters.Add("resource", string.Join(",", resources)); } if (events?.Any() == true) { queryParameters.Add("events", string.Join(",", events)); } return(GetSubscriptionsRawAsync(queryParameters.ToString(), cancellationToken)); }
public static string CustomFeedExecutionError(string feedUrl, QueryParameters collection) { return "An error occurred while executing " + feedUrl + Environment.NewLine + "Request Parameters: " + ((collection == null) ? "" : ((collection == null) ? "" : collection.ToString())); }
/// <summary> /// Search for an artist in the MusicBrainz database, matching the given query. /// </summary> /// <param name="query">The query parameters.</param> /// <param name="limit">The maximum number of artists to return (default = 25).</param> /// <param name="offset">The offset to the artists list (enables paging, default = 0).</param> /// <returns></returns> public async static Task<ArtistList> SearchAsync(QueryParameters<Artist> query, int limit = 25, int offset = 0) { return (await SearchAsync<ArtistMetadata>(EntityName, query.ToString(), limit, offset)).Collection; }
public void DirectUserToServiceProvider() { QueryParameters oauthParameters = new QueryParameters(); try { oauthParameters.Add(new QueryParameter("oauth_token", connectionToken.RequestToken)); BeforeDirectingUserToServiceProvider(oauthParameters); logger.Debug("redirecting user for login to: " + provider.UserLoginEndpoint + "?" + oauthParameters.ToString()); SocialAuthUser.Redirect(provider.UserLoginEndpoint + "?" + oauthParameters.ToString()); } catch (Exception ex) { logger.Error(ErrorMessages.UserLoginRedirectionError(provider.UserLoginEndpoint + "?" + oauthParameters.ToString()), ex); throw new OAuthException(ErrorMessages.UserLoginRedirectionError(provider.UserLoginEndpoint + "?" + oauthParameters.ToString()), ex); } }
public static string UserLoginResponseError(PROVIDER_TYPE providerType, QueryParameters collection) { return "An error occurred in user login." + Environment.NewLine + "Provider returned: " + ((collection == null) ? "" : collection.ToString()); }
public override System.Net.WebResponse ExecuteFeed(string feedURL, IProvider provider, BusinessObjects.Token connectionToken, BusinessObjects.TRANSPORT_METHOD transportMethod, byte[] content = null, Dictionary<string, string> headers = null) { string signature = ""; OAuthHelper oauthHelper = new OAuthHelper(); string timestamp = oauthHelper.GenerateTimeStamp(); QueryParameters oauthParams = new QueryParameters(); oauthParams.Add("oauth_consumer_key", provider.Consumerkey); oauthParams.Add("oauth_nonce", oauthHelper.GenerateNonce()); oauthParams.Add("oauth_signature_method", provider.SignatureMethod.ToString()); oauthParams.Add("oauth_timestamp", timestamp); oauthParams.Add("oauth_token", connectionToken.AccessToken); oauthParams.Add("oauth_version", "1.0"); signature = oauthHelper.GenerateSignature(new Uri(feedURL), oauthParams, provider.Consumerkey, provider.Consumersecret, provider.SignatureMethod, TRANSPORT_METHOD.POST, connectionToken.TokenSecret); oauthParams.Add("oauth_signature", signature); HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(feedURL); request.Method = transportMethod.ToString(); if (headers != null) { foreach (var header in headers) { switch (header.Key) { case "ContentLength": { request.ContentLength = long.Parse(header.Value); break; } case "ContentType": { request.ContentType = header.Value; break; } default: { request.Headers[header.Key] = header.Value; break; } } } } request.ContentLength = (content == null) ? 0 : content.Length; request.Headers.Add("Authorization", oauthHelper.GetAuthorizationHeader(oauthParams)); request.GetRequestStream().Write(content, 0, content.Length); WebResponse wr = null; try { logger.Debug("Executing " + feedURL + " using " + transportMethod.ToString() + Environment.NewLine + "Request Parameters: " + oauthParams.ToString()); wr = (WebResponse)request.GetResponse(); logger.Info("Successfully executed " + feedURL + " using " + transportMethod.ToString()); } catch (Exception ex) { logger.Error(ErrorMessages.CustomFeedExecutionError(feedURL, oauthParams), ex); throw new OAuthException(ErrorMessages.CustomFeedExecutionError(feedURL, oauthParams), ex); } return wr; }
/// <summary> /// Generate Signature /// </summary> /// <param name="requestURL"></param> /// <param name="oauthParameters"></param> /// <param name="consumerKey"></param> /// <param name="consumerSecret"></param> /// <param name="signatureType"></param> /// <param name="httpMethod"></param> /// <param name="tokenSecret"></param> /// <returns></returns> public string GenerateSignature(Uri requestURL, QueryParameters oauthParameters, string consumerKey, string consumerSecret, SIGNATURE_TYPE signatureType, TRANSPORT_METHOD httpMethod, string tokenSecret) { QueryParameters tmpOauthParameters = new QueryParameters(); foreach (var param in oauthParameters) { if (param.Value.ToLower().Contains("http://") || param.Value.ToLower().Contains("https://")) tmpOauthParameters.Add(new QueryParameter(param.Key, Utility.UrlEncode(param.Value))); else tmpOauthParameters.Add(new QueryParameter(param.Key, param.Value)); } tmpOauthParameters[OAuthSignatureMethodKey] = ParseSignatureEnum(signatureType); string signature = ""; StringBuilder signatureBase = new StringBuilder(); //1. URL encode and process Request URL string normalizedRequestUrl; normalizedRequestUrl = string.Format("{0}://{1}", requestURL.Scheme, requestURL.Host); if (!((requestURL.Scheme == "http" && requestURL.Port == 80) || (requestURL.Scheme == "https" && requestURL.Port == 443))) { normalizedRequestUrl += ":" + requestURL.Port; } normalizedRequestUrl += requestURL.AbsolutePath; normalizedRequestUrl = Utility.UrlEncode(normalizedRequestUrl); //2. URL Encode callbackUrl (if present) //if (tmpOauthParameters.HasName(OAuthCallbackKey)) // tmpOauthParameters[OAuthCallbackKey] = Utility.UrlEncode(tmpOauthParameters[OAuthCallbackKey]); //tmpOauthParameters["scope"] = Utility.UrlEncode(tmpOauthParameters["scope"]); foreach (var p in Utility.GetQuerystringParameters(requestURL.ToString())) tmpOauthParameters.Add(p.Key, UrlEncode(HttpUtility.UrlDecode(p.Value))); //following works for Twitter with spaces //tmpOauthParameters.Add(p.Key, UrlEncode(HttpUtility.UrlDecode(p.Value))); //3. Perform Lexographic Sorting tmpOauthParameters.Sort(); //4. Generate Signature Base signatureBase.AppendFormat("{0}&", httpMethod.ToString().ToUpper()); signatureBase.AppendFormat("{0}&", normalizedRequestUrl); signatureBase.AppendFormat("{0}", Utility.UrlEncode(tmpOauthParameters.ToString())); string sbase = signatureBase.ToString(); logger.Debug("signature base:" + sbase); //5. Generate Signature switch (signatureType) { case SIGNATURE_TYPE.PLAINTEXT: { signature = Utility.UrlEncode(string.Format("{0}&{1}", consumerSecret, tokenSecret)); break; } case SIGNATURE_TYPE.HMACSHA1: { HMACSHA1 hmacsha1 = new HMACSHA1(); hmacsha1.Key = Encoding.ASCII.GetBytes(string.Format("{0}&{1}", UrlEncode(consumerSecret), string.IsNullOrEmpty(tokenSecret) ? "" : tokenSecret)); signature = GenerateSignatureUsingHash(sbase, hmacsha1); logger.Debug("HMACSHA1 signature:" + signature); break; } default: throw new ArgumentException("Unknown signature type", "signatureType"); } return signature; }
public static string RequestTokenRequestError(string url, QueryParameters collection) { return "An error occurred while requesting Request Token at " + url + Environment.NewLine + "with parameters " + ((collection == null) ? "" : collection.ToString()); }
public void RequestForAccessToken() { QueryParameters oauthParameters = new QueryParameters(); string signature = ""; OAuthHelper oauthHelper = new OAuthHelper(); ////1. Generate Signature oauthParameters.Add("oauth_consumer_key", provider.Consumerkey); oauthParameters.Add("oauth_token", Utility.UrlEncode(ConnectionToken.RequestToken)); oauthParameters.Add("oauth_signature_method", provider.SignatureMethod.ToString()); oauthParameters.Add("oauth_timestamp", oauthHelper.GenerateTimeStamp()); oauthParameters.Add("oauth_nonce", oauthHelper.GenerateNonce()); oauthParameters.Add("oauth_version", "1.0"); BeforeRequestingAccessToken(oauthParameters); // hook called signature = oauthHelper.GenerateSignature(new Uri(provider.AccessTokenEndpoint), oauthParameters, provider.Consumerkey, provider.Consumersecret, provider.SignatureMethod, provider.TransportName, string.Empty); oauthParameters.Add("oauth_signature", Utility.UrlEncode(signature)); //2. Notify Consumer (if applicable) HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(provider.AccessTokenEndpoint + "?" + oauthParameters.ToString().Replace("HMACSHA1", "HMAC-SHA1")); request.Method = "GET";// always get irrespective of provider.TransportName.ToString(); request.ContentLength = 0; string response = ""; try { logger.Debug("Requesting Access Token at: " + request.RequestUri + Environment.NewLine + "Request Parameters: " + oauthParameters.ToString()); using (HttpWebResponse webResponse = (HttpWebResponse)request.GetResponse()) using (Stream responseStream = webResponse.GetResponseStream()) using (StreamReader reader = new StreamReader(responseStream)) { response = reader.ReadToEnd(); HandleAccessTokenResponse(Utility.GetQuerystringParameters(response)); } } catch (Exception ex) { logger.Debug(ErrorMessages.AccessTokenRequestError(request.RequestUri.ToString(), oauthParameters), ex); throw new OAuthException(ErrorMessages.AccessTokenRequestError(request.RequestUri.ToString(), oauthParameters), ex); } }
public static string AccessTokenResponseInvalid(QueryParameters collection) { return "Invalid Access Token received." + Environment.NewLine + "Provider returned: " + ((collection == null) ? "" : collection.ToString()); }
public override System.Net.WebResponse ExecuteFeed(string feedURL, IProvider provider, BusinessObjects.Token connectionToken, BusinessObjects.TRANSPORT_METHOD transportMethod) { string signature = ""; OAuthHelper oauthHelper = new OAuthHelper(); QueryParameters oauthParams = new QueryParameters(); oauthParams.Add("oauth_consumer_key", provider.Consumerkey); oauthParams.Add("oauth_nonce", oauthHelper.GenerateNonce()); oauthParams.Add("oauth_signature_method", provider.SignatureMethod.ToString()); oauthParams.Add("oauth_timestamp", oauthHelper.GenerateTimeStamp()); oauthParams.Add("oauth_token", connectionToken.AccessToken); oauthParams.Add("oauth_version", "1.0"); ////1. Generate Signature signature = oauthHelper.GenerateSignature(new Uri(feedURL), oauthParams, provider.Consumerkey, provider.Consumersecret, provider.SignatureMethod, TRANSPORT_METHOD.GET, connectionToken.TokenSecret); oauthParams.Add("oauth_signature", signature); //3.Connect and Execute Feed HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(feedURL); request.Method = transportMethod.ToString(); request.Headers.Add("Authorization", oauthHelper.GetAuthorizationHeader(oauthParams)); //request.ContentType = "application/atom+xml"; request.ContentLength = 0; WebResponse wr; try { logger.Debug("Executing " + feedURL + " using " + transportMethod.ToString() + Environment.NewLine + "Request Parameters: " + oauthParams.ToString()); wr = (WebResponse)request.GetResponse(); logger.Info("Successfully executed " + feedURL + " using " + transportMethod.ToString()); } catch (Exception ex) { logger.Error(ErrorMessages.CustomFeedExecutionError(feedURL, oauthParams), ex); throw new OAuthException(ErrorMessages.CustomFeedExecutionError(feedURL, oauthParams), ex); } return wr; }