12 files changed, 319 insertions, 0 deletions

@@ -0,0 +1,9 @@
+[submodule "vendor/liboauthcpp"]
+        path = vendor/liboauthcpp
+        url = https://github.com/sirikata/liboauthcpp
+[submodule "vendor/json"]
+        path = vendor/json
+        url = https://github.com/nlohmann/json
+[submodule "vendor/curlcpp"]
+        path = vendor/curlcpp
+        url = https://github.com/JosephP91/curlcpp
@@ -0,0 +1,15 @@
+cmake_minimum_required (VERSION 3.1)
+project (twitter++)
+
+include_directories(vendor/json/src)
+
+add_subdirectory(vendor/liboauthcpp/build EXCLUDE_FROM_ALL)
+include_directories(vendor/liboauthcpp/include)
+
+add_subdirectory(vendor/curlcpp)
+include_directories(${CURLCPP_SOURCE_DIR}/include)
+
+add_library(twitter++ src/client.cpp src/auth.cpp src/tweet.cpp)
+set_property(TARGET twitter++ PROPERTY CXX_STANDARD 11)
+set_property(TARGET twitter++ PROPERTY CXX_STANDARD_REQUIRED ON)
+target_link_libraries(twitter++ oauthcpp curlcpp)
@@ -0,0 +1,45 @@
+#include "twitter.h"
+
+namespace twitter {
+  
+  void auth::setConsumerKey(std::string _arg)
+  {
+    _consumer_key = _arg;
+  }
+  
+  void auth::setConsumerSecret(std::string _arg)
+  {
+    _consumer_secret = _arg;
+  }
+  
+  void auth::setAccessKey(std::string _arg)
+  {
+    _access_key = _arg;
+  }
+  
+  void auth::setAccessSecret(std::string _arg)
+  {
+    _access_secret = _arg;
+  }
+  
+  std::string auth::getConsumerKey() const
+  {
+    return _consumer_key;
+  }
+  
+  std::string auth::getConsumerSecret() const
+  {
+    return _consumer_secret;
+  }
+  
+  std::string auth::getAccessKey() const
+  {
+    return _access_key;
+  }
+  
+  std::string auth::getAccessSecret() const
+  {
+    return _access_secret;
+  }
+    
+};
@@ -0,0 +1,29 @@
+#ifndef AUTH_H_48EF85FD
+#define AUTH_H_48EF85FD
+
+#include <string>
+
+namespace twitter {
+  
+  class auth {
+    public:
+      void setConsumerKey(std::string _arg);
+      void setConsumerSecret(std::string _arg);
+      void setAccessKey(std::string _arg);
+      void setAccessSecret(std::string _arg);
+      
+      std::string getConsumerKey() const;
+      std::string getConsumerSecret() const;
+      std::string getAccessKey() const;
+      std::string getAccessSecret() const;
+      
+    private:
+      std::string _consumer_key;
+      std::string _consumer_secret;
+      std::string _access_key;
+      std::string _access_secret;
+  };
+  
+};
+
+#endif /* end of include guard: AUTH_H_48EF85FD */
@@ -0,0 +1,124 @@
+#include "client.h"
+#include <curl_easy.h>
+#include <curl_header.h>
+#include <sstream>
+#include <set>
+#include <algorithm>
+#include <liboauthcpp/liboauthcpp.h>
+
+namespace twitter {
+  
+  client::client(const auth& _arg)
+  {
+    _oauth_consumer = new OAuth::Consumer(_arg.getConsumerKey(), _arg.getConsumerSecret());
+    _oauth_token = new OAuth::Token(_arg.getAccessKey(), _arg.getAccessSecret());
+    _oauth_client = new OAuth::Client(_oauth_consumer, _oauth_token);
+  }
+  
+  client::~client()
+  {
+    delete _oauth_client;
+    delete _oauth_token;
+    delete _oauth_consumer;
+  }
+  
+  response client::updateStatus(std::string msg, tweet& result)
+  {
+    std::ostringstream output;
+    curl::curl_ios<std::ostringstream> ios(output);
+    curl::curl_easy conn(ios);
+    
+    std::stringstream datastrstream;
+    datastrstream << "status=" << OAuth::PercentEncode(msg);
+    
+    std::string datastr = datastrstream.str();
+    std::string url = "https://api.twitter.com/1.1/statuses/update.json";
+    
+    curl::curl_header headers;
+    std::string oauth_header = _oauth_client->getFormattedHttpHeader(OAuth::Http::Post, url, datastr);
+    if (!oauth_header.empty())
+    {
+      headers.add(oauth_header);
+    }
+    
+    try {
+      conn.add<CURLOPT_URL>(url.c_str());
+      conn.add<CURLOPT_COPYPOSTFIELDS>(datastr.c_str());
+      conn.add<CURLOPT_POST>(1);
+      conn.add<CURLOPT_HTTPHEADER>(headers.get());
+      
+      conn.perform();
+    } catch (curl::curl_easy_exception error)
+    {
+      error.print_traceback();
+      
+      return response::curl_error;
+    }
+    
+    long response_code = conn.get_info<CURLINFO_RESPONSE_CODE>().get();
+    json response_data = json::parse(output.str());
+    if (response_code == 200)
+    {
+      result = tweet(response_data);
+      return response::ok;
+    }
+    
+    std::set<int> error_codes;
+    if (response_data.find("errors") != response_data.end())
+    {
+      std::transform(std::begin(response_data["errors"]), std::end(response_data["errors"]), std::inserter(error_codes, std::begin(error_codes)), [] (const json& error) {
+        return error["code"].get<int>();
+      });
+    }
+    
+    if (error_codes.count(32) == 1 || error_codes.count(135) == 1 || error_codes.count(215) == 1)
+    {
+      return response::bad_auth;
+    } else if (error_codes.count(64) == 1)
+    {
+      return response::suspended;
+    } else if (error_codes.count(88) == 1 || error_codes.count(185) == 1)
+    {
+      return response::limited;
+    } else if (error_codes.count(89) == 1)
+    {
+      return response::bad_token;
+    } else if (error_codes.count(130) == 1)
+    {
+      return response::server_overloaded;
+    } else if (error_codes.count(131) == 1)
+    {
+      return response::server_error;
+    } else if (error_codes.count(186) == 1)
+    {
+      return response::bad_length;
+    } else if (error_codes.count(187) == 1)
+    {
+      return response::duplicate_status;
+    } else if (error_codes.count(226) == 1)
+    {
+      return response::suspected_spam;
+    } else if (error_codes.count(261) == 1)
+    {
+      return response::write_restricted;
+    } else if (response_code == 429)
+    {
+      return response::limited;
+    } else if (response_code == 500)
+    {
+      return response::server_error;
+    } else if (response_code == 502)
+    {
+      return response::server_unavailable;
+    } else if (response_code == 503)
+    {
+      return response::server_overloaded;
+    } else if (response_code == 504)
+    {
+      return response::server_timeout;
+    } else {
+      return response::unknown_error;
+    }
+  }
+  
+};
@@ -0,0 +1,29 @@
+#ifndef TWITTER_H_ABFF6A12
+#define TWITTER_H_ABFF6A12
+
+#include "twitter.h"
+
+namespace OAuth {
+  class Consumer;
+  class Token;
+  class Client;
+};
+
+namespace twitter {
+  
+  class client {
+    public:
+      client(const auth& _auth);
+      ~client();
+      
+      response updateStatus(std::string msg, tweet& result);
+      
+    private:
+      OAuth::Consumer* _oauth_consumer;
+      OAuth::Token* _oauth_token;
+      OAuth::Client* _oauth_client;
+  };
+  
+};
+
+#endif /* end of include guard: TWITTER_H_ABFF6A12 */
@@ -0,0 +1,15 @@
+#include "twitter.h"
+
+namespace twitter {
+  
+  tweet::tweet()
+  {
+    _valid = false;
+  }
+  
+  tweet::tweet(const json& data)
+  {
+    _valid = true;
+  }
+  
+};
@@ -0,0 +1,17 @@
+#ifndef TWEET_H_CE980721
+#define TWEET_H_CE980721
+
+namespace twitter {
+  
+  class tweet {
+    public:
+      tweet();
+      tweet(const json& _data);
+      
+    private:
+      bool _valid;
+  };
+  
+};
+
+#endif /* end of include guard: TWEET_H_CE980721 */
@@ -0,0 +1,36 @@
+#ifndef TWITTER_H_AC7A7666
+#define TWITTER_H_AC7A7666
+
+namespace twitter {
+  
+  enum class response {
+    ok,
+    curl_error,
+    bad_auth,
+    limited,
+    server_error,
+    server_unavailable,
+    server_overloaded,
+    server_timeout,
+    suspended,
+    bad_token,
+    duplicate_status,
+    suspected_spam,
+    write_restricted,
+    bad_length,
+    unknown_error
+  };
+  
+  class tweet;
+  
+};
+
+#include <json.hpp>
+
+using nlohmann::json;
+
+#include "auth.h"
+#include "client.h"
+#include "tweet.h"
+
+#endif /* end of include guard: TWITTER_H_AC7A7666 */
+Subproject 0cdfb670d726252bdce4fb2a194e11de38a42e0
+Subproject 507322e6f2f63d028c68b2a666aefe902b77f66
+Subproject 4219b6576c53545d5f6b6f18a28ec93ec796968