public static string Get(string url, OAuthToken consumerToken, OAuthToken oauthToken, WebProxy proxy)
{
string nonce, timestamp;
string signature = GetSignature(WebMethod.GET, consumerToken, oauthToken, url, out timestamp, out nonce);
HttpWebRequest request = CreateWebRequest(url, WebMethod.GET, nonce, timestamp, signature, consumerToken, oauthToken, proxy);
return GetWebResponse(request);
}
private Uri SignRequest(Uri uri, OAuthToken requestToken = null)
{
var nonce = _oAuthBase.GenerateNonce();
var timestamp = _oAuthBase.GenerateTimeStamp();
string parameters;
string normalizedUrl;
string token = requestToken == null ? String.Empty : requestToken.Token;
string secret = requestToken == null ? String.Empty : requestToken.Secret;
var signature = _oAuthBase.GenerateSignature(
uri, _consumerKey, _consumerSecret,
token, secret, "GET", timestamp,
nonce, OAuthBase.SignatureTypes.HMACSHA1,
out normalizedUrl, out parameters);
signature = HttpUtility.UrlEncode(signature);
var requestUri = new StringBuilder(uri.ToString());
requestUri.AppendFormat("?oauth_consumer_key={0}&", _consumerKey);
if (!String.IsNullOrEmpty(token))
requestUri.AppendFormat("oauth_token={0}&", token);
requestUri.AppendFormat("oauth_nonce={0}&", nonce);
requestUri.AppendFormat("oauth_timestamp={0}&", timestamp);
requestUri.AppendFormat("oauth_signature_method={0}&", "HMAC-SHA1");
requestUri.AppendFormat("oauth_version={0}&", "1.0");
requestUri.AppendFormat("oauth_signature={0}", signature);
return new Uri(requestUri.ToString());
}
public OAuthToken GetToken(Uri uri)
{
var tokenString = Get(uri);
var parts = tokenString.Split('&');
var tokenKey = parts[1].Substring(parts[1].IndexOf('=') + 1);
var tokenSecret = parts[0].Substring(parts[0].IndexOf('=') + 1);
var token = new OAuthToken() { Token = tokenKey, Secret = tokenSecret };
return token;
}
/// <summary>
/// Подписывает запрос
/// </summary>
/// <param name="httpMethod">
/// метод, используемый для запроса
/// </param>
/// <param name="requestUrl">
/// адрес для запроса
/// </param>
/// <param name="requestParameters">
/// параметры запроса
/// </param>
/// <param name="consumerInfo">
/// информация о программе клиенте
/// </param>
/// <param name="token">
/// токен
/// </param>
/// <exception cref="ArgumentNullException"></exception>
/// <exception cref="ArgumentOutOfRangeException"></exception>
/// <returns>
/// подписанная сторока запроса
/// </returns>
public static string Sign(HttpMethods httpMethod, string requestUrl,
List<RequestParameter> requestParameters,
ConsumerInfo consumerInfo,
OAuthToken token)
{
if (consumerInfo.CallbackUrl == null && consumerInfo.ConsumerKey == null &&
consumerInfo.ConsumerSecret == null) throw new ArgumentNullException("consumerInfo");
// Подготовка и нормализация операндов для подписи
// Определяем метод запроса
if ((httpMethod < 0) && (httpMethod > (HttpMethods) 3))
throw new ArgumentOutOfRangeException("httpMethod");
var baseHttpMethod = httpMethod.ToString().ToUpper() + "&";
// определяем и нормализуем Url запроса
if (string.IsNullOrWhiteSpace(requestUrl)) throw new ArgumentNullException("requestUrl");
var baseRequesUrl = Uri.EscapeDataString(requestUrl) + "&";
// Определяем и нормализуем параметры запроса
if (requestParameters == null) throw new ArgumentNullException("requestParameters");
// нормализуем и сортируем список параметров
requestParameters = NormalizeRequestParameters(requestParameters);
var baseParameters = string.Join("&",
requestParameters.Select(param => param.Name + "=" + param.Value));
//строка для подписывания
var baseRequestString = baseHttpMethod + baseRequesUrl + Uri.EscapeDataString(baseParameters);
#if DEBUG
Debug.WriteLine(string.Format("Подписываемая строка {0}", baseRequestString));
#endif
// Определяем ключ для подписи
var baseKey = token == null
? consumerInfo.ConsumerSecret + "&" + string.Empty
: consumerInfo.ConsumerSecret + "&" + token.Secret;
// осуществляем шифрование
var encoder = new HMACSHA1 {Key = Encoding.ASCII.GetBytes(baseKey)};
var buffer = Encoding.ASCII.GetBytes(baseRequestString);
var signatureByte = encoder.ComputeHash(buffer, 0, buffer.Length);
// получаем стороку подписи в представлении Base64
var sigmature = Convert.ToBase64String(signatureByte);
#if DEBUG
Debug.WriteLine(string.Format("Подписанная строка {0}", sigmature));
#endif
/* Формируем подписанную строку запроса */
// Для формирования стоки запроса к параметрам добавляем параметр с цифровой подписью
requestParameters.Add(new RequestParameter(OAuthParam.Signature,
NormalizeParameter(sigmature)));
// формируем строку
var signedUrlString = requestUrl + "?" +
string.Join("&", requestParameters.Select(param => param.Name + "=" + param.Value));
#if DEBUG
Debug.WriteLine(string.Format("Подписанная строка запроса {0}", signedUrlString));
#endif
// возвращаем подписанную строку
return signedUrlString;
}
public static HttpWebRequest CreateWebRequest(string fullUrl, WebMethod method, string nonce, string timeStamp, string sig, string contentType, OAuthToken consumerToken, OAuthToken oauthToken, WebProxy proxy)
{
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(fullUrl);
request.Method = method.ToString();
request.Proxy = proxy;
string authHeader = CreateAuthHeader(method, nonce, timeStamp, sig, consumerToken, oauthToken);
//request.ContentType = "multipart/form-data; boundary=" + boundary;
request.ContentType = contentType;
request.Headers.Add("Authorization", authHeader);
return request;
}
public OAuthToken GetAccessToken(Uri baseUri, OAuthToken requestToken)
{
var uri = new Uri(baseUri, "oauth/access_token");
uri = SignRequest(uri, requestToken);
var request = (HttpWebRequest) WebRequest.Create(uri);
request.Method = WebRequestMethods.Http.Get;
var response = request.GetResponse();
var reader = new StreamReader(response.GetResponseStream());
var accessToken = reader.ReadToEnd();
var parts = accessToken.Split('&');
var token = parts[1].Substring(parts[1].IndexOf('=') + 1);
var secret = parts[0].Substring(parts[0].IndexOf('=') + 1);
return new OAuthToken(token, secret);
}
public static string GetSignature(WebMethod method, OAuthToken consumerToken, OAuthToken oauthToken, string url, out string timestamp, out string nonce)
{
OAuthBase oAuth = new OAuthBase();
nonce = oAuth.GenerateNonce();
timestamp = oAuth.GenerateTimeStamp();
string nurl, nrp;
string tokenKey = oauthToken == null ? String.Empty : oauthToken.TokenKey;
string tokenSecret = oauthToken == null ? String.Empty : oauthToken.TokenSecret;
Uri uri = new Uri(url);
string sig = oAuth.GenerateSignature(
uri,
consumerToken.TokenKey,
consumerToken.TokenSecret,
tokenKey,
tokenSecret,
method.ToString(),
timestamp,
nonce,
OAuthBase.SignatureTypes.HMACSHA1, out nurl, out nrp);
return System.Web.HttpUtility.UrlEncode(sig);
}
public Uri GetAuthorizeUri(Uri baseUri, OAuthToken requestToken)
{
var queryString = String.Format("oauth_token_secret={0}&oauth_token={1}", requestToken.Secret, requestToken.Token);
var authorizeUri = String.Format("{0}{1}?{2}", baseUri, "oauth/authorize", queryString);
return new Uri(authorizeUri);
}
protected void SignIt_OnWeb(object sender, EventArgs e)
{
bool isError = false;
try
{
string userId = "aa621eb5-e488-4135-9698-613136bce319"; // use your userId (guid), not email address
string oauthBasePath = "account-d.docusign.com";
string integratorKey = "ad00790f-c0c8-49d8-a621-904549bc9d88";
string privateKeyFile = Server.MapPath(@"~/App_Data/DocuSign_PrivateKey.pem");
string privateKey = System.IO.File.ReadAllText(privateKeyFile);
int expiresInHours = 1;
string host = "https://demo.docusign.net/restapi";
string accountId = string.Empty;
ApiClient apiClient = new ApiClient(host);
OAuth.OAuthToken tokenInfo = apiClient.ConfigureJwtAuthorizationFlowByKey(integratorKey, userId, oauthBasePath, privateKey, expiresInHours);
/////////////////////////////////////////////////////////////////
// STEP 1: Get User Info
// now that the API client has an OAuth token, let's use it in all// DocuSign APIs
/////////////////////////////////////////////////////////////////
OAuth.UserInfo userInfo = apiClient.GetUserInfo(tokenInfo.access_token);
foreach (var item in userInfo.GetAccounts())
{
if (item.GetIsDefault() == "true")
{
accountId = item.AccountId();
apiClient = new ApiClient(item.GetBaseUri() + "/restapi");
break;
}
}
// New Code
// Read a file from disk to use as a document.
string pdfToSign = Server.MapPath(@"~/Application/Uploads/CONFIRMATION PAGE.pdf");
byte[] fileBytes = System.IO.File.ReadAllBytes(pdfToSign);
EnvelopeDefinition envDef = new EnvelopeDefinition();
envDef.EmailSubject = "[DocuSign C# SDK] - Please sign this doc";
// Add a document to the envelope
Document doc = new Document();
doc.DocumentBase64 = System.Convert.ToBase64String(fileBytes);
doc.Name = "PROGRAM GUIDE & CONFIRMATION PAGE.pdf";
doc.DocumentId = "1";
envDef.Documents = new List <Document>();
envDef.Documents.Add(doc);
// Add a recipient to sign the documeent
Signer signer = new Signer();
signer.Email = "*****@*****.**";
signer.Name = "Noel Ciambotti";
signer.RecipientId = "1";
signer.ClientUserId = "1002";
// Create a |SignHere| tab somewhere on the document for the recipient to sign
signer.Tabs = new Tabs();
signer.Tabs.SignHereTabs = new List <SignHere>();
SignHere signHere = new SignHere();
signHere.DocumentId = "1";
signHere.PageNumber = "1";
signHere.RecipientId = "1";
signHere.XPosition = "37";
signHere.YPosition = "666";
signer.Tabs.SignHereTabs.Add(signHere);
envDef.Recipients = new Recipients();
envDef.Recipients.Signers = new List <Signer>();
envDef.Recipients.Signers.Add(signer);
// set envelope status to "sent" to immediately send the signature request
envDef.Status = "sent";
// |EnvelopesApi| contains methods related to creating and sending Envelopes (aka signature requests)
// EnvelopesApi envelopesApi = new EnvelopesApi();
EnvelopesApi envelopesApi = new EnvelopesApi(apiClient.Configuration);
EnvelopeSummary envelopeSummary = envelopesApi.CreateEnvelope(accountId, envDef);
// print the JSON response
lblEnvelopeId.Text = envelopeSummary.EnvelopeId;
lblEnvelope.Text = "EnvelopeSummary:<br />" + Newtonsoft.Json.JsonConvert.SerializeObject(envelopeSummary);
//Console.WriteLine("EnvelopeSummary:\n" + Newtonsoft.Json.JsonConvert.SerializeObject(envelopeSummary));
lblEnvelope.Text += "<br />" + envelopeSummary.EnvelopeId;
lblEnvelope.Text += "<br />" + envelopeSummary.Status;
lblEnvelope.Text += "<br />" + envelopeSummary.StatusDateTime;
lblEnvelope.Text += "<br />" + envelopeSummary.Uri;
}
catch (Exception ex)
{
isError = true;
string errMsg = "Sign Test";
lblError.Text += String.Format("<hr /><table class='table_error'>"
+ "<tr><td>Error<td/><td>{0}</td></tr>"
+ "<tr><td>Message<td/><td>{1}</td></tr>"
+ "<tr><td>StackTrace<td/><td>{2}</td></tr>"
+ "<tr><td>Source<td/><td>{3}</td></tr>"
+ "<tr><td>InnerException<td/><td>{4}</td></tr>"
+ "<tr><td>Data<td/><td>{5}</td></tr>"
+ "</table>"
, errMsg //0
, ex.Message //1
, ex.StackTrace //2
, ex.Source //3
, ex.InnerException //4
, ex.Data //5
, ex.HelpLink
, ex.TargetSite
);
}
if (!isError)
{
// In DeBug - We comment out so we can do multiple steps
SignIt_OnWeb_View(sender, e);
}
}
protected void SignIt_OnWeb_View(object sender, EventArgs e)
{
try
{
string userId = "aa621eb5-e488-4135-9698-613136bce319"; // use your userId (guid), not email address
string oauthBasePath = "account-d.docusign.com";
string integratorKey = "ad00790f-c0c8-49d8-a621-904549bc9d88";
string privateKeyFile = Server.MapPath(@"~/App_Data/DocuSign_PrivateKey.pem");
string privateKey = System.IO.File.ReadAllText(privateKeyFile);
int expiresInHours = 1;
string host = "https://demo.docusign.net/restapi";
string accountId = string.Empty;
ApiClient apiClient = new ApiClient(host);
OAuth.OAuthToken tokenInfo = apiClient.ConfigureJwtAuthorizationFlowByKey(integratorKey, userId, oauthBasePath, privateKey, expiresInHours);
/////////////////////////////////////////////////////////////////
// STEP 1: Get User Info
// now that the API client has an OAuth token, let's use it in all// DocuSign APIs
/////////////////////////////////////////////////////////////////
OAuth.UserInfo userInfo = apiClient.GetUserInfo(tokenInfo.access_token);
foreach (var item in userInfo.GetAccounts())
{
if (item.GetIsDefault() == "true")
{
accountId = item.AccountId();
apiClient = new ApiClient(item.GetBaseUri() + "/restapi");
break;
}
}
// New Code
RecipientViewRequest viewOptions = new RecipientViewRequest()
{
ReturnUrl = "https://application.cardgroupintl.com/Application/SignTest",
ClientUserId = "1002", // must match clientUserId of the embedded recipient
AuthenticationMethod = "email",
UserName = "******",
Email = "*****@*****.**"
};
string envelopeId = lblEnvelopeId.Text;
// instantiate an envelopesApi object
//EnvelopesApi envelopesApi = new EnvelopesApi();
EnvelopesApi envelopesApi = new EnvelopesApi(apiClient.Configuration);
// create the recipient view (aka signing URL)
ViewUrl recipientView = envelopesApi.CreateRecipientView(accountId, envelopeId, viewOptions);
// print the JSON response
//Console.WriteLine("ViewUrl:\n{0}", Newtonsoft.Json.JsonConvert.SerializeObject(recipientView));
//Trace.WriteLine("ViewUrl:\n{0}", JsonConvert.SerializeObject(recipientView));
lblView.Text = "ViewUrl:<br />" + Newtonsoft.Json.JsonConvert.SerializeObject(recipientView);
lblView.Text += "<br />" + recipientView.Url;
HyperLink1.NavigateUrl = recipientView.Url;
// Start the embedded signing session
// System.Diagnostics.Process.Start(recipientView.Url);
// In DeBug - We comment out so we can do multiple steps
Response.Redirect(recipientView.Url);
}
catch (Exception ex)
{
string errMsg = "Sign Test View";
lblError.Text += String.Format("<hr /><table class='table_error'>"
+ "<tr><td>Error<td/><td>{0}</td></tr>"
+ "<tr><td>Message<td/><td>{1}</td></tr>"
+ "<tr><td>StackTrace<td/><td>{2}</td></tr>"
+ "<tr><td>Source<td/><td>{3}</td></tr>"
+ "<tr><td>InnerException<td/><td>{4}</td></tr>"
+ "<tr><td>Data<td/><td>{5}</td></tr>"
+ "</table>"
, errMsg //0
, ex.Message //1
, ex.StackTrace //2
, ex.Source //3
, ex.InnerException //4
, ex.Data //5
, ex.HelpLink
, ex.TargetSite
);
}
}
//static void Main(string[] args)
protected void SignIt(object sender, EventArgs e)
{
string userId = "aa621eb5-e488-4135-9698-613136bce319"; // use your userId (guid), not email address
string oauthBasePath = "account-d.docusign.com";
string integratorKey = "ad00790f-c0c8-49d8-a621-904549bc9d88";
string privateKeyFile = Server.MapPath(@"~/App_Data/DocuSign_PrivateKey.pem");
string privateKey = System.IO.File.ReadAllText(privateKeyFile);
int expiresInHours = 1;
string host = "https://demo.docusign.net/restapi";
string accountId = string.Empty;
ApiClient apiClient = new ApiClient(host);
OAuth.OAuthToken tokenInfo = apiClient.ConfigureJwtAuthorizationFlowByKey(integratorKey, userId, oauthBasePath, privateKey, expiresInHours);
/////////////////////////////////////////////////////////////////
// STEP 1: Get User Info
// now that the API client has an OAuth token, let's use it in all// DocuSign APIs
/////////////////////////////////////////////////////////////////
OAuth.UserInfo userInfo = apiClient.GetUserInfo(tokenInfo.access_token);
foreach (var item in userInfo.GetAccounts())
{
if (item.GetIsDefault() == "true")
{
accountId = item.AccountId();
apiClient = new ApiClient(item.GetBaseUri() + "/restapi");
break;
}
}
/////////////////////////////////////////////////////////////////
// STEP 2: CREATE ENVELOPE API
/////////////////////////////////////////////////////////////////
EnvelopeDefinition envDef = new EnvelopeDefinition();
envDef.EmailSubject = "[DocuSign C# SDK] - Please sign this doc";
// assign recipient to template role by setting name, email, and role name. Note that the
// template role name must match the placeholder role name saved in your account template.
TemplateRole tRole = new TemplateRole();
tRole.Email = "[SIGNER_EMAIL]";
tRole.Name = "[SIGNER_NAME]";
tRole.RoleName = "[ROLE_NAME]";
List <TemplateRole> rolesList = new List <TemplateRole>()
{
tRole
};
// add the role to the envelope and assign valid templateId from your account
envDef.TemplateRoles = rolesList;
envDef.TemplateId = "[TEMPLATE_ID]";
// set envelope status to "sent" to immediately send the signature request
envDef.Status = "sent";
// |EnvelopesApi| contains methods related to creating and sending Envelopes (aka signature requests)
EnvelopesApi envelopesApi = new EnvelopesApi(apiClient.Configuration);
EnvelopeSummary envelopeSummary = envelopesApi.CreateEnvelope(accountId, envDef);
}
public static string Put(string url, NameValueCollection parameters, string body, string contentType, OAuthToken consumerToken, OAuthToken oauthToken, WebProxy proxy)
{
string nonce, timestamp;
string fullUrl = EncodeUrl(url, parameters);
string signature = GetSignature(WebMethod.PUT, consumerToken, oauthToken, fullUrl, out timestamp, out nonce);
HttpWebRequest request = CreateWebRequest(fullUrl, WebMethod.PUT, nonce, timestamp, signature, contentType, consumerToken, oauthToken, proxy);
WritePostData(body, request.GetRequestStream(), true);
return GetWebResponse(request);
}
/// <summary>
/// Конструктор
/// </summary>
public OAuthBroker()
{
Token = new OAuthToken();
AccessToken = new OAuthToken();
RequestParameters = new List<RequestParameter>();
}
/// <summary>
/// возвращает строку ресурса для авторизации пользователя
/// </summary>
/// <param name="requestToken">
/// request token
/// </param>
/// <returns>
/// возвращает строку ресурса для авторизации пользователя
/// </returns>
public string GetAuthorizationUrl(OAuthToken requestToken)
{
RequestParameters?.Clear();
RequestParameters = new List<RequestParameter>
{
new RequestParameter(OAuthParam.Callback, Consumer.CallbackUrl),
new RequestParameter(OAuthParam.Token, requestToken.Token)
};
var resultString = Core.Sign(HttpMethods.Post, OAuthConst.AuthorizeUrl, RequestParameters,
Consumer, requestToken);
#if DEBUG
Debug.WriteLine(string.Format("Authorize Url: {0}", resultString));
#endif
return resultString;
}
public static string Upload(string url, NameValueCollection parameters, string path, OAuthToken consumerToken, OAuthToken oauthToken, WebProxy proxy)
{
List<String> files = new List<String>();
files.Add(path);
return UploadAttachments(url, parameters, files, consumerToken, oauthToken, proxy);
}
private static string UploadAttachments(string url, NameValueCollection parameters, List<string> fileNames, OAuthToken consumerToken, OAuthToken oauthToken, WebProxy proxy)
{
string nonce, timestamp;
string beginBoundary = GenerateRandomString(25);
string contentBoundary = "--" + beginBoundary;
string endBoundary = contentBoundary + "--";
string contentTrailer = "\r\n" + endBoundary;
string signature = OAuthHttp.GetSignature(WebMethod.POST, consumerToken, oauthToken, url, out timestamp, out nonce);
string contentType = "multipart/form-data; boundary=" + beginBoundary;
HttpWebRequest request = OAuthHttp.CreateWebRequest(url, WebMethod.POST, nonce, timestamp, signature, contentType, consumerToken, oauthToken, proxy);
Version protocolVersion = HttpVersion.Version11;
string method = WebMethod.POST.ToString();
string contentDisposition = "Content-Disposition: form-data; name=";
request.Headers.Add("Cache-Control", "no-cache");
request.KeepAlive = true;
string postParams = GetPostParameters(parameters, contentBoundary, contentDisposition);
FileInfo[] fi = new FileInfo[fileNames.Count];
int i = 0;
long postDataSize = 0;
int headerLength = 0;
List<string> fileHeaders = new List<string>();
AddFileHeaders(fileNames, contentBoundary, contentDisposition, fi, ref i, ref postDataSize, ref headerLength, fileHeaders);
request.ContentLength = postParams.Length + headerLength + contentTrailer.Length + postDataSize;
System.IO.Stream io = request.GetRequestStream();
WritePostData(postParams, io, false);
i = 0;
foreach (string fileName in fileNames)
{
WritePostData(fileHeaders[i], io, false);
WriteFile(io, fileName);
i++;
}
WritePostData(contentTrailer,io, true);
string response = GetWebResponse(request);
io.Close();
request = null;
return response;
}
private static HttpWebRequest CreateWebRequest(string fullUrl, WebMethod method, string nonce, string timeStamp, string sig, OAuthToken consumerToken, OAuthToken oauthToken, WebProxy proxy)
{
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(fullUrl);
request.Method = method.ToString();
request.Proxy = proxy;
string authHeader = CreateAuthHeader(method, nonce, timeStamp, sig, consumerToken, oauthToken);
request.ContentType = "application/x-www-form-urlencoded";
request.Headers.Add("Authorization", authHeader);
return request;
}
private static string CreateAuthHeader(WebMethod method, string nonce, string timeStamp, string sig, OAuthToken consumerToken, OAuthToken oauthToken)
{
StringBuilder sb = new StringBuilder();
sb.Append("OAuth ");
//sb.Append("realm=\"" + Resources.API_ROOT + "\",");
sb.Append("oauth_consumer_key=\"" + consumerToken.TokenKey + "\",");
if (oauthToken != null && oauthToken.TokenKey.Length > 0)
sb.Append("oauth_token=\"" + oauthToken.TokenKey + "\",");
string authHeader = "oauth_nonce=\"" + nonce + "\"," +
"oauth_timestamp=\"" + timeStamp + "\"," +
"oauth_signature_method=\"" + "HMAC-SHA1" + "\"," +
"oauth_version=\"" + "1.0" + "\"," +
"oauth_signature=\"" +sig + "\"";
sb.Append(authHeader);
return sb.ToString();
}
/// <summary>
/// Получает Access Token
/// </summary>
/// <param name="requestToken">токен</param>
/// <returns>
/// задача, получения токена
/// </returns>
public async Task<OAuthToken> GetAccessTokenAsync(OAuthToken requestToken)
{
RequestParameters?.Clear();
RequestParameters = new List<RequestParameter>
{
new RequestParameter(OAuthParam.Callback, Consumer.CallbackUrl),
new RequestParameter(OAuthParam.ConsumerKey, Consumer.ConsumerKey),
new RequestParameter(OAuthParam.Nonce, OAuthHelpers.GenerateNonce()),
new RequestParameter(OAuthParam.SignatureMethod, OAuthConst.OAuthSignatureMethod),
new RequestParameter(OAuthParam.Timestamp, OAuthHelpers.GenerateTimeStamp()),
new RequestParameter(OAuthParam.Version, OAuthConst.OAuthVersion),
new RequestParameter(OAuthParam.Verifier, Token.Verifier),
new RequestParameter(OAuthParam.Token, Token.Token)
};
var signature = Core.Sign(HttpMethods.Post, OAuthConst.AccessUrl, RequestParameters, Consumer,
requestToken);
using (var client = new HttpClient())
{
var response = await client.PostAsync(signature, null);
if (response == null || !response.IsSuccessStatusCode) return AccessToken;
var content = await response.Content.ReadAsStringAsync();
var parameters = content.Split('&');
foreach (var parameterParts in parameters.Select(parameter => parameter.Split('=')))
{
switch (parameterParts[0])
{
case "oauth_token":
AccessToken.Token = parameterParts[1];
break;
case "oauth_token_secret":
AccessToken.Secret = parameterParts[1];
break;
}
}
}
#if DEBUG
Debug.Indent();
Debug.WriteLineIf(!string.IsNullOrEmpty(AccessToken.Secret) && (!string.IsNullOrEmpty(AccessToken.Token)),
string.Format("Access Token: {0}, Secret: {1}", AccessToken.Token, AccessToken.Secret));
Debug.Unindent();
Debug.WriteLine("Access token complete!");
#endif
return AccessToken;
}
public Consumer(OAuthToken consumerToken)
{
this.consumerToken = consumerToken;
this.Proxy = null;
}
/// <summary>
/// Получает request token
/// </summary>
/// <returns>
/// задача, получения request token
/// </returns>
public async Task<OAuthToken> GetRequestTokenAsync()
{
// возвращаемый токен
var token = new OAuthToken();
// определяем параметры запроса
RequestParameters?.Clear();
RequestParameters = new List<RequestParameter>
{
new RequestParameter(OAuthParam.Callback, Consumer.CallbackUrl),
new RequestParameter(OAuthParam.ConsumerKey, Consumer.ConsumerKey),
new RequestParameter(OAuthParam.Nonce, OAuthHelpers.GenerateNonce()),
new RequestParameter(OAuthParam.SignatureMethod, OAuthConst.OAuthSignatureMethod),
new RequestParameter(OAuthParam.Timestamp, OAuthHelpers.GenerateTimeStamp()),
new RequestParameter(OAuthParam.Version, OAuthConst.OAuthVersion)
};
// подписываем строку запроса
var requestUrl = Core.Sign(HttpMethods.Post, OAuthConst.RequestUrl, RequestParameters, Consumer,
null);
// инициализируем HTTP Client
using (var httpClient = new HttpClient())
{
// осуществляем запрос
var response = await httpClient.PostAsync(requestUrl, null);
//проверяем результат
if (response.StatusCode == HttpStatusCode.Unauthorized ||
response.StatusCode == HttpStatusCode.InternalServerError) return token;
if (response.IsSuccessStatusCode)
{
//асинхронное чтение ответа сервера
var contentResponse = await response.Content.ReadAsStringAsync();
//"режем" по амперсанду
var responsesegments = contentResponse.Split('&');
if (responsesegments.Length <= 0) return token;
foreach (var item in responsesegments.Select(responsesegment => responsesegment.Split('=')))
{
switch (item[0])
{
case "oauth_token":
//возвращаеи токен
token.Token = item[1];
break;
case "oauth_token_secret":
//возвращаем секрет
token.Secret = item[1];
break;
}
}
}
}
#if DEBUG
Debug.Indent();
Debug.WriteLineIf(!string.IsNullOrEmpty(token.Secret) && (!string.IsNullOrEmpty(token.Token)),
string.Format("Token: {0}, Secret: {1}", token.Token, token.Secret));
Debug.Unindent();
Debug.WriteLine("Request token complete!");
#endif
Token = token;
return token;
}
public Consumer(OAuthToken consumerToken, OAuthToken accessToken)
{
this.consumerToken = consumerToken;
this.accessToken = accessToken;
this.Proxy = null;
}
