public static AuthorizedTokenResponse CompleteAuthorization(DesktopConsumer consumer, string requestToken, string userCode)
{
var customServiceDescription = new ServiceProviderDescription
{
RequestTokenEndpoint = ServiceProviderDescription.RequestTokenEndpoint,
UserAuthorizationEndpoint =
new MessageReceivingEndpoint(
string.Format("{0}?key={1}&token={2}", ServiceProviderDescription.UserAuthorizationEndpoint.Location.AbsoluteUri,
consumer.TokenManager.ConsumerKey, requestToken),
HttpDeliveryMethods.AuthorizationHeaderRequest | HttpDeliveryMethods.GetRequest),
AccessTokenEndpoint = new MessageReceivingEndpoint(
ServiceProviderDescription.AccessTokenEndpoint.Location.AbsoluteUri + "?oauth_verifier" + userCode + string.Empty,
HttpDeliveryMethods.AuthorizationHeaderRequest | HttpDeliveryMethods.GetRequest),
TamperProtectionElements = ServiceProviderDescription.TamperProtectionElements,
ProtocolVersion = ProtocolVersion.V10a
};
var customConsumer = new DesktopConsumer(customServiceDescription, consumer.TokenManager);
var response = customConsumer.ProcessUserAuthorization(requestToken, userCode);
return(response);
}
private async Task <ImageUpload> UploadImage(string albumUri, string fileName, byte[] image, CancellationToken cancellationToken)
{
using (HttpClient client = new HttpClient())
{
client.BaseAddress = new Uri(SMUGMUG_API_v2_UploadEndpoint);
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
client.DefaultRequestHeaders.Add("X-Smug-AlbumUri", albumUri);
client.DefaultRequestHeaders.Add("X-Smug-FileName", fileName);
client.DefaultRequestHeaders.Add("X-Smug-ResponseType", "JSON");
client.DefaultRequestHeaders.Add("X-Smug-Version", "v2");
if (LoginType == LoginType.OAuth)
{
smugmugConsumer = new DesktopConsumer(smugmugServiceDescription, smugmugTokenManager);
HttpDeliveryMethods resourceHttpMethod = HttpDeliveryMethods.PostRequest | HttpDeliveryMethods.AuthorizationHeaderRequest;
var resourceEndpoint = new MessageReceivingEndpoint(SMUGMUG_API_v2_UploadEndpoint, resourceHttpMethod);
var httpRequest = smugmugConsumer.PrepareAuthorizedRequest(resourceEndpoint, smugmugTokenManager.AccessToken);
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("OAuth", httpRequest.Headers["Authorization"].Substring(6));
}
else
{
throw new NotSupportedException(string.Format("LoginType {0} is unsupported", LoginType));
}
var content = new StreamContent(new MemoryStream(image));
HttpResponseMessage httpResponse = client.PostAsync(SMUGMUG_API_v2_UploadEndpoint, content, cancellationToken).Result;
System.Diagnostics.Trace.WriteLine(string.Format("POST {0}", httpResponse.RequestMessage.RequestUri));
httpResponse.EnsureSuccessStatusCode();
ImagePostResponse contentResponse = await httpResponse.Content.ReadAsAsync <ImagePostResponse>();
System.Diagnostics.Trace.WriteLine(string.Format("---{0} {1}: {2}", contentResponse.Stat, contentResponse.Method, contentResponse.Image));
return(contentResponse.Image);
}
}
private async Task <T> PostRequest <T>(string baseAddress, string endpoint, string jsonContent)
{
using (HttpClient client = new HttpClient())
{
client.BaseAddress = new Uri(baseAddress);
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
if (LoginType == LoginType.Anonymous)
{
endpoint = string.Format("{0}{2}APIKey={1}", endpoint, smugmugTokenManager.ConsumerKey, endpoint.Contains('?') ? "&" : "?");
}
else if (LoginType == LoginType.OAuth)
{
smugmugConsumer = new DesktopConsumer(smugmugServiceDescription, smugmugTokenManager);
HttpDeliveryMethods resourceHttpMethod = HttpDeliveryMethods.PostRequest | HttpDeliveryMethods.AuthorizationHeaderRequest;
var resourceEndpoint = new MessageReceivingEndpoint(baseAddress + endpoint, resourceHttpMethod);
var httpRequest = smugmugConsumer.PrepareAuthorizedRequest(resourceEndpoint, smugmugTokenManager.AccessToken);
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("OAuth", httpRequest.Headers["Authorization"].Substring(6));
}
else
{
throw new NotSupportedException(string.Format("LoginType {0} is unsupported", LoginType));
}
HttpResponseMessage httpResponse = client.PostAsync(endpoint, new StringContent(jsonContent)).Result;
System.Diagnostics.Trace.WriteLine(string.Format("POST {0}: {1}", httpResponse.RequestMessage.RequestUri, jsonContent));
PostResponseStub <T> contentResponse = null;
if (httpResponse.IsSuccessStatusCode)
{
contentResponse = await httpResponse.Content.ReadAsAsync <PostResponseStub <T> >();
}
else
{
var failedResponse = httpResponse.Content.ReadAsStringAsync();
JObject response = JObject.Parse(failedResponse.Result);
var invalidParameters =
from p in response["Options"]["Parameters"]["POST"]
where p["Problems"] != null
select new POSTParameter
{
ParameterName = (string)p["Name"],
Problem = (string)p["Problems"].First()
};
if (invalidParameters.Count() > 0)
{
List <ArgumentException> argumentExceptions = new List <ArgumentException>();
foreach (POSTParameter invalidParameter in invalidParameters)
{
argumentExceptions.Add(new ArgumentException(invalidParameter.Problem, invalidParameter.ParameterName));
}
throw new AggregateException("HTTP POST Request failed. See inner exceptions for individual reasons.", argumentExceptions.ToArray());
}
else
{
throw new HttpRequestException("HTTP POST Request failed for unknown reasons");
}
}
System.Diagnostics.Trace.WriteLine(string.Format("---{0} {1}: {2}", contentResponse.Code, contentResponse.Message, contentResponse.Response));
return(contentResponse.Response);
}
}
private static HttpMessageHandler OAuthHandler(string requestTokenURL,
string authorizationTokenURL,
string accessTokenURL,
string consumerKey,
string consumerSecret,
string user,
string passwd,
string authUrl)
{
ServiceProviderDescription serviceDescription = new ServiceProviderDescription();
serviceDescription.AccessTokenEndpoint = new MessageReceivingEndpoint(new Uri(accessTokenURL), HttpDeliveryMethods.PostRequest);
serviceDescription.ProtocolVersion = ProtocolVersion.V10a;
serviceDescription.RequestTokenEndpoint = new MessageReceivingEndpoint(new Uri(requestTokenURL), HttpDeliveryMethods.PostRequest);
serviceDescription.TamperProtectionElements = new ITamperProtectionChannelBindingElement[] { new HmacSha1SigningBindingElement() };
serviceDescription.UserAuthorizationEndpoint = new MessageReceivingEndpoint(new Uri(authorizationTokenURL), HttpDeliveryMethods.PostRequest);
TokenManager tokenManager = new TokenManager(consumerKey, consumerSecret);
WebConsumer consumer = new WebConsumer(serviceDescription, tokenManager);
// callback is never called by CLM, but needed to do OAuth based forms login
// XXX - Dns.GetHostName() alway seems to return simple, uppercased hostname
string callback = "https://" + Dns.GetHostName() + '.' + IPGlobalProperties.GetIPGlobalProperties().DomainName + ":9443/cb";
callback = callback.ToLower();
consumer.PrepareRequestUserAuthorization(new Uri(callback), null, null);
OslcClient oslcClient = new OslcClient();
HttpClient client = oslcClient.GetHttpClient();
HttpStatusCode statusCode = HttpStatusCode.Unused;
string location = null;
HttpResponseMessage resp;
try
{
client.DefaultRequestHeaders.Clear();
resp = client.GetAsync(authorizationTokenURL + "?oauth_token=" + tokenManager.GetRequestToken() +
"&oauth_callback=" + Uri.EscapeUriString(callback).Replace("#", "%23").Replace("/", "%2F").Replace(":", "%3A")).Result;
statusCode = resp.StatusCode;
if (statusCode == HttpStatusCode.Found)
{
location = resp.Headers.Location.AbsoluteUri;
resp.ConsumeContent();
statusCode = FollowRedirects(client, statusCode, location);
}
string securityCheckUrl = "j_username="******"&j_password="******"application/x-www-form-urlencoded");
mediaTypeValue.CharSet = "utf-8";
content.Headers.ContentType = mediaTypeValue;
resp = client.PostAsync(authUrl + "/j_security_check", content).Result;
statusCode = resp.StatusCode;
string jazzAuthMessage = null;
IEnumerable <string> values = new List <string>();
if (resp.Headers.TryGetValues(JAZZ_AUTH_MESSAGE_HEADER, out values))
{
jazzAuthMessage = values.Last();
}
if (jazzAuthMessage != null && string.Compare(jazzAuthMessage, JAZZ_AUTH_FAILED, true) == 0)
{
resp.ConsumeContent();
throw new JazzAuthFailedException(user, authUrl);
}
else if (statusCode != HttpStatusCode.OK && statusCode != HttpStatusCode.Found)
{
resp.ConsumeContent();
throw new JazzAuthErrorException(statusCode, authUrl);
}
else //success
{
Uri callbackUrl = resp.Headers.Location;
resp = client.GetAsync(callbackUrl.AbsoluteUri).Result;
callbackUrl = resp.Headers.Location;
resp = client.GetAsync(callbackUrl.AbsoluteUri).Result;
callbackUrl = resp.Headers.Location;
NameValueCollection qscoll = callbackUrl.ParseQueryString();
if (callbackUrl.OriginalString.StartsWith(callback + '?') && qscoll["oauth_verifier"] != null)
{
DesktopConsumer desktopConsumer = new DesktopConsumer(serviceDescription, tokenManager);
AuthorizedTokenResponse authorizedTokenResponse = desktopConsumer.ProcessUserAuthorization(tokenManager.GetRequestToken(), qscoll["oauth_verifier"]);
return(consumer.CreateAuthorizingHandler(authorizedTokenResponse.AccessToken, CreateSSLHandler()));
}
throw new JazzAuthErrorException(statusCode, authUrl);
}
} catch (JazzAuthFailedException jfe) {
throw jfe;
} catch (JazzAuthErrorException jee) {
throw jee;
} catch (Exception e) {
Console.WriteLine(e.StackTrace);
}
// return consumer.CreateAuthorizingHandler(accessToken);
return(null);
}
