dropbox-sdk-sv 0.0.1

data/examples/dropbox_controller.rb

@@ -0,0 +1,113 @@
+# ---------------------------------------------------------------------------------------
+# A Rails 3 controller that:
+# - Runs the through Dropbox's OAuth 2 flow, yielding a Dropbox API access token.
+# - Makes a Dropbox API call to upload a file.
+#
+# To set up:
+# 1. Create a Dropbox App key and secret to use the API. https://www.dropbox.com/developers
+# 2. Add http://localhost:3000/dropbox/auth_finish as a Redirect URI for your Dropbox app.
+# 3. Copy your App key and App secret into APP_KEY and APP_SECRET below.
+#
+# To run:
+# 1. You need a Rails 3 project (to create one, run: rails new <folder-name>)
+# 2. Copy dropbox_sdk.rb into <folder-name>/vendor
+# 3. Copy this file into <folder-name>/app/controllers/
+# 4. Add the following lines to <folder-name>/config/routes.rb
+#        get  "dropbox/main"
+#        post "dropbox/upload"
+#        get  "dropbox/auth_start"
+#        get  "dropbox/auth_finish"
+# 5. Run: rails server
+# 6. Point your browser at: https://localhost:3000/dropbox/main
+
+require 'dropbox_sdk'
+require 'securerandom'
+
+APP_KEY = ""
+APP_SECRET = ""
+
+class DropboxController < ApplicationController
+
+  def main
+    client = get_dropbox_client
+    unless client
+      redirect_to(:action => 'auth_start') and return
+    end
+
+    account_info = client.account_info
+
+    # Show a file upload page
+    render :inline =>
+      "#{account_info['email']} <br/><%= form_tag({:action => :upload}, :multipart => true) do %><%= file_field_tag 'file' %><%= submit_tag 'Upload' %><% end %>"
+  end
+
+  def upload
+    client = get_dropbox_client
+    unless client
+      redirect_to(:action => 'auth_start') and return
+    end
+
+    begin
+      # Upload the POST'd file to Dropbox, keeping the same name
+      resp = client.put_file(params[:file].original_filename, params[:file].read)
+      render :text => "Upload successful.  File now at #{resp['path']}"
+    rescue DropboxAuthError => e
+      session.delete(:access_token)  # An auth error means the access token is probably bad
+      logger.info "Dropbox auth error: #{e}"
+      render :text => "Dropbox auth error"
+    rescue DropboxError => e
+      logger.info "Dropbox API error: #{e}"
+      render :text => "Dropbox API error"
+    end
+  end
+
+  def get_dropbox_client
+    if session[:access_token]
+      begin
+        access_token = session[:access_token]
+        DropboxClient.new(access_token)
+      rescue
+        # Maybe something's wrong with the access token?
+        session.delete(:access_token)
+        raise
+      end
+    end
+  end
+
+  def get_web_auth()
+    redirect_uri = url_for(:action => 'auth_finish')
+    DropboxOAuth2Flow.new(APP_KEY, APP_SECRET, redirect_uri, session, :dropbox_auth_csrf_token)
+  end
+
+  def auth_start
+    authorize_url = get_web_auth().start()
+
+    # Send the user to the Dropbox website so they can authorize our app.  After the user
+    # authorizes our app, Dropbox will redirect them here with a 'code' parameter.
+    redirect_to authorize_url
+  end
+
+  def auth_finish
+    begin
+      access_token, user_id, url_state = get_web_auth.finish(params)
+      session[:access_token] = access_token
+      redirect_to :action => 'main'
+    rescue DropboxOAuth2Flow::BadRequestError => e
+      render :text => "Error in OAuth 2 flow: Bad request: #{e}"
+    rescue DropboxOAuth2Flow::BadStateError => e
+      logger.info("Error in OAuth 2 flow: No CSRF token in session: #{e}")
+      redirect_to(:action => 'auth_start')
+    rescue DropboxOAuth2Flow::CsrfError => e
+      logger.info("Error in OAuth 2 flow: CSRF mismatch: #{e}")
+      render :text => "CSRF error"
+    rescue DropboxOAuth2Flow::NotApprovedError => e
+      render :text => "Not approved?  Why not, bro?"
+    rescue DropboxOAuth2Flow::ProviderError => e
+      logger.info "Error in OAuth 2 flow: Error redirect from Dropbox: #{e}"
+      render :text => "Strange error."
+    rescue DropboxError => e
+      logger.info "Error getting OAuth 2 access token: #{e}"
+      render :text => "Error communicating with Dropbox servers."
+    end
+  end
+end

data/examples/oauth1_upgrade.rb

@@ -0,0 +1,40 @@
+require File.expand_path('../../lib/dropbox_sdk', __FILE__)
+require 'pp'
+
+# You must use your Dropbox App key and secret to use the API.
+# Find this at https://www.dropbox.com/developers
+APP_KEY = ''
+APP_SECRET = ''
+
+def main
+  if APP_KEY == '' or APP_SECRET == ''
+    warn "ERROR: Set your APP_KEY and APP_SECRET at the top of search_cache.rb"
+    exit
+  end
+
+  prog_name = __FILE__
+  args = ARGV
+  if args.size != 2
+    warn "Usage: #{prog_name} <oauth1-access-token-key> <oauth1-access-token-secret>"
+    exit 1
+  end
+
+  access_token_key = args[0]
+  access_token_secret = args[1]
+
+  sess = DropboxSession.new(APP_KEY, APP_SECRET)
+  sess.set_access_token(access_token_key, access_token_secret)
+  c = DropboxClient.new(sess)
+
+  print "Creating OAuth 2 access token...\n"
+  oauth2_access_token = c.create_oauth2_access_token
+
+  print "Using OAuth 2 access token to get account info...\n"
+  c2 = DropboxClient.new(oauth2_access_token)
+  pp c2.account_info
+
+  print "Disabling OAuth 1 access token...\n"
+  c.disable_access_token
+end
+
+main()

data/examples/search_cache.rb

@@ -0,0 +1,322 @@
+# An example use of the /delta API call.  Maintains a local cache of
+# the App Folder's contents.  Use the 'update' sub-command to update
+# the local cache.  Use the 'find' sub-command to search the local
+# cache.
+#
+# Example usage:
+#
+# 1. Link to your Dropbox account
+#    > ruby search_cache.rb link
+#
+# 2. Go to Dropbox and make changes to the contents.
+#
+# 3. Update the local cache to match what's on Dropbox.
+#    > ruby search_cache.rb update
+#
+# 4. Search the local cache.
+#    > ruby search_cache.rb find 'txt'
+
+# Repeat steps 2-4 any number of times.
+
+
+
+require File.expand_path('../../lib/dropbox_sdk', __FILE__)
+require 'json'
+
+# You must use your Dropbox App key and secret to use the API.
+# Find this at https://www.dropbox.com/developers
+APP_KEY = ''
+APP_SECRET = ''
+
+STATE_FILE = 'search_cache.json'
+
+def main()
+  if APP_KEY == '' or APP_SECRET == ''
+    warn "ERROR: Set your APP_KEY and APP_SECRET at the top of search_cache.rb"
+    exit
+  end
+  prog_name = __FILE__
+  args = ARGV
+  if args.size == 0
+    warn("Usage:\n")
+    warn("   #{prog_name} link          Link to a user's account.")
+    warn("   #{prog_name} update        Update cache to the latest on Dropbox.")
+    warn("   #{prog_name} update <num>  Update cache, limit to <num> pages of /delta.")
+    warn("   #{prog_name} find <term>   Search cache for <term>.")
+    warn("   #{prog_name} find          Display entire cache contents")
+    warn("   #{prog_name} reset         Delete the cache.")
+    exit
+  end
+
+  command = args[0]
+  if command == 'link'
+    command_link(args)
+  elsif command == 'update'
+    command_update(args)
+  elsif command == 'find'
+    command_find(args)
+  elsif command == 'reset'
+    command_reset(args)
+  else
+    warn "ERROR: Unknown command: #{command}"
+    warn "Run with no arguments for help."
+    exit(1)
+  end
+end
+
+
+def command_link(args)
+  if args.size != 1
+    warn "ERROR: \"link\" doesn't take any arguments"
+    exit
+  end
+
+  web_auth = DropboxOAuth2FlowNoRedirect.new(APP_KEY, APP_SECRET)
+  authorize_url = web_auth.start()
+  puts "1. Go to: #{authorize_url}"
+  puts "2. Click \"Allow\" (you might have to log in first)."
+  puts "3. Copy the authorization code."
+
+  print "Enter the authorization code here: "
+  STDOUT.flush
+  auth_code = STDIN.gets.strip
+
+  access_token, user_id = web_auth.finish(auth_code)
+  puts "Link successful."
+
+  save_state({
+    'access_token' => access_token,
+    'tree' => {}
+  })
+end
+
+
+def command_update(args)
+  if args.size == 1
+    page_limit = nil
+  elsif args.size == 2
+    page_limit = Integer(args[1])
+  else
+    warn "ERROR: \"update\" takes either zero or one argument."
+    exit
+  end
+
+  # Load state
+  state = load_state()
+  access_token = state['access_token']
+  cursor = state['cursor']
+  tree = state['tree']
+
+  # Connect to Dropbox
+  c = DropboxClient.new(access_token)
+
+  page = 0
+  changed = false
+  while (page_limit == nil) or (page < page_limit)
+    # Get /delta results from Dropbox
+    result = c.delta(cursor)
+    page += 1
+    if result['reset'] == true
+      puts 'reset'
+      changed = true
+      tree = {}
+    end
+    cursor = result['cursor']
+    # Apply the entries one by one to our cached tree.
+    for delta_entry in result['entries']
+      changed = true
+      apply_delta(tree, delta_entry)
+    end
+    cursor = result['cursor']
+    if not result['has_more']
+      break
+    end
+  end
+
+  # Save state
+  if changed
+    state['cursor'] = cursor
+    state['tree'] = tree
+    save_state(state)
+  else
+    puts "No updates."
+  end
+
+end
+
+# We track folder state as a tree of Node objects.
+class Node
+  attr_accessor :path, :content
+  def initialize(path, content)
+    # The "original" page (i.e. not the lower-case path)
+    @path = path
+    # For files, content is a pair (size, modified)
+    # For folders, content is a hash of children Nodes, keyed by lower-case file names.
+    @content = content
+  end
+  def folder?()
+    @content.is_a? Hash
+  end
+  def to_json()
+    [@path, Node.to_json_content(@content)]
+  end
+  def self.from_json(jnode)
+    path, jcontent = jnode
+    Node.new(path, Node.from_json_content(jcontent))
+  end
+  def self.to_json_content(content)
+    if content.is_a? Hash
+      map_hash_values(content) { |child| child.to_json }
+    else
+      content
+    end
+  end
+  def self.from_json_content(jcontent)
+    if jcontent.is_a? Hash
+      map_hash_values(jcontent) { |jchild| Node.from_json jchild }
+    else
+      jcontent
+    end
+  end
+end
+
+# Run a mapping function over every value in a Hash, returning a new Hash.
+def map_hash_values(h)
+  new = {}
+  h.each { |k,v| new[k] = yield v }
+  new
+end
+
+
+def apply_delta(root, e)
+  path, metadata = e
+  branch, leaf = split_path(path)
+
+  if metadata != nil
+    puts "+ #{path}"
+    # Traverse down the tree until we find the parent folder of the entry
+    # we want to add.  Create any missing folders along the way.
+    children = root
+    branch.each do |part|
+      node = get_or_create_child(children, part)
+      # If there's no folder here, make an empty one.
+      if not node.folder?
+        node.content = {}
+      end
+      children = node.content
+    end
+
+    # Create the file/folder.
+    node = get_or_create_child(children, leaf)
+    node.path = metadata['path']  # Save the un-lower-cased path.
+    if metadata['is_dir']
+      # Only create a folder if there isn't one there already.
+      node.content = {} if not node.folder?
+    else
+      node.content = metadata['size'], metadata['modified']
+    end
+  else
+    puts "- #{path}"
+    # Traverse down the tree until we find the parent of the entry we
+    # want to delete.
+    children = root
+    missing_parent = false
+    branch.each do |part|
+      node = children[part]
+      # If one of the parent folders is missing, then we're done.
+      if node == nil or not node.folder?
+        missing_parent = true
+        break
+      end
+      children = node.content
+    end
+    # If we made it all the way, delete the file/folder.
+    if not missing_parent
+      children.delete(leaf)
+    end
+  end
+end
+
+def get_or_create_child(children, name)
+  child = children[name]
+  if child == nil
+    children[name] = child = Node.new(nil, nil)
+  end
+  child
+end
+
+def split_path(path)
+  bad, *parts = path.split '/'
+  [parts, parts.pop]
+end
+
+
+def command_find(args)
+  if args.size == 1
+    term = ''
+  elsif args.size == 2
+    term = args[1]
+  else
+    warn("ERROR: \"find\" takes either zero or one arguments.")
+    exit
+  end
+
+  state = load_state()
+  results = []
+  search_tree(results, state['tree'], term)
+  for r in results
+    puts("#{r}")
+  end
+  puts("[Matches: #{results.size}]")
+end
+
+
+def command_reset(args)
+  if args.size != 1
+    warn("ERROR: \"reset\" takes no arguments.")
+    exit
+  end
+
+  # Delete cursor, empty tree.
+  state = load_state()
+  if state.has_key?('cursor')
+    state.delete('cursor')
+  end
+  state['tree'] = {}
+  save_state(state)
+end
+
+
+# Recursively search 'tree' for files that contain the string in 'term'.
+# Print out any matches.
+def search_tree(results, tree, term)
+  tree.each do |name_lc, node|
+    path = node.path
+    if (path != nil) and path.include?(term)
+      if node.folder?
+        results.push("#{path}")
+      else
+        size, modified = node.content
+        results.push("#{path}  (#{size}, #{modified})")
+      end
+    end
+    if node.folder?
+      search_tree(results, node.content, term)
+    end
+  end
+end
+
+def save_state(state)
+  state['tree'] = Node.to_json_content(state['tree'])
+  File.open(STATE_FILE,"w") do |f|
+    f.write(JSON.pretty_generate(state, :max_nesting => false))
+  end
+end
+
+def load_state()
+  state = JSON.parse(File.read(STATE_FILE), :max_nesting => false)
+  state['tree'] = Node.from_json_content(state['tree'])
+  state
+end
+
+main()

data/examples/web_file_browser.rb

@@ -0,0 +1,193 @@
+# -------------------------------------------------------------------
+# An example webapp that lets you browse and upload files to Dropbox.
+# Demonstrates:
+# - The webapp OAuth process.
+# - The metadata() and put_file() calls.
+#
+# To set up:
+# 1. Create a Dropbox App key and secret to use the API. https://www.dropbox.com/developers
+# 2. Add http://localhost:5000/dropbox-auth-finish as a Redirect URI for your Dropbox app.
+# 3. Copy your App key and App secret into APP_KEY and APP_SECRET below.
+#
+# To run:
+# 1. Install Sinatra  $ gem install sinatra
+# 2. Launch server    $ ruby web_file_browser.rb
+# 3. Browse to        http://localhost:5000/
+# -------------------------------------------------------------------
+
+require 'rubygems'
+require 'sinatra'
+require 'pp'
+require 'securerandom'
+require File.expand_path('../../lib/dropbox_sdk', __FILE__)
+
+# Get your app's key and secret from https://www.dropbox.com/developers/
+APP_KEY = ''
+APP_SECRET = ''
+
+# -------------------------------------------------------------------
+# OAuth stuff
+
+def get_web_auth()
+  return DropboxOAuth2Flow.new(APP_KEY, APP_SECRET, url('/dropbox-auth-finish'),
+                 session, :dropbox_auth_csrf_token)
+end
+
+get '/dropbox-auth-start' do
+  authorize_url = get_web_auth().start()
+
+  # Send the user to the Dropbox website so they can authorize our app.  After the user
+  # authorizes our app, Dropbox will redirect them to our '/dropbox-auth-finish' endpoint.
+  redirect authorize_url
+end
+
+get '/dropbox-auth-finish' do
+  begin
+    access_token, user_id, url_state = get_web_auth.finish(params)
+  rescue DropboxOAuth2Flow::BadRequestError => e
+    return html_page "Error in OAuth 2 flow", "<p>Bad request to /dropbox-auth-finish: #{e}</p>"
+  rescue DropboxOAuth2Flow::BadStateError => e
+    return html_page "Error in OAuth 2 flow", "<p>Auth session expired: #{e}</p>"
+  rescue DropboxOAuth2Flow::CsrfError => e
+    logger.info("/dropbox-auth-finish: CSRF mismatch: #{e}")
+    return html_page "Error in OAuth 2 flow", "<p>CSRF mismatch</p>"
+  rescue DropboxOAuth2Flow::NotApprovedError => e
+    return html_page "Not Approved?", "<p>Why not, bro?</p>"
+  rescue DropboxOAuth2Flow::ProviderError => e
+    return html_page "Error in OAuth 2 flow", "Error redirect from Dropbox: #{e}"
+  rescue DropboxError => e
+    logger.info "Error getting OAuth 2 access token: #{e}"
+    return html_page "Error in OAuth 2 flow", "<p>Error getting access token</p>"
+  end
+
+  # In this simple example, we store the authorized DropboxSession in the session.
+  # A real webapp might store it somewhere more persistent.
+  session[:access_token] = access_token
+  redirect url('/')
+end
+
+get '/dropbox-unlink' do
+  session.delete(:access_token)
+  nil
+end
+
+# If we already have an authorized DropboxSession, returns a DropboxClient.
+def get_dropbox_client
+  if session[:access_token]
+    return DropboxClient.new(session[:access_token])
+  end
+end
+
+# -------------------------------------------------------------------
+# File/folder display stuff
+
+get '/' do
+  # Get the DropboxClient object.  Redirect to OAuth flow if necessary.
+  client = get_dropbox_client
+  unless client
+    redirect url("/dropbox-auth-start")
+  end
+
+  # Call DropboxClient.metadata
+  path = params[:path] || '/'
+  begin
+    entry = client.metadata(path)
+  rescue DropboxAuthError => e
+    session.delete(:access_token)  # An auth error means the access token is probably bad
+    logger.info "Dropbox auth error: #{e}"
+    return html_page "Dropbox auth error"
+  rescue DropboxError => e
+    if e.http_response.code == '404'
+      return html_page "Path not found: #{h path}"
+    else
+      logger.info "Dropbox API error: #{e}"
+      return html_page "Dropbox API error"
+    end
+  end
+
+  if entry['is_dir']
+    render_folder(client, entry)
+  else
+    render_file(client, entry)
+  end
+end
+
+def render_folder(client, entry)
+  # Provide an upload form (so the user can add files to this folder)
+  out = "<form action='/upload' method='post' enctype='multipart/form-data'>"
+  out += "<label for='file'>Upload file:</label> <input name='file' type='file'/>"
+  out += "<input type='submit' value='Upload'/>"
+  out += "<input name='folder' type='hidden' value='#{h entry['path']}'/>"
+  out += "</form>"  # TODO: Add a token to counter CSRF attacks.
+  # List of folder contents
+  entry['contents'].each do |child|
+    cp = child['path']      # child path
+    cn = File.basename(cp)  # child name
+    if (child['is_dir']) then cn += '/' end
+    out += "<div><a style='text-decoration: none' href='/?path=#{h cp}'>#{h cn}</a></div>"
+  end
+
+  html_page "Folder: #{entry['path']}", out
+end
+
+def render_file(client, entry)
+  # Just dump out metadata hash
+  html_page "File: #{entry['path']}", "<pre>#{h entry.pretty_inspect}</pre>"
+end
+
+# -------------------------------------------------------------------
+# File upload handler
+
+post '/upload' do
+  # Check POST parameter.
+  file = params[:file]
+  unless file && (temp_file = file[:tempfile]) && (name = file[:filename])
+    return html_page "Upload error", "<p>No file selected.</p>"
+  end
+
+  # Get the DropboxClient object.
+  client = get_dropbox_client
+  unless client
+    return html_page "Upload error", "<p>Not linked with a Dropbox account.</p>"
+  end
+
+  # Call DropboxClient.put_file
+  begin
+    entry = client.put_file("#{params[:folder]}/#{name}", temp_file.read)
+  rescue DropboxAuthError => e
+    session.delete(:access_token)  # An auth error means the access token is probably bad
+    logger.info "Dropbox auth error: #{e}"
+    return html_page "Dropbox auth error"
+  rescue DropboxError => e
+    logger.info "Dropbox API error: #{e}"
+    return html_page "Dropbox API error"
+  end
+
+  html_page "Upload complete", "<pre>#{h entry.pretty_inspect}</pre>"
+end
+
+# -------------------------------------------------------------------
+
+def html_page(title, body='')
+  "<html>" +
+    "<head><title>#{h title}</title></head>" +
+    "<body><h1>#{h title}</h1>#{body}</body>" +
+  "</html>"
+end
+
+# Rack will issue a warning if no session secret key is set.  A real web app would not have
+# a hard-coded secret in the code but would load it from a config file.
+use Rack::Session::Cookie, :secret => 'dummy_secret'
+
+set :port, 5000
+enable :sessions
+
+helpers do
+  include Rack::Utils
+  alias_method :h, :escape_html
+end
+
+if APP_KEY == '' or APP_SECRET == ''
+  puts "You must set APP_KEY and APP_SECRET at the top of \"#{__FILE__}\"!"
+  exit 1
+end