public TwitPicUploader(string key, OAuthInfo oauth)
 {
     APIKey = key;
     AuthInfo = oauth;
     TwitPicUploadType = TwitPicUploadType.UPLOAD_IMAGE_ONLY;
     ShowFull = false;
     TwitPicThumbnailMode = TwitPicThumbnailType.Thumb;
 }

 private AccountInfo GetAccountInfo(OAuthInfo oauth)
 {
     var uri = new Uri("https://api.dropbox.com/1/account/info");
     var client = GetDropboxClient(HttpMethod.Get, uri, oauth);
     var response = client.GetAsync(uri.PathAndQuery).Result.EnsureSuccessful();
     using (var reader = new JsonTextReader(new StreamReader(response.Content.ReadAsStreamAsync().Result)))
     {
         JsonSerializer serializer = new JsonSerializer();
         return serializer.Deserialize<AccountInfo>(reader);
     }
 }

        public void Tweet(string text)
        {
            string[] creds = File.ReadAllLines("./config.cfg");
            OAuthInfo TInfo = new OAuthInfo();
            TInfo.ConsumerKey = creds[0];
            TInfo.ConsumerSecret = creds[1];
            TInfo.AccessToken = creds[2];
            TInfo.AccessSecret = creds[3];
            TinyTwitter.TinyTwitter Manager = new TinyTwitter.TinyTwitter(TInfo);

            Manager.UpdateStatus(text.Replace("\n\n",""));
        }

        private DeltaInfo GetDeltaInfo(OAuthInfo oauth, string cursor = null)
        {
            Uri uri;
            HttpClient client;
            if (!String.IsNullOrEmpty(cursor))
            {
                uri = new Uri("https://api.dropbox.com/1/delta/?cursor=" + cursor);
                client = GetDropboxClient(HttpMethod.Post, uri, oauth, new KeyValuePair<string, string>("cursor", cursor));
            }
            else
            {
                uri = new Uri("https://api.dropbox.com/1/delta");
                client = GetDropboxClient(HttpMethod.Post, uri, oauth);
            }

            var response = client.PostAsync(uri.PathAndQuery, null).Result.EnsureSuccessful();
            using (var reader = new JsonTextReader(new StreamReader(response.Content.ReadAsStreamAsync().Result)))
            {
                JsonSerializer serializer = new JsonSerializer();
                return new DeltaInfo(serializer.Deserialize<JObject>(reader));
            }
        }

        static void Main(string[] args)
        {
            //OAuthInfo myOAuth = new OAuthInfo();
            //myOAuth.ConsumerKey = "";
            //myOAuth.ConsumerSecret = "";
            //myOAuth.AccessSecret = "";
            //myOAuth.AccessToken = "";

            //var myOauth = new

            //TinyTwitter TT = new TinyTwitter(new OAuthInfo());

            //IEnumerable<Tweet> mytimneline = TT.GetHomeTimeline(null, 2);
            var oauth = new OAuthInfo
            {
                AccessToken = "21985278-dud1wSertHCQYTUK5ta5AA0ciqWB31ZsT8Dt8DJg",
                AccessSecret = "yPDp2TTOOhQj6XDxX7P5TxmNtHZcQ6sJumth8DVzRk",
                ConsumerKey = "tedRo766zL7mr7TKZkOugA",
                ConsumerSecret = "WREOp5SZ71EtLCt3T4RboUv1IrkUpPkCpcBxkAGk8"
            };

            var twitter = new TinyTwitter(oauth);

            //// Update status, i.e, post a new tweet
            //twitter.UpdateStatus("I'm tweeting from C#");

            // Get home timeline tweets
            var tweets = twitter.GetUserTimeline(null, 5);

            //twitter.UpdateStatus("First tweet from my program");
               // twitter.UpdateStatus("First tweet from my program");
            foreach (var tweet in tweets)
                Console.WriteLine("{0}: {1}: {2}", tweet.UserName, tweet.Text, tweet.Id);

            Console.ReadKey();
        }

        public Jira(string jiraBaseAddress, OAuthInfo oauth, string jiraIssuePrefix = null)
        {
            _jiraBaseAddress = jiraBaseAddress;
            AuthInfo = oauth;
            _jiraIssuePrefix = jiraIssuePrefix;

            InitUris();
        }

 protected bool GetAccessToken(string accessTokenURL, OAuthInfo authInfo, HttpMethod httpMethod = HttpMethod.GET)
 {
     return GetAccessTokenEx(accessTokenURL, authInfo, httpMethod) != null;
 }

 public TwitterTweetForm(OAuthInfo oauth)
     : this()
 {
     AuthInfo = oauth;
 }

        public static void Main(string[] args)
        {
            //Load config
            XmlData config;

            try
            {
                config=new XmlData("tweetstatus.xml");
            }
            catch(Exception e)
            {
                Console.WriteLine("Konfiguration konnte nicht gelesen werden.");
                Console.WriteLine(e.ToString());
                return;
            }

            string miscCheckCertificates=config.GetElementAsString("xml.misc.checkcertificates");

            if(miscCheckCertificates.ToLower()=="false")
            {
                //Disable certificate check
                ServicePointManager.ServerCertificateValidationCallback=delegate
                {
                    return true;
                };
            }

            string apiToken=config.GetElementAsString("xml.api.token");
            string apiUrl=config.GetElementAsString("xml.api.url");

            string twitterConsumerKey=config.GetElementAsString("xml.twitter.consumerkey");
            string twitterConsumerSecret=config.GetElementAsString("xml.twitter.consumersecret");

            string twitterAccessToken=config.GetElementAsString("xml.twitter.accesstoken");
            string twitterAccessTokenSecret=config.GetElementAsString("xml.twitter.accesstokensecret");

            //Create twitter token
            OAuthInfo token=null;

            if(twitterAccessToken==""||twitterAccessTokenSecret=="")
            {
                Console.WriteLine("Set access token in config file");
                return;
            }
            else
            {
                token=new OAuthInfo {
                    AccessToken=twitterAccessToken,
                    AccessSecret=twitterAccessTokenSecret,
                    ConsumerKey=twitterConsumerKey,
                    ConsumerSecret=twitterConsumerSecret
                };
            }

            //Check status database
            Console.WriteLine("Check status database");

            //Database
            RestClient client=new RestClient(apiUrl);
            string parameters=String.Format("entities/?token={0}", apiToken);

            string value=client.Request(parameters);
            int entityCount=Convert.ToInt32(value);

            Console.WriteLine("Entity count from api: {0}", entityCount);

            //Check status file and tweet if nessesary
            //Load known entries
            string entryFile="status.txt";

            Entry oldStatus=new Entry(0);

            if(File.Exists(entryFile))
            {
                oldStatus=new Entry(File.ReadAllLines(entryFile)[0]);
            }

            Entry newStatus=new Entry(entityCount);

            if(oldStatus!=newStatus)
            {
                //Tweet
                DateTime now=DateTime.Now;
                string datetimeHash="#"+CRC16.ComputeChecksum(BitConverter.GetBytes(now.Ticks)).ToString("x4");

                string statusGreen=String.Format("Der Hackerspace ist besetzt ({0}:{1:00} Uhr) und kann besucht werden. #status {2}", now.Hour, now.Minute, datetimeHash);
                string statusYellow="";
                string statusRed=String.Format("Der Hackerspace ist nicht mehr besetzt ({0}:{1:00} Uhr). #status {2}", now.Hour, now.Minute, datetimeHash);

                string tweetText="";

                if(newStatus.EntityCount==0)
                {
                    tweetText=statusRed;
                }
                else
                {
                    if(oldStatus.EntityCount>0)
                    {
                        Console.WriteLine("Update not necessary.");
//.........这里部分代码省略.........

        private void TwitterAuthClear()
        {
            if (CheckTwitterAccounts())
            {
                OAuthInfo oauth = new OAuthInfo();

                OAuthInfo oauth2 = GetSelectedTwitterAccount();

                if (oauth2 != null)
                {
                    oauth.Description = oauth2.Description;
                }

                Config.TwitterOAuthInfoList[Config.TwitterSelectedAccount] = oauth;
            }
        }

        public void CopyAuthOpen()
        {
            try
            {
                OAuthInfo oauth = new OAuthInfo(APIKeys.CopyConsumerKey, APIKeys.CopyConsumerSecret);

                string url = new Copy(oauth).GetAuthorizationURL();

                if (!string.IsNullOrEmpty(url))
                {
                    Config.CopyOAuthInfo = oauth;
                    URLHelpers.OpenURL(url);
                    DebugHelper.WriteLine("CopyAuthOpen - Authorization URL is opened: " + url);
                }
                else
                {
                    DebugHelper.WriteLine("CopyAuthOpen - Authorization URL is empty.");
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.ToString(), Resources.UploadersConfigForm_Error, MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

        public void TwitterAuthOpen()
        {
            if (CheckTwitterAccounts())
            {
                OAuthInfo acc = new OAuthInfo(APIKeys.TwitterConsumerKey, APIKeys.TwitterConsumerSecret);
                Twitter twitter = new Twitter(acc);
                string url = twitter.GetAuthorizationURL();

                if (!string.IsNullOrEmpty(url))
                {
                    acc.Description = Config.TwitterOAuthInfoList[Config.TwitterSelectedAccount].Description;
                    Config.TwitterOAuthInfoList[Config.TwitterSelectedAccount] = acc;
                    ucTwitterAccounts.pgSettings.SelectedObject = acc;
                    URLHelpers.OpenURL(url);
                    btnTwitterLogin.Enabled = true;
                }
            }
        }

 public Twitter(OAuthInfo oauth)
 {
     AuthInfo = oauth;
 }

        protected NameValueCollection GetAccessTokenEx(string accessTokenURL, OAuthInfo authInfo, HttpMethod httpMethod = HttpMethod.GET)
        {
            if (string.IsNullOrEmpty(authInfo.AuthToken) || string.IsNullOrEmpty(authInfo.AuthSecret))
            {
                throw new Exception("Auth infos missing. Open Authorization URL first.");
            }

            string url = OAuthManager.GenerateQuery(accessTokenURL, null, httpMethod, authInfo);

            string response = SendRequest(httpMethod, url);

            if (!string.IsNullOrEmpty(response))
            {
                return OAuthManager.ParseAccessTokenResponse(response, authInfo);
            }

            return null;
        }

 public Copy(OAuthInfo oauth)
 {
     AuthInfo = oauth;
 }

 public TwitSnapsUploader(string apiKey, OAuthInfo oauth)
 {
     APIKey = apiKey;
     AuthInfo = oauth;
 }

 private void TwitterAccountAddButton_Click(object sender, EventArgs e)
 {
     OAuthInfo acc = new OAuthInfo();
     Config.TwitterOAuthInfoList.Add(acc);
     ucTwitterAccounts.AddItem(acc);
 }

        protected string GetAuthorizationURL(string requestTokenURL, string authorizeURL, OAuthInfo authInfo,
            Dictionary<string, string> customParameters = null, HttpMethod httpMethod = HttpMethod.GET)
        {
            string url = OAuthManager.GenerateQuery(requestTokenURL, customParameters, httpMethod, authInfo);

            string response = SendRequest(httpMethod, url);

            if (!string.IsNullOrEmpty(response))
            {
                return OAuthManager.GetAuthorizationURL(response, authInfo, authorizeURL);
            }

            return null;
        }

        private DropboxDeployInfo GetDeployInfo(OAuthInfo oauth, string cursor = null)
        {
            List<DropboxDeltaInfo> deltas = new List<DropboxDeltaInfo>();
            string timeStamp = GetUtcTimeStamp();
            string oldCursor = cursor;
            string newCursor = "";
            while (true)
            {
                DeltaInfo delta = GetDeltaInfo(oauth, cursor);
                newCursor = delta.cursor;
                if (newCursor == oldCursor)
                {
                    break;
                }

                foreach (EntryInfo info in delta.entries)
                {
                    DropboxDeltaInfo item = new DropboxDeltaInfo { Path = info.path };
                    if (info.metadata == null || info.metadata.is_deleted || string.IsNullOrEmpty(info.metadata.path))
                    {
                        item.IsDeleted = true;
                    }
                    else
                    {
                        item.IsDirectory = info.metadata.is_dir;
                        if (!item.IsDirectory)
                        {
                            item.Modified = info.metadata.modified;
                            item.Nonce = GetNonce();
                            item.Signature = GetSignature(oauth, info.path, timeStamp, item.Nonce);
                        }
                    }

                    deltas.Add(item);
                }

                if (!delta.has_more)
                {
                    break;
                }
            }

            if (deltas.Count == 0)
            {
                throw new InvalidOperationException("the repo is up-to-date.");
            }

            return new DropboxDeployInfo
            {
                TimeStamp = timeStamp,
                Token = oauth.Token,
                ConsumerKey = oauth.ConsumerKey,
                OAuthVersion = "1.0",
                SignatureMethod = "HMAC-SHA1",
                OldCursor = oldCursor,
                NewCursor = newCursor,
                Path = "/",
                Deltas = deltas
            };
        }

        private void btnTwitterAdd_Click(object sender, EventArgs e)
        {
            OAuthInfo oauth = new OAuthInfo();
            Config.TwitterOAuthInfoList.Add(oauth);
            lvTwitterAccounts.Items.Add(oauth.Description);
            lvTwitterAccounts.SelectLast();

            TwitterUpdateSelected();
        }