ubiquitously 0.0.1.6 → 0.1.0

data/lib/ubiquitously/services/digg.rb

@@ -0,0 +1,151 @@
+# digg now uses oauth, so switch when we have oauth through terminal
+module Ubiquitously
+  module Digg
+    class Account < Ubiquitously::Service::Account
+      def login
+        page = agent.get("http://digg.com/login")
+        form = page.form_with(:action => "/login/prepare/digg")
+        form["username"] = username
+        form["password"] = password
+        page = form.submit
+        
+        authorize!(page.title =~ /The Latest News/i)
+      end
+    end
+    
+    class Post < Ubiquitously::Service::Post
+      submit_to "http://digg.com/submit?phase=2&url=:url&title=:title&bodytext=:description&topic=26"
+      
+      def create
+        # url
+        page        = agent.get("http://digg.com/submit/")
+        form        = page.forms.detect {|form| form.form_node["id"] == "thisform"}
+        
+        form["url"] = url
+        form.radiobuttons_with(:name => "type").each do |checkbox|
+          checkbox.check if checkbox.value.to_s == "0"
+        end
+        
+        page = form.submit
+        
+        key = page.parser.css("input#key").first["value"]
+        
+        # http://digg.com/submit/processing?key=171a6601a6690e7105122a4f02242dd6&type=Crawl
+        # redirects you to "http://digg.com/submit/details?key=#{key}"
+        page = agent.get("http://digg.com/submit/dupes?key=#{key}", [], "http://digg.com/submit/processing?key=#{key}type=Crawl")
+        
+        form["title"] = title
+        form["body"] = description # 350 chars max
+        form["topic"] = "26"
+        
+        captcha_image = page.parser.css("img.captcha").first["src"]
+        captcha_id    = page.parser.css("input#captchaid").first["value"]
+        # open browser with captcha image
+        # need to pass cookies
+        image = agent.get("http://digg.com#{captcha_image}")
+        image_path = "digg-image-#{key}.jpg"
+        
+        # instead of writing it, you could do a trick to
+        # post a url with javascript that adds the cookie information, and then
+        # redirects you to the image url:
+        #   path = http://some-site.com/?code="<script>document.cookie = #{agent.cookies}</script>"
+        #   system("open", path)
+        File.open(image_path, "w+") { |f| f.puts image.body }
+        system("open", image_path)
+        
+        # enter captcha response in terminal
+        captcha_says = ask("Enter Captcha from Browser Image:  ") { |q| q.echo = true }
+        File.delete(image_path) if File.exists?(image_path)
+        
+        form["captchaid"] = captcha_id
+        form["captchatext"] = captcha_says
+        form["thumbnail"] = image if image
+        
+        unless debug?
+          form.action = "http://digg.com/submit/details?key=#{key}"
+          page = form.submit
+        end
+        # has captcha, not done with this
+        true
+      end
+      
+      def update
+        key = nil
+        page = agent.get(remote.service_url)
+        page.parser.css("script").each do |script|
+          if script["src"] =~ /http:\/\/digg\.com\/dynjs\/loader/
+            key = agent.get(script["src"]).body.match(/tokens\.digg\.perform\s+=\s+"([^"]+)"/)[1]
+          end
+        end
+        location = page.body.match(/D\.meta\.page\.type\s+=\s+"([^"]+)"/)[1]
+        headers = {
+          "X-Requested-With" => "XMLHttpRequest",
+          "Accept" => "application/json, text/javascript",
+          "Content-Type" => "application/x-www-form-urlencoded; charset=UTF-8",
+          "Pragma" => "no-cache",
+          "Cache-Control" => "no-cache",
+          "Accept-Encoding" => "gzip,deflate",
+          "Referer" => self.remote.service_url
+        }
+        params = {
+          "location" => location,
+          "token" => key,
+          "itemid" => remote.service_id
+        }
+        
+        begin
+          page = agent.post("http://digg.com/ajax/digg/perform", params, headers)
+        rescue Exception => e
+          puts e.page.body
+        end
+        
+        true
+      end
+      
+      class << self
+        def find(options = {})
+          url = options[:url]
+          raise ArgumentError.new("Please give #{service} a url") if url.blank?
+          urls = url_permutations(options[:url])
+          user = options[:user]
+          records = []
+          # search = "http://services.digg.com/1.0/endpoint?method=search.stories&query=#{url}"
+          link = "http://services.digg.com/1.0/endpoint?method=story.getAll&link=#{url}"
+          
+          xml = Nokogiri::XML(user.agent.get(link).body)
+          
+          xml.css("story").each do |node|
+            service_url = node["href"]
+            service_id  = node["id"]
+            url         = node["link"]
+            votes       = node["diggs"].to_i
+            title       = node.css("title").first.text
+            description = node.css("description").first.text
+            categories  = [node.css("container").first["name"]] rescue []
+            categories  << node.css("topic").first["name"] rescue nil
+            categories.flatten!
+            record = new(
+              :title => title,
+              :url => url,
+              :description => description,
+              :categories => categories,
+              :service_url => service_url,
+              :service_id  => service_id,
+              :upvotes => votes,
+              :user => user
+            )
+            records << record if urls.include?(record.url)
+          end
+          
+          records.sort! { |a, b| b.upvotes <=> a.upvotes }
+          
+          if options[:url]
+            records.first
+          else
+            records
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ubiquitously/services/digzign.rb

@@ -0,0 +1,25 @@
+module Ubiquitously
+  module Digzign
+    class Account < Ubiquitously::Service::Account
+      def login
+        return true if logged_in?
+        
+        page = agent.get("http://digzign.com/login")
+        form = page.form_with(:name => "loginform")
+        form["username"] = username
+        form["password"] = password
+        page = form.submit
+      end
+    end
+    
+    class Post < Ubiquitously::Service::Post
+      def save(options = {})
+        return false if !valid?
+        
+        authorize
+        
+        page = agent.get("")
+      end
+    end
+  end
+end

data/lib/ubiquitously/services/diigo.rb

@@ -0,0 +1,68 @@
+module Ubiquitously
+  module Diigo
+    class Account < Ubiquitously::Service::Account
+      
+      def login
+        page = agent.get("https://secure.diigo.com/sign-in")
+        form = page.form_with(:name => "loginForm")
+        form["username"] = username
+        form["password"] = password
+        page = form.submit
+        
+        authorize!(page.title !~ /Sign in/i)
+      end
+      
+    end
+    
+    class Post < Ubiquitously::Service::Post
+      validates_presence_of :url, :title, :description, :tags
+      submit_to "http://www.diigo.com/post?b_mode=0&c_mode=0&url=:url&title=:title&comments=:description&tag=:tags"
+      
+      # tags are space separated. Use " " for tag with multiple words.
+      def tokenize
+        super.merge(:tags => tags.taggify(" ", " "))
+      end
+      
+      def create
+        page = agent.get("https://secure.diigo.com/item/new/bookmark")
+        form = page.forms.detect { |form| form.form_node["id"] == "newBookmarkForm" }
+        form["url"] = token[:url]
+        form["title"] = token[:title]
+        form["description"] = token[:description]
+        # tags are space separated. Use " " for tag with multiple words.
+        form["tags"] = token[:tags]
+        
+        unless debug?
+          page = form.submit
+        end
+      end
+      
+      class << self
+        def find(options = {})
+          records = []
+          user = options[:user]
+          user_url = "http://secure.diigo.com/rss/user/#{user.username_for(self)}"
+          xml = Nokogiri::XML(open(user_url).read)
+          
+          urls = url_permutations(options[:url])
+          
+          xml.css("item").each do |node|
+            title = node.css("title").first.text
+            url   = node.css("link").first.text
+            description = node.css("description").first.text
+            record = new(
+              :title => title,
+              :url => url,
+              :description => description,
+              :user => user
+            )
+            return record if urls.include?(record.url)
+            records << record
+          end
+          
+          options[:url] ? nil : records
+        end
+      end
+    end
+  end
+end

data/lib/ubiquitously/services/dzone.rb

@@ -0,0 +1,132 @@
+module Ubiquitously
+  module Dzone
+    class Account < Ubiquitously::Service::Account
+      def login
+        page = agent.get("http://www.dzone.com/links/loginLightbox.html")
+        form = page.form_with(:action => "/links/j_acegi_security_check")
+        form["j_username"] = username
+        form["j_password"] = password
+        form["_acegi_security_remember_me"] = "on"
+        page = form.submit
+        
+        authorize!(page.body !~ /Invalid username or password/i)
+      end
+    end
+    
+    class Post < Ubiquitously::Service::Post
+      submit_to "http://www.dzone.com/links/add.html?url=:url&title=:url&description=:description"      
+      
+      def create
+        # url
+        page        = agent.get("http://www.dzone.com/links/add.html")
+        form        = page.form_with(:action => "/links/add.html")
+        
+        accepted_tags = []
+        
+        form.checkboxes_with(:name => "tags").each do |tag|
+          accepted_tags << tag.value.to_s
+        end
+        
+        unaccepted_tags = token[:categories].select { |tag| !accepted_tags.include?(tag) }
+        
+        if unaccepted_tags.length > 0
+          raise ArgumentError.new("DZone doesn't accept these tags: #{unaccepted_tags.inspect}, they want these:\n#{accepted_tags.inspect}")
+        end
+        
+        form["title"] = title
+        form["url"] = url
+        form["description"] = description
+        
+        form.checkboxes_with(:name => "tags").each do |checkbox|
+          checkbox.check if token[:categories].include?(checkbox.value)
+        end
+        
+        unless debug?
+          page = form.submit
+        end
+        
+        true
+      end
+      
+      def update
+        page = agent.get(remote.service_url)
+        params = "\ncallCount=1\n"
+        params << "c0-scriptName=LinkManager\n"
+        params << "c0-methodName=incrementVoteCount\n"
+        # var random = Math.floor(Math.random() * 10001);
+        # var id = (random + "_" + new Date().getTime()).toString();
+        # => 9031_1281646074042
+        js_time = (Time.now.utc - Time.utc(1970, 1, 1)).floor * 1000
+        params << "c0-id=#{rand(10001).to_s}_#{js_time.to_s}\n"
+        params << "c0-param0=number:#{remote.service_id}\n"
+        params << "c0-param1=number:1\n"
+        params << "c0-param2=boolean:false\n"
+        params << "xml=true\n"
+        headers = {
+          "Content-Type" => "text/plain; charset=UTF-8",
+          "Referer" => remote.service_url,
+          "Accept" => "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+          "Accept-Encoding" => "gzip,deflate",
+          "X-Requested-With" => "XMLHttpRequest",
+          "Pragma" => "no-cache",
+          "Cache-Control" => "no-cache"
+        }
+        result = agent.post("http://www.dzone.com/links/dwr/exec/LinkManager.incrementVoteCount.dwr", params, headers)
+        
+        # now add comment
+        form = page.form_with(:name => "addlinkform")
+        form["body"] = description
+        
+        form.submit
+        
+        true
+      end
+      
+      class << self
+        
+        def find(options = {})
+          url = options[:url]
+          user = options[:user]
+          urls = url_permutations(url)
+          records = []
+          
+          for page in 1..10
+            search = "http://dzone.com/links/search.html?query=#{URI.parse(url).host}&type=html&p=#{page}"
+            html = user.agent.get(search).parser
+            
+            html.css(".linkblock").each do |node|
+              service_id = node["id"].match(/(\d+)/)[1]
+              link = node.css(".thumb a").first["href"]
+              header = node.css(".details h3 a").first
+              title = header.text
+              upvotes = node.css(".vwidget .upcount").first.text.to_i
+              downvotes = node.css(".vwidget .downcount").first.text.to_i
+              service_url = "http://www.dzone.com#{header["href"]}"
+              record = new(
+                :url => link,
+                :title => title,
+                :upvotes => upvotes,
+                :downvotes => downvotes,
+                :service_url => service_url,
+                :service_id => service_id,
+                :user => user
+              )
+              if urls.include?(record.url)
+                records << record
+                break
+              end
+            end
+            
+            break if records.length > 0
+          end
+          
+          if options[:url]
+            records.first
+          else
+            records
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ubiquitously/services/dzone_snippets.rb

@@ -0,0 +1,39 @@
+module Ubiquitously
+  module DzoneSnippets
+    class Account < Ubiquitously::Service::Account
+      def login
+        page = agent.get("http://snippets.dzone.com/account/login")
+        form = page.form_with(:action => "/account/login")
+        form["username"] = username
+        form["password"] = password
+        form["commit"] = "Log In"
+        page = form.submit
+        
+        authorize!(page.uri != "http://snippets.dzone.com/account/login")
+      end
+    end
+    
+    class Post < Ubiquitously::Service::Post
+      
+      def tokenize
+        super.merge(
+          :description => "<code>#{self.description}</code>",
+          :tags => tags.taggify("-", " ", 40)
+        )
+      end
+      
+      def create
+        page = agent.get("http://snippets.dzone.com/")
+        form = page.form_with(:action => "/posts/create")
+        
+        form["post[title]"] = token[:title]
+        form["post[content]"] = token[:description]
+        form["post[tag_list]"] = token[:tags]
+        form["post[private]"] = 1 if private?
+        page = form.submit
+        
+        true
+      end
+    end
+  end
+end

data/lib/ubiquitously/services/facebook.rb

@@ -0,0 +1,42 @@
+module Ubiquitously
+  module Facebook
+    class Account < Ubiquitously::Service::Account
+      uses :oauth
+      
+      def login
+        had_cookies = cookies?
+        url = "http://localhost:4567/"
+        authorize_url = FacebookToken.authorize(url)
+        page = agent.get(authorize_url, [], url)
+        
+        # only login if we don't have cookies
+        unless had_cookies
+          form = page.forms.detect { |form| form.form_node["id"] == "login_form" }
+          form["email"] = username
+          form["pass"] = password
+          begin
+            page = form.submit
+          rescue Exception => e
+            puts e.inspect
+          end
+        end
+        
+        location = URI.parse(page.response.to_hash["location"].to_a.first)
+        code = Rack::Utils.parse_query(location.query)["code"]
+        
+        # do something with the oauth token, save it in the cookie?
+        self.credentials = FacebookToken.access(:secret => code, :callback_url => url)
+        
+        authorize!(page.uri !~ /http:\/\/login\.facebook\.com\/login\.php/i)
+      end
+    end
+    
+    class Post < Ubiquitously::Service::Post
+      def create
+        access_token.post("https://graph.facebook.com/me/feed", {
+          "message" => token[:description]
+        })
+      end
+    end
+  end
+end