C# ConsumerBase.PrepareAuthorizedRequest方法代码示例

		public static XDocument UpdateProfileImage(ConsumerBase twitter, string accessToken, Stream image, string contentType) {
			var parts = new[] {
				MultipartPostPart.CreateFormFilePart("image", "twitterPhoto", contentType, image),
			};
			HttpWebRequest request = twitter.PrepareAuthorizedRequest(UpdateProfileImageEndpoint, accessToken, parts);
			IncomingWebResponse response = twitter.Channel.WebRequestHandler.GetResponse(request);
			string responseString = response.GetResponseReader().ReadToEnd();
			return XDocument.Parse(responseString);
		}

        public static XDocument UpdateStatus(ConsumerBase twitter, string accessToken, string message)
        {
            var data = new Dictionary<string, string>();
            data.Add("status", message);

            HttpWebRequest request = twitter.PrepareAuthorizedRequest(UpdateStatusEndpoint, accessToken, data);

            var response = twitter.Channel.WebRequestHandler.GetResponse(request);
            return XDocument.Load(XmlReader.Create(response.GetResponseReader()));
        }

		public static XDocument UpdateProfileBackgroundImage(ConsumerBase twitter, string accessToken, string image, bool tile) {
			var parts = new[] {
				MultipartPostPart.CreateFormFilePart("image", image, "image/" + Path.GetExtension(image).Substring(1).ToLowerInvariant()),
				MultipartPostPart.CreateFormPart("tile", tile.ToString().ToLowerInvariant()),
			};
			HttpWebRequest request = twitter.PrepareAuthorizedRequest(UpdateProfileBackgroundImageEndpoint, accessToken, parts);
			request.ServicePoint.Expect100Continue = false;
			IncomingWebResponse response = twitter.Channel.WebRequestHandler.GetResponse(request);
			string responseString = response.GetResponseReader().ReadToEnd();
			return XDocument.Parse(responseString);
		}

        public static string GetProfile(ConsumerBase consumer, string accessToken)
        {
            if (consumer == null)
            {
                throw new ArgumentNullException("consumer");
            }

            var request = consumer.PrepareAuthorizedRequest(ProfileEndpoint, accessToken, new Dictionary<string, string>());
            var response = consumer.Channel.WebRequestHandler.GetResponse(request);
            string body = response.GetResponseReader().ReadToEnd();
            return body;
        }

        /// <summary>
        /// Gets the current oDesk user.
        /// </summary>
        /// <param name="consumer">The oDesk consumer.</param>
        /// <param name="accessToken">The access token previously retrieved.</param>
        /// <returns>An XML document returned by oDesk.</returns>
        public static XDocument GetUser(ConsumerBase consumer, string accessToken)
        {
            if (consumer == null)
                throw new ArgumentNullException("consumer");

            var request = consumer.PrepareAuthorizedRequest(GetUserEndpoint, accessToken);

            var response = consumer.Channel.WebRequestHandler.GetResponse(request);
            var body = response.GetResponseReader().ReadToEnd();
            var result = XDocument.Parse(body);
            return result;
        }

        public static string Digg(ConsumerBase consumer, string accessToken, string id)
        {
            if (consumer == null)
            {
                throw new ArgumentNullException("consumer");
            }

            var extraData = new Dictionary<string, string>() {
				{ "story_id", id }
			};
            var request = consumer.PrepareAuthorizedRequest(DiggEndpoint, accessToken, extraData);
            var response = consumer.Channel.WebRequestHandler.GetResponse(request);
            string body = response.GetResponseReader().ReadToEnd();
            return body;
        }

        public static void PostBlogEntry(ConsumerBase consumer, string accessToken, string blogUrl, string title, XElement body)
        {
            string feedUrl;
            var getBlogHome = WebRequest.Create(blogUrl);
            using (var blogHomeResponse = getBlogHome.GetResponse()) {
                using (StreamReader sr = new StreamReader(blogHomeResponse.GetResponseStream())) {
                    string homePageHtml = sr.ReadToEnd();
                    Match m = Regex.Match(homePageHtml, @"http://www.blogger.com/feeds/\d+/posts/default");
                    Debug.Assert(m.Success, "Posting operation failed.");
                    feedUrl = m.Value;
                }
            }
            const string Atom = "http://www.w3.org/2005/Atom";
            XElement entry = new XElement(
                XName.Get("entry", Atom),
                new XElement(XName.Get("title", Atom), new XAttribute("type", "text"), title),
                new XElement(XName.Get("content", Atom), new XAttribute("type", "xhtml"), body),
                new XElement(XName.Get("category", Atom), new XAttribute("scheme", "http://www.blogger.com/atom/ns#"), new XAttribute("term", "oauthdemo")));

            MemoryStream ms = new MemoryStream();
            XmlWriterSettings xws = new XmlWriterSettings() {
                Encoding = Encoding.UTF8,
            };
            XmlWriter xw = XmlWriter.Create(ms, xws);
            entry.WriteTo(xw);
            xw.Flush();

            WebRequest request = consumer.PrepareAuthorizedRequest(new MessageReceivingEndpoint(feedUrl, HttpDeliveryMethods.PostRequest | HttpDeliveryMethods.AuthorizationHeaderRequest), accessToken);
            request.ContentType = "application/atom+xml";
            request.Method = "POST";
            request.ContentLength = ms.Length;
            ms.Seek(0, SeekOrigin.Begin);
            using (Stream requestStream = request.GetRequestStream()) {
                ms.CopyTo(requestStream);
            }
            using (HttpWebResponse response = (HttpWebResponse)request.GetResponse()) {
                if (response.StatusCode == HttpStatusCode.Created) {
                    // Success
                } else {
                    // Error!
                }
            }
        }

        /// <summary>
        ///    Updates the authenticating user's status, also known as tweeting.
        /// </summary>
        /// <param name="twitter"></param>
        /// <param name="accessToken"></param>
        /// <param name="status">The text of your status update, typically up to 140 characters. URL encode as necessary. t.co link wrapping may effect character counts.</param>
        /// <param name="includeEntities">When set to either true, t or 1, each tweet will include a node called "entities,". This node offers a variety of metadata about the tweet in a discreet structure, including: user_mentions, urls, and hashtags. While entities are opt-in on timelines at present, they will be made a default component of output in the future. See Tweet Entities for more detail on entities.
        ///  </param>
        /// <returns></returns>
        public static JObject UpdateStatus(ConsumerBase twitter, string accessToken, String status, bool includeEntities)
        {

            var parts = new[] {
				MultipartPostPart.CreateFormPart("status", status),
                MultipartPostPart.CreateFormPart("include_entities", includeEntities.ToString()),
			};

            HttpWebRequest request = twitter.PrepareAuthorizedRequest(UpdateStatusEndpoint, accessToken, parts);
            IncomingWebResponse response = twitter.Channel.WebRequestHandler.GetResponse(request);
          
            using (var responseReader = response.GetResponseReader())
            {
                var result = responseReader.ReadToEnd();

                return JObject.Parse(result);

            }
        }

        /// <summary>
        /// Gets the Gmail address book's contents.
        /// </summary>
        /// <param name="consumer">The Google consumer.</param>
        /// <param name="accessToken">The access token previously retrieved.</param>
        /// <param name="maxResults">The maximum number of entries to return. If you want to receive all of the contacts, rather than only the default maximum, you can specify a very large number here.</param>
        /// <param name="startIndex">The 1-based index of the first result to be retrieved (for paging).</param>
        /// <returns>An XML document returned by Google.</returns>
        public static XDocument GetContacts(ConsumerBase consumer, string accessToken, int maxResults/* = 25*/, int startIndex/* = 1*/)
        {
            if (consumer == null) {
                throw new ArgumentNullException("consumer");
            }

            var extraData = new Dictionary<string, string>() {
                { "start-index", startIndex.ToString(CultureInfo.InvariantCulture) },
                { "max-results", maxResults.ToString(CultureInfo.InvariantCulture) },
            };
            var request = consumer.PrepareAuthorizedRequest(GetContactsEndpoint, accessToken, extraData);
            var response = consumer.Channel.WebRequestHandler.GetResponse(request);
            string body = response.GetResponseReader().ReadToEnd();
            XDocument result = XDocument.Parse(body);
            return result;
        }

	    public static Stream GetDoc(ConsumerBase consumer, string accessToken, string docEndpoint, out long size)
        {
            if (consumer == null)
            {
                throw new ArgumentNullException("consumer");
            }
            var endpoint = new MessageReceivingEndpoint(docEndpoint, HttpDeliveryMethods.GetRequest | HttpDeliveryMethods.AuthorizationHeaderRequest);
            var extraData = new Dictionary<string, string>() /*{ {"GData-Version","3.0"} }*/;
            var request = consumer.PrepareAuthorizedRequest(endpoint, accessToken, extraData);
            var response = consumer.Channel.WebRequestHandler.GetResponse(request);
            if (!string.IsNullOrEmpty(response.Headers[HttpResponseHeader.ContentLength]))
            {
                long.TryParse(response.Headers[HttpResponseHeader.ContentLength], out size);
            }
            else
            {
                size = 0;
            }
            return response.ResponseStream;
        }

	    public static XDocument GetDocList(ConsumerBase consumer, string accessToken, string nextEndpoint)
        {
            if (consumer == null)
            {
                throw new ArgumentNullException("consumer");
            }
            var endpoint = GetDocsEntriesEndpoint;
            if (!string.IsNullOrEmpty(nextEndpoint))
            {
                endpoint = new MessageReceivingEndpoint(nextEndpoint, HttpDeliveryMethods.GetRequest);
            }

            var extraData = new Dictionary<string, string>() /*{ {"GData-Version","3.0"} }*/;
            //var request = consumer.PrepareAuthorizedRequest(endpoint, accessToken, extraData);
            //var response = consumer.Channel.WebRequestHandler.GetResponse(request);
            //string body = response.GetResponseReader().ReadToEnd();
            //XDocument result = XDocument.Parse(body);
            //return result;

            var request = consumer.PrepareAuthorizedRequest(endpoint, accessToken, extraData);

            // Enable gzip compression.  Google only compresses the response for recognized user agent headers. - Mike Lim
            request.AutomaticDecompression = DecompressionMethods.GZip;
            request.UserAgent = "Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US) AppleWebKit/534.16 (KHTML, like Gecko) Chrome/10.0.648.151 Safari/534.16";

            var response = consumer.Channel.WebRequestHandler.GetResponse(request);
            string body = response.GetResponseReader().ReadToEnd();
            XDocument result = XDocument.Parse(body);
            return result;

        }

 public static string Tweet(ConsumerBase twitter, string accessToken, string status)
 {
     Dictionary<string, string> extraData = new Dictionary<string, string>();
     extraData.Add("status", status);
     HttpWebRequest request = twitter.PrepareAuthorizedRequest(TweetEndpoint, accessToken, extraData);
     IncomingWebResponse response = twitter.Channel.WebRequestHandler.GetResponse(request);
     return response.GetResponseReader().ReadToEnd();
 }

        /// <summary>
        ///  NOTE: Method does not currently work
        /// </summary>
        public static XDocument PostJob(ConsumerBase consumer, string accessToken, string apiKey, string sharedSecret,
            string title, string description, string buyerTeamReference)
        {
            if (consumer == null)
            {
                throw new ArgumentNullException("consumer");
            }

            //List<NameValuePair> nameValuePairs = new ArrayList<NameValuePair>(2);

            //for (Map.Entry<String, String> entry : params.entrySet()) {
            //    String key = entry.getKey();
            //    String value = entry.getValue();
            //    nameValuePairs.add(new BasicNameValuePair(key, value));
            //}
            //httpPost.setEntity(new UrlEncodedFormEntity(nameValuePairs));

            var parameters = new Dictionary<string, string>()
                                 {
                                     {"title", title},
                                     {"job_type", "hourly"},
                                     {"description", description},
                                     {"buyer_team_reference", buyerTeamReference},
                                     {"visibility", "public"},
                                     {"duration", "16"},
                                     {"category", "Web Development"},
                                     {"subcategory", "Web Programming"}//,
                                     //{"api_key", apiKey}, Not sure these are required or not
                                     //{"api_token", accessToken}
                                 };
            var paramWrapper = new Dictionary<string, Dictionary<string, string>>()
                                   {
                                       {"job_data", parameters}
                                   };
            //parameters.Add("api_sig", CalcApiSig(parameters, sharedSecret));

            var parts = paramWrapper.Select(x => MultipartPostPart.CreateFormPart(x.Key, x.Value.ToString()));

            var request = consumer.PrepareAuthorizedRequest(PostJobEndpoint, accessToken, parts); //, extraData);

            var response = consumer.Channel.WebRequestHandler.GetResponse(request);
            var body = response.GetResponseReader().ReadToEnd();
            var result = XDocument.Parse(body);
            return result;
        }

	    public static XDocument GetDocList(ConsumerBase consumer, string accessToken, string nextEndpoint)
        {
            if (consumer == null)
            {
                throw new ArgumentNullException("consumer");
            }
            var endpoint = GetDocsEntriesEndpoint;
            if (!string.IsNullOrEmpty(nextEndpoint))
            {
                endpoint = new MessageReceivingEndpoint(nextEndpoint, HttpDeliveryMethods.GetRequest);
            }

            var extraData = new Dictionary<string, string>() /*{ {"GData-Version","3.0"} }*/;
            var request = consumer.PrepareAuthorizedRequest(endpoint, accessToken, extraData);
            var response = consumer.Channel.WebRequestHandler.GetResponse(request);
            string body = response.GetResponseReader().ReadToEnd();
            XDocument result = XDocument.Parse(body);
            return result;
        }

        /// <summary>
        /// Gets the Gmail address book's contents.
        /// </summary>
        /// <param name="consumer">The Google consumer.</param>
        /// <param name="accessToken">The access token previously retrieved.</param>
        /// <param name="maxResults">The maximum number of entries to return. If you want to receive all of the contacts, rather than only the default maximum, you can specify a very large number here.</param>
        /// <param name="startIndex">The 1-based index of the first result to be retrieved (for paging).</param>
        /// <returns>An XML document returned by Google.</returns>
        public static XDocument GetContacts(ConsumerBase consumer, string accessToken, int maxResults/* = 25*/, int startIndex/* = 1*/)
        {
            if (consumer == null) {
                throw new ArgumentNullException("consumer");
            }

            var extraData = new Dictionary<string, string>() {
                { "start-index", startIndex.ToString(CultureInfo.InvariantCulture) },
                { "max-results", maxResults.ToString(CultureInfo.InvariantCulture) },
            };
            var request = consumer.PrepareAuthorizedRequest(GetContactsEndpoint, accessToken, extraData);

            // Enable gzip compression.  Google only compresses the response for recognized user agent headers. - Mike Lim
            request.AutomaticDecompression = DecompressionMethods.GZip;
            request.UserAgent = "Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US) AppleWebKit/534.16 (KHTML, like Gecko) Chrome/10.0.648.151 Safari/534.16";

            var response = consumer.Channel.WebRequestHandler.GetResponse(request);
            string body = response.GetResponseReader().ReadToEnd();
            XDocument result = XDocument.Parse(body);
            return result;
        }