dropbox-invite 0.0.1

data/README.md

@@ -0,0 +1,106 @@
+# dropbox-invite
+
+[![Code Climate](https://codeclimate.com/github/Jesus/dropbox-invite/badges/gpa.svg)](https://codeclimate.com/github/Jesus/dropbox-invite)
+
+## Introduction
+
+This gem allows you to invite other users to a shared folder in Dropbox. It's
+known that Dropbox API doesn't allow this operation, however it's a requirement
+in some scenarios.
+
+To achieve this functionality and due to the lack of implementation in the
+official API, the library relies on
+[rest-client](https://github.com/rest-client/rest-client) and
+[nokogiri](http://www.nokogiri.org) to perform the action through the web
+interface.
+
+### Scope
+
+This gem is meant to provide a missing functionality, not to build another
+API implementation. Ideally you'd use this library in combination with
+some actual implementation of the Dropbox API.
+
+I recommend [dropbox-api](https://github.com/futuresimple/dropbox-api) just
+because I've included integration for it. If `Dropbox::API` is found
+the existing classes will be extended to allow you invite people to your
+folders. This is shown in the examples below.
+
+### Disclaimer
+
+This gem depends 100% on the parsing of the HTML from Dropbox web pages,
+therefore a change in their layouts might result in a broken library. Please,
+keep this in mind if you're planning to use this in a production environment.
+
+Another drawback of using the web interface is of course the speed.
+
+## How to use
+
+### Using it with `dropbox-api` (recommended)
+
+First, you'll need to set up `dropbox-api` as explained in the [gem's README]
+(https://github.com/futuresimple/dropbox-api):
+
+```ruby
+Dropbox::API::Config.app_key    = YOUR_APP_KEY
+Dropbox::API::Config.app_secret = YOUR_APP_SECRET
+Dropbox::API::Config.mode       = "dropbox" # This is a requirement
+```
+
+At this point you're able to instantiate a `Dropbox::API::Client` object either
+through web-based authorization or rake-based. So far, nothing new.
+
+Additionally you'll need to set up the web login credentials as part of the
+API settings to enable the initialization of a web client when it's required.
+
+```ruby
+Dropbox::API::Config.web_session = Dropbox::WebClient::Session.new(
+  :email => "example@corkeryfisher.info",
+  :password => "yourPassw0rd"
+)
+```
+
+Note that the web authentication won't happen until you actually need it, i.e.
+when the `invite` method is invoked.
+
+Now, assuming that you've got a `Dropbox::API::Dir` object called `some_dir`,
+you'd be able to perform this:
+
+```ruby
+response = some_dir.invite("kirsten.greenholt@corkeryfisher.info")
+# => #<Dropbox::WebClient::ResponseParser ... >
+response.error?
+# => false
+response.response_data
+# => {"success_msg"=>"Created shared folder 'folder x'", "sf_info"=>{"mount_point"=>"/folder x", "user_id"=>372486289, "extra_count"=>0, "sort_rank"=>nil, "encoded_sort_key"=>["NkhCMjROBloBDAEMAA=="], "other_emails"=>[], "other_names"=>[], "modified_pretty"=>"just now", "href"=>"/home/folder%20x", "modified_ts"=>1420051083, "filename"=>"folder x", "target_ns_id"=>791334450, "icon"=>"folder_user"}}
+```
+
+Additionally you can check who's included in the dir through `members`:
+
+```ruby
+some_dir.members
+# => ["example@corkeryfisher.info", "kirsten.greenholt@corkeryfisher.info"]
+```
+
+### Using it on its own (standalone, not recommended)
+```ruby
+session = Dropbox::WebClient::Session.new(
+  :email => "your@account.com",
+  :password => "yourPassw0rd"
+)
+session.invite("/folder path", ["kirsten.greenholt@corkeryfisher.info"])
+# => #<Dropbox::WebClient::ResponseParser ... >
+```
+
+## To do
+
+Would be nice to:
+
+- [ ] Record tests in HTTP instead of HTTPS so they'd be readable. To do so
+      we'll need a proxy.
+- [ ] Implement other functions (share permissions, etc).
+- [ ] Improve error handling.
+- [ ] Add setting to disable lazy authentication.
+
+## Problems?
+
+Please report them in [issues](https://github.com/Jesus/dropbox-invite/issues)

data/Rakefile

@@ -0,0 +1,11 @@
+require 'rspec/core/rake_task'
+require 'bundler/gem_tasks'
+
+# Default directory to look in is `/specs`
+# Run with `rake spec`
+RSpec::Core::RakeTask.new(:spec) do |task|
+  task.rspec_opts = ['--color', '--format documentation', '--require spec_helper']
+end
+
+task :default => :spec
+

data/dropbox-invite.gemspec

@@ -0,0 +1,34 @@
+# coding: utf-8
+$:.push File.expand_path("../lib", __FILE__)
+require "dropbox/web_client/version"
+
+Gem::Specification.new do |s|
+  s.name        = "dropbox-invite"
+  s.version     = Dropbox::WebClient::VERSION
+  s.authors     = ["Jesus Burgos Macia"]
+  s.email       = ["jburmac@gmail.com"]
+  s.homepage    = "https://github.com/Jesus/dropbox-invite"
+  s.summary     = "Invite people to shared folders in Dropbox"
+  s.description = "It's capable of working as an extension for dropbox-api to allow folder invites"
+  s.license     = "GPL-3.0"
+
+  s.rubyforge_project = "dropbox-invite"
+
+  s.add_dependency 'rest-client', "~> 1.6"
+  s.add_dependency 'nokogiri', "~> 1.6"
+
+  s.add_development_dependency 'dropbox-api', "~> 0.4"
+
+  s.add_development_dependency "bundler", "~> 1.6"
+  s.add_development_dependency "rake"
+
+  s.add_development_dependency 'rspec', "~> 3.1"
+  s.add_development_dependency 'vcr', "~> 2.9"
+  s.add_development_dependency 'webmock', "~> 1.17"
+  s.add_development_dependency 'debugger', "~> 1.6"
+
+  s.files         = `git ls-files -z`.split("\x0")
+  s.executables   = s.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  s.test_files    = s.files.grep(%r{^(test|spec|features)/})
+  s.require_paths = ["lib"]
+end

data/lib/dropbox/api/objects/dir.rb

@@ -0,0 +1,38 @@
+class Dropbox::API::Dir
+  
+  # Returns an array of people who have been invited to this shared folder
+  def members
+    @members ||= if is_shared_folder?
+      Dropbox::API::Config.web_session.
+        share_options(self[:path]).
+        response_data[:members].
+        map{|member_info| member_info[:email]}
+    else
+      []
+    end
+  end
+  
+  def is_shared_folder?
+    @is_shared_folder ||= self.icon == "folder_user" # Not very reliable...
+  end
+  
+  def is_shared_folder=(value)
+    @is_shared_folder = value
+  end
+  
+  # Sends an invitation to email
+  def invite(emails, message = "")    
+    emails = [emails] if emails.is_a? String
+    
+    response = Dropbox::API::Config.web_session.invite(self[:path], emails, message, is_shared_folder?)
+    
+    # This is now a shared folder
+    @is_shared_folder = true
+
+    # Clear out cache of members so it'll be fetched again when asked
+    @members = nil
+    
+    response
+  end
+
+end

data/lib/dropbox/api/util/config.rb

@@ -0,0 +1,21 @@
+module Dropbox
+  module API
+
+    module Config
+      class << self
+        def web_session=(session)
+          @web_session = session
+        end
+        
+        def web_session
+          if @web_session.nil?
+            raise Dropbox::API::Error::Config.new("Web session hasn't been configured")
+          else
+            @web_session
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/dropbox/invite.rb

@@ -0,0 +1 @@
+require 'dropbox/web_client'

data/lib/dropbox/web_client.rb

@@ -0,0 +1,12 @@
+require 'dropbox/web_client/response_parser'
+
+require 'dropbox/web_client/paths'
+require 'dropbox/web_client/authentication'
+require 'dropbox/web_client/cookie_manager'
+require 'dropbox/web_client/actions'
+require 'dropbox/web_client/session'
+
+if defined? Dropbox::API
+  require 'dropbox/api/util/config'
+  require 'dropbox/api/objects/dir'
+end

data/lib/dropbox/web_client/actions.rb

@@ -0,0 +1,49 @@
+module Dropbox
+  module WebClient
+    
+    module Actions
+      def invite(path, emails, message = "", is_shared_folder = nil)
+        ensure_authenticated
+        
+        if is_shared_folder.nil?
+          # Determine if the folder exists
+          share_options_response = share_options(path)
+          
+          is_shared_folder = !share_options_response.error?
+        end
+
+        params = {
+          "emails" => emails.join(","),
+          "custom_message" => message,
+          "t" => cookies.login_token,
+          "_subject_uid" => subject_uid
+        }
+        if is_shared_folder
+          url = invite_more_url
+          params["ns_id"] = share_options(path).response_data[:ns_id]
+        else
+          url = invite_url
+          params["path"] = path
+        end
+
+        response = RestClient.post(url, params, {:cookies => cookies.all})
+        response_text = response.body
+
+        return ResponseParser.new(response_text)
+      end
+
+      def share_options(path)
+        ensure_authenticated
+        url = share_options_url(:path => path)
+
+        response = RestClient.post(url, {
+          "t" => cookies.login_token,
+          "_subject_uid" => subject_uid
+        }, {:cookies => cookies.for_share_options})
+
+        return ResponseParser.new(response.body, :share_options)
+      end
+    end
+
+  end
+end

data/lib/dropbox/web_client/authentication.rb

@@ -0,0 +1,71 @@
+module Dropbox
+  module WebClient
+  
+    module Authentication
+
+      def authenticated?
+        @authenticated
+      end
+
+      def authenticate
+        get_login
+        post_login
+
+        @authenticated = true
+      end
+      
+      # TODO: Should keep in consideration the session expiration...
+      def ensure_authenticated
+        authenticate unless authenticated?
+        true
+      end
+
+    private
+
+      # Gets the login URL and keeps the cookies, required to continue the
+      # authentication process
+      def get_login
+        response = RestClient.get(login_url)
+        cookies.take response.cookies
+        response
+      end
+
+      # Posts user credentials and keeps the returned cookies, this'll start a 
+      # user session.
+      def post_login
+        response = RestClient.post(post_login_url, {
+          "t" => cookies.login_token,
+          "login_email" => @email,
+          "login_password" => @password
+        }, {:cookies => cookies.all}) do |response, request, result, &block|
+          if response.code == 200
+            cookies.take response.cookies
+            parsed_response = ResponseParser.new(response.body)
+            @subject_uid = parsed_response.response_data["id"]
+          else
+            response.return!(request, result, &block)
+          end
+        end
+        response
+      end
+
+      # This step might not be required, it's just following the redirect which
+      # we got in the previous authentication step.
+      def get_after_login_url
+        response = RestClient.get(after_login_url, :cookies => current_cookies)
+  
+        # Get _subject_uid (hidden field in response HTML)
+        parsed_response = ResponseParser.new(response.body, :html, :html)
+        @subject_uid = parsed_response.response_data[:subject_uid]
+  
+        return response
+      end
+
+      def subject_uid
+        @subject_uid
+      end
+
+    end
+    
+  end
+end

data/lib/dropbox/web_client/cookie_manager.rb

@@ -0,0 +1,40 @@
+module Dropbox
+  module WebClient
+    
+    # Cookie management, this is what will preserve our session
+    class CookieManager
+      def initialize
+        clear_cookies
+      end
+      
+      def take(cookies)
+        @cookies ||= {}
+        @cookies.merge! cookies
+      end
+
+      # Returns a hash with all collected cookies.
+      def all
+        @cookies
+      end
+
+      # Returns a hash with cookies relevant for the `share_options` action.
+      def for_share_options
+        valid_keys = ["bjar", "blid", "forumjar", "forumlid", "gvc", "jar",
+                      "l", "lid", "locale", "puc", "t"]
+        all.select do |k, v|
+          valid_keys.include? k
+        end
+      end
+
+      def clear_cookies
+        @cookies = {}
+      end
+
+      def login_token
+        @cookies["t"]
+      end
+
+    end
+ 
+  end
+end

data/lib/dropbox/web_client/paths.rb

@@ -0,0 +1,35 @@
+module Dropbox
+  module WebClient
+    
+    module Paths
+      @@endpoint = "https://www.dropbox.com"      
+      @@paths = {
+        :login          => "/login",
+        :post_login     => "/ajax_login",
+        :invite         => "/share_ajax/existing",
+        :invite_more    => "/share_ajax/invite_more",
+        :share_options  => "/share_options/:path"
+      }
+
+      private
+
+      def url_from_path(path, *arguments)
+        _path = path.dup
+        options = arguments.last.is_a?(Hash) ? arguments.pop : {}
+        options.each { |key, value| _path.gsub!(":#{key}", value) }
+        _path.gsub! "//", "/"
+
+        URI.encode(File.join(@@endpoint, _path))
+      end
+
+      def method_missing(method_sym, *arguments, &block)
+        if (method_sym.to_s =~ /^(.*)_url$/) == 0 and @@paths.keys.include?(path = $1.to_sym)
+          return url_from_path(@@paths[path], *arguments)
+        else
+          super
+        end
+      end
+    end
+    
+  end
+end

data/lib/dropbox/web_client/response_parser.rb

@@ -0,0 +1,88 @@
+module Dropbox
+  module WebClient
+    
+    class ResponseParser
+      attr_reader :response_text
+
+      def initialize(response_text, response_type = :json, error_type = :json)
+        @response_text = response_text
+        
+        @error_type = error_type
+        @response_type = response_type
+      end
+      
+      def error?
+        @response_text.start_with? "err:"
+      end
+      
+      def error_data
+        JSON.parse(@response_text.split(":", 2)[1]) if error?
+      end
+            
+      def error_data
+        return unless error?
+        
+        error_text = @response_text.split(":", 2)[1]
+        
+        self.class.send("parse_#{@error_type.to_s}", error_text)
+      end
+      
+      def response_data
+        if error?
+          Exception.new(error_data)
+        else
+          begin
+            self.class.send("parse_#{@response_type.to_s}", @response_text)
+          rescue NoMethodError
+            raise Exception.new("Unsupported response format")
+          end
+        end
+      end
+      
+    private
+      
+      def self.parse_json(text)
+        JSON.parse(text)
+      end
+      
+      def self.parse_text(text)
+        text
+      end
+      
+      def self.parse_html(text)
+        doc = Nokogiri::HTML(text)
+        result = {}
+
+        members = doc.css("#sf-members .bs-row")
+        if members.size > 0
+          result[:members] = members.map do |member|
+            {
+              :email => member.css("a[href^=mailto]").text,
+              :name => (member.css(".sf-tooltip-name").children[0].text.strip rescue nil),
+              :access => (member.css(".sf-can-edit-text").text rescue nil),
+              :joined => member.css("> .sf-name > em").text == "(pending)" ? "Still waiting" : "Joined"
+            }
+          end
+        end
+        
+        # Parse ns_id
+        result[:ns_id] = doc.css("[data-ns-id]").first.attr("data-ns-id") rescue nil
+
+        result
+      end
+      
+      #
+      # Following parsers are for specific Dropbox actions
+      # 
+      
+      # Parses a `share_options` response
+      def self.parse_share_options(text)
+        json = parse_json(text)
+        format, html, el = json["actions"].first
+        parse_html(html)
+      end
+      
+    end
+    
+  end
+end