X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=data%2Frbot%2Fplugins%2Ftwitter.rb;h=2ce8142fea50373d6340b63adc10a65c61555a16;hb=052217de30c59206d7025b582d4604557a747470;hp=14b0c2d65f0c01d3e67de1e401bd07a07101d3fa;hpb=d1105edb72568beae81b2d15f61585fe4cb0d48d;p=user%2Fhenk%2Fcode%2Fruby%2Frbot.git

diff --git a/data/rbot/plugins/twitter.rb b/data/rbot/plugins/twitter.rb
index 14b0c2d6..2ce8142f 100644
--- a/data/rbot/plugins/twitter.rb
+++ b/data/rbot/plugins/twitter.rb
@@ -5,6 +5,7 @@
 #
 # Author:: Carter Parks (carterparks) <carter@carterparks.com>
 # Author:: Giuseppe "Oblomov" Bilotta <giuseppe.bilotta@gmail.com>
+# Author:: NeoLobster <neolobster@snugglenets.com>
 #
 # Copyright:: (C) 2007 Carter Parks
 # Copyright:: (C) 2007 Giuseppe Bilotta
@@ -12,20 +13,37 @@
 # Users can setup their twitter username and password and then begin updating
 # twitter whenever
 
+begin
+  require 'oauth'
+rescue LoadError
+  error "OAuth module could not be loaded, twits will not be submitted and protected twits will not be accessible"
+end
+
+require 'yaml'
 require 'rexml/rexml'
-require 'cgi'
 
 class TwitterPlugin < Plugin
-  Config.register Config::IntegerValue.new('twitter.status_count',
-    :default => 1, :validate => Proc.new { |v| v > 0 && v <= 10},
-    :desc => "Maximum number of status updates shown by 'twitter status'")
-  Config.register Config::IntegerValue.new('twitter.friends_status_count',
-    :default => 3, :validate => Proc.new { |v| v > 0 && v <= 10},
-    :desc => "Maximum number of status updates shown by 'twitter friends status'")
+   Config.register Config::StringValue.new('twitter.key',
+      :default => "",
+      :desc => "Twitter OAuth Consumer Key")
+
+   Config.register Config::StringValue.new('twitter.secret',
+      :default => "",
+      :desc => "Twitter OAuth Consumer Secret")
+
+    Config.register Config::IntegerValue.new('twitter.status_count',
+      :default => 1, :validate => Proc.new { |v| v > 0 && v <= 10},
+      :desc => "Maximum number of status updates shown by 'twitter status'")
+
+    Config.register Config::IntegerValue.new('twitter.friends_status_count',
+      :default => 3, :validate => Proc.new { |v| v > 0 && v <= 10},
+      :desc => "Maximum number of status updates shown by 'twitter friends status'")
 
   def initialize
     super
 
+    @has_oauth = defined? OAuth
+
     class << @registry
       def store(val)
         val
@@ -34,38 +52,60 @@ class TwitterPlugin < Plugin
         val
       end
     end
+  end
 
-    @header = {
-      'X-Twitter-Client' => 'rbot twitter plugin'
-    }
+  def report_oauth_missing(m, failed_action)
+    m.reply [failed_action, "I cannot authenticate to Twitter (OAuth not available)"].join(' because ')
+  end
+
+  def report_key_missing(m, failed_action)
+    m.reply [failed_action, "no Twitter Consumer Key/Secret is defined"].join(' because ')
   end
 
-  # return a help string when the bot is asked for help on this plugin
   def help(plugin, topic="")
-    return "twitter status [nick] => show nick's (or your) status, use 'twitter friends status [nick]' to also show the friends' timeline | twitter update [status] => updates your status on twitter | twitter identify [username] [password] => ties your nick to your twitter username and password"
+    return "twitter status [nick] => show nick's (or your) status, use 'twitter friends status [nick]' to also show the friends' timeline | twitter update [status] => updates your status on twitter | twitter authorize => Generates an authorization URL which will give you a PIN to authorize the bot to use your twitter account. | twitter pin [pin] => Finishes bot authorization using the PIN provided by the URL from twitter authorize. | twitter deauthorize => Makes the bot forget your Twitter account. | twitter actions [on|off] => enable/disable twitting of actions (/me does ...)"
   end
 
   # update the status on twitter
   def get_status(m, params)
+    friends = params[:friends]
 
-    nick = params[:nick] || @registry[m.sourcenick + "_username"]
+    if @registry.has_key?(m.sourcenick + "_access_token")
+      @access_token = YAML::load(@registry[m.sourcenick + "_access_token"])
+      nick = params[:nick] || @access_token.params[:screen_name]
+    else
+      if friends
+        if @has_oauth
+          m.reply "You are not authorized with Twitter. Please use 'twitter authorize' first to use this feature."
+        else
+          report_oauth_missing(m, "I cannot retrieve your friends status")
+        end
+        return false
+      end
+      nick = params[:nick]
+    end
 
     if not nick
-      m.reply "you should specify the username of the twitter touse, or identify using 'twitter identify [username] [password]'"
+      m.reply "you should specify the username of the twitter to use, or identify using 'twitter authorize'"
       return false
     end
 
+    count = friends ? @bot.config['twitter.friends_status_count'] : @bot.config['twitter.status_count']
     user = URI.escape(nick)
-
-    count = @bot.config['twitter.status_count']
-    unless params[:friends]
-      uri = "http://twitter.com/statuses/user_timeline/#{user}.xml?count=#{count}"
+    if @has_oauth and @registry.has_key?(m.sourcenick + "_access_token")
+        if friends
+          #no change to count variable
+          uri = "https://api.twitter.com/1/statuses/friends_timeline.xml?count=#{count}"
+          response = @access_token.get(uri).body
+        else
+          uri = "https://api.twitter.com/1/statuses/user_timeline.xml?screen_name=#{user}&count=#{count}"
+          response = @access_token.get(uri).body
+        end
     else
-      count = @bot.config['twitter.friends_status_count']
-      uri = "http://twitter.com/statuses/friends_timeline/#{user}.xml"
+       #unauthorized user, will try to get from public timeline the old way
+       uri = "http://twitter.com/statuses/user_timeline/#{user}.xml?count=#{count}"
+       response = @bot.httputil.get(uri, :cache => false)
     end
-
-    response = @bot.httputil.get(uri, :headers => @header, :cache => false)
     debug response
 
     texts = []
@@ -83,63 +123,135 @@ class TwitterPlugin < Plugin
           delta = ((time > now) ? time - now : now - time)
           msg = st.elements['text'].to_s + " (#{Utils.secs_to_string(delta.to_i)} ago via #{st.elements['source'].to_s})"
           author = ""
-          if params[:friends]
+          if friends
             author = Utils.decode_html_entities(st.elements['user'].elements['name'].text) + ": " rescue ""
           end
           texts << author+Utils.decode_html_entities(msg).ircify_html
         }
-        if params[:friends]
+        if friends
           # friends always return the latest 20 updates, so we clip the count
           texts[count..-1]=nil
         end
       rescue
         error $!
-        m.reply "could not parse status for #{nick}"
+        if friends
+          m.reply "could not parse status for #{nick}'s friends"
+        else
+          m.reply "could not parse status for #{nick}"
+        end
         return false
       end
-      m.reply texts.reverse.join("\n")
+      if texts.empty?
+        m.reply "No status updates!"
+      else
+        m.reply texts.reverse.join("\n")
+      end
       return true
     else
-      m.reply "could not get status for #{nick}"
+      if friends
+        rep = "could not get status for #{nick}'s friends"
+        rep << ", try asking in private" unless m.private?
+      else
+        rep = "could not get status for #{nick}"
+      end
+      m.reply rep
       return false
     end
   end
 
-  # update the status on twitter
-  def update_status(m, params)
+  def deauthorize(m, params)
+    if @registry.has_key?(m.sourcenick + "_request_token")
+      @registry.delete(m.sourcenick + "_request_token")
+    end
+    if @registry.has_key?(m.sourcenick + "_access_token")
+      @registry.delete(m.sourcenick + "_access_token")
+    end
+    m.reply "Done! You can reauthorize this account in the future by using 'twitter authorize'"
+  end
 
+  def authorize(m, params)
+    failed_action = "we can't complete the authorization process"
+    unless @has_oauth
+      report_oauth_missing(m, failed_action)
+      return false
+    end
 
-    unless @registry.has_key?(m.sourcenick + "_password") && @registry.has_key?(m.sourcenick + "_username")
-      m.reply "you must identify using 'twitter identify [username] [password]'"
+    #remove all old authorization data
+    if @registry.has_key?(m.sourcenick + "_request_token")
+      @registry.delete(m.sourcenick + "_request_token")
+    end
+    if @registry.has_key?(m.sourcenick + "_access_token")
+      @registry.delete(m.sourcenick + "_access_token")
+    end
+
+    key = @bot.config['twitter.key']
+    secret = @bot.config['twitter.secret']
+    if key.empty? or secret.empty?
+      report_key_missing(m, failed_action)
       return false
     end
 
-    user = URI.escape(@registry[m.sourcenick + "_username"])
-    pass = URI.escape(@registry[m.sourcenick + "_password"])
-    uri = "http://#{user}:#{pass}@twitter.com/statuses/update.xml"
+    @consumer = OAuth::Consumer.new(key, secret, {
+      :site => "https://api.twitter.com",
+      :request_token_path => "/oauth/request_token",
+      :access_token_path => "/oauth/access_token",
+      :authorize_path => "/oauth/authorize"
+    } )
+    begin
+      @request_token = @consumer.get_request_token
+    rescue OAuth::Unauthorized
+      m.reply _("My authorization failed! Did you block me? Or is my Twitter Consumer Key/Secret pair incorrect?")
+      return false
+    end
+    @registry[m.sourcenick + "_request_token"] = YAML::dump(@request_token)
+    m.reply "Go to this URL to get your authorization PIN, then use 'twitter pin <pin>' to finish authorization: " + @request_token.authorize_url
+  end
 
-    msg = params[:status].to_s
+  def pin(m, params)
+     unless @registry.has_key?(m.sourcenick + "_request_token")
+       m.reply "You must first use twitter authorize to get an authorization URL, which you can use to get a PIN for me to use to verify your Twitter account"
+       return false
+     end
+     @request_token = YAML::load(@registry[m.sourcenick + "_request_token"])
+     begin
+       @access_token = @request_token.get_access_token( { :oauth_verifier => params[:pin] } )
+     rescue
+       m.reply "Error: There was a problem registering your Twitter account. Please make sure you have the right PIN. If the problem persists, use twitter authorize again to get a new PIN"
+       return false
+     end
+     @registry[m.sourcenick + "_access_token"] = YAML::dump(@access_token)
+     m.reply "Okay, you're all set"
+  end
 
-    if msg.length > 160
-      m.reply "your status message update is too long, please keep it under 140 characters if possible, 160 characters maximum"
-      return
+  # update the status on twitter
+  def update_status(m, params)
+    unless @has_oauth
+      report_oauth_missing(m, "I cannot update your status")
+      return false
     end
 
-    if msg.length > 140
-      m.reply "your status message is longer than 140 characters, which is not optimal, but I'm going to update anyway"
+    unless @registry.has_key?(m.sourcenick + "_access_token")
+       m.reply "You must first authorize your Twitter account before tweeting."
+       return false;
     end
+    @access_token = YAML::load(@registry[m.sourcenick + "_access_token"])
 
-    source = "source=rbot"
-    msg = "status=#{CGI.escape(msg)}"
-    body = [source,msg].join("&")
+    uri = "https://api.twitter.com/statuses/update.json"
+    msg = params[:status].to_s
 
-    response = @bot.httputil.post(uri, body, :headers => @header)
+    if msg.length > 140
+      m.reply "your status message update is too long, please keep it under 140 characters"
+      return
+    end
+
+    response = @access_token.post(uri, { :status => msg })
     debug response
 
+    reply_method = params[:notify] ? :notify : :reply
     if response.class == Net::HTTPOK
-      m.reply "status updated"
+      m.__send__(reply_method, "status updated")
     else
-      m.reply "could not update status"
+      m.__send__(reply_method, "could not update status")
     end
   end
 
@@ -147,14 +259,44 @@ class TwitterPlugin < Plugin
   def identify(m, params)
     @registry[m.sourcenick + "_username"] = params[:username].to_s
     @registry[m.sourcenick + "_password"] = params[:password].to_s
-    m.reply "you're all setup!"
+    m.reply "you're all set up!"
+  end
+
+  # update on ACTION if the user has enabled the option
+  # Possible TODO: move the has_oauth check further down and alert
+  # the user the first time we do not update because of the missing oauth
+  def ctcp_listen(m)
+    return unless @has_oauth
+    return unless m.action?
+    return unless @registry[m.sourcenick + "_actions"]
+    update_status(m, :status => m.message, :notify => true)
+  end
+
+  # show or toggle action twitting
+  def actions(m, params)
+    case params[:toggle]
+    when 'on'
+      @registry[m.sourcenick + "_actions"] = true
+      m.okay
+    when 'off'
+      @registry.delete(m.sourcenick + "_actions")
+      m.okay
+    else
+      if @registry[m.sourcenick + "_actions"]
+        m.reply _("actions will be twitted")
+      else
+        m.reply _("actions will not be twitted")
+      end
+    end
   end
 end
 
 # create an instance of our plugin class and register for the "length" command
 plugin = TwitterPlugin.new
-plugin.map 'twitter identify :username :password', :action => "identify", :public => false
 plugin.map 'twitter update *status', :action => "update_status", :threaded => true
+plugin.map 'twitter authorize', :action => "authorize", :public => false
+plugin.map 'twitter deauthorize', :action => "deauthorize", :public => false
+plugin.map 'twitter pin :pin', :action => "pin", :public => false
+plugin.map 'twitter actions [:toggle]', :action => "actions", :requirements => { :toggle => /^on|off$/ }
 plugin.map 'twitter status [:nick]', :action => "get_status", :threaded => true
 plugin.map 'twitter :friends [status] [:nick]', :action => "get_status", :requirements => { :friends => /^friends?$/ }, :threaded => true
-