Initial commit of bager to git

Author: ajturner

badger.rb

@@ -0,0 +1,210 @@
+#!/usr/bin/env ruby
+
+#--
+# Upload script for Finder!
+# Version 0.1
+# Copyright (c) 2008 Andrew Turner
+# Copyright (c) 2005 Bill Stilwell ([email protected])
+#++
+
+require 'net/http'
+require 'rexml/document'
+require 'uri'
+require 'cgi'
+require 'optparse'
+require 'ostruct'
+require 'yaml'
+require 'multipart'
+
+$finder_path = "http://finder.subie"
+#BATCH_FILE_FORMAT = "kml"
+BATCH_FILE_FORMAT = "shp"
+
+def login( username, password )
+  uri = URI.parse($finder_path)
+  res = Net::HTTP.new(uri.host, uri.port).start do |http|
+    #make the initial get to get the JSESSION cookie
+    post = Net::HTTP::Post.new("/sessions")
+    post.set_form_data( {'login' => username, 'password' => password} )
+    response = http.request(post)
+    case response
+    when Net::HTTPFound
+      puts "Badger got a cookie (logged in)"
+    else
+      puts "No cookies for badger (login failed)"
+    end    
+    # get original cookie contains _f1gc_session=blahblahblah
+    cookie = response.response['set-cookie']  
+  end
+end
+
+def upload( query,cookie = nil )
+  url = URI.parse($finder_path)
+  req = Net::HTTP::Post.new("/overlays.xml")
+  req["Cookie"] = cookie  
+  req.set_multipart_form_data(query)
+  res = Net::HTTP.new(url.host, url.port).start {|http| http.request(req) }
+end
+
+
+def metadata(overlay_id, params, cookie = nil )
+  url = URI.parse($finder_path)
+  req = Net::HTTP::Put.new("/overlays/#{overlay_id}.xml")
+  req["Cookie"] = cookie  
+  req.set_form_data(params)
+  res = Net::HTTP.new(url.host, url.port).start {|http| http.request(req) }
+end
+
+
+if __FILE__ == $0
+
+  # Parse the command line options
+  options = OpenStruct.new
+  opts = OptionParser.new
+  opts.banner = "Usage: badger.rb [options] filename"
+  opts.on("-e [USERNAME]", "--user [USERNAME]", "GeoCommons account username") {|username| options.username = username }
+  opts.on("-p [PASSWORD]", "--password [PASSWORD]", "GeoCommons password") {|password| options.password = password }
+  opts.on("-f FILE", "--file FILE", "--overlay FILE", "File to upload") {|overlay| options.overlay = overlay }
+  opts.on("-t=[TITLE]", "--title=[TITLE]", "Title of the overlay") {|title| options.title = title }
+  opts.on("-d=[DESCRIPTION]", "--description=[DESCRIPTION]", "--desc=[DESCRIPTION]", "Description of the overlay") {|description| options.description = description }
+  opts.on("--tags=[TAGS]", Array, "Tags to be applied (comma separated)") {|tags| options.tags = tags}
+  opts.on("--is-private", "Set visibility to private") {|private| options.private = private}
+  opts.on("-s", "Store the credentials to a configuration file") {|save| options.save = save}
+  opts.on("--meta=[METAFILE]", "Metadata Filename") {|metadata| options.metadata = metadata}
+  opts.on("--batch=[DIRECTORY]", "Batch upload a directory") {|batch| options.batch = batch}
+  opts.on("--finder=[FINDER URL]", "Finder web address") {|finder| options.finder = finder; $finder_path = finder}
+  opts.on("-c", "Provide a terminal interface to get username and password") {|terminal| options.terminal = terminal}
+  
+  opts.on_tail("-h", "--help", "Show this message") do
+    puts opts
+    exit
+  end
+  
+  files = opts.parse(ARGV)
+  if options.batch
+    files = Dir.glob(options.batch.gsub(/\/$/,'') + "/*.xml")
+  elsif files.length == 0
+    raise "You must specify at least one file or a batch upload directory!"
+  end
+
+  # Split the tags
+  if options.tags
+    options.tags.each do |tag|
+      tag.gsub!(/^(.*) (.*)$/, '"\1 \2"')
+    end
+  end
+
+  # if options.terminal
+  #   options.username = ask("Enter your Finder! username: ") {|q| q.echo = false} unless options.username
+  #   options.password = ask("Enter your Finder! password: ") {|q| q.echo = false} unless options.password
+  #   options.finder = ask("Enter the URL to Finder!: ") {|q| q.echo = false} unless options.finder
+  #   options.batch = ask("Batch upload directory?: ") {|q| q.echo = false} unless options.batch
+  # end
+  
+  # Optionally load or save the login credentials to a stored file
+  # TODO: store the password as a hash
+  if test ?r, "#{ENV['HOME']}/.geocommonsrc"
+    config = YAML.load(File.open("#{ENV['HOME']}/.geocommonsrc"))
+    options.username = config['username'] if ! options.username
+    options.password = config['password'] if ! options.password
+  else
+    # puts "No config file, consider running with -s to create one."
+  end
+
+  if options.save
+    conf = {
+      "username" => options.username,
+      "password" => options.password,
+    }
+    File.open("#{ENV['HOME']}/.geocommonsrc", "w") { |f| YAML.dump(conf, f)}
+    puts "Config file saved."
+  end
+
+  ids=[]
+  cookie = options.username.nil? ? nil : login(options.username, options.password)
+  for overlay in files
+    if options.batch
+      options.metadata = overlay
+      overlay = options.metadata.gsub(/\.xml/,'')
+    else
+      overlay = overlay.gsub(/\.shp/, '')
+    end
+    
+    shp = "#{overlay}.shp"
+    shx = "#{overlay}.shx"
+    dbf = "#{overlay}.dbf"
+    xml = "#{overlay}.xml"
+    
+    puts "Overlay: #{overlay}"
+    
+    # Upload the overlay file
+    raise "File #{overlay} doesn't exist or isn't readable." if ! test ?r, shp
+    shpfile = File.open( shp )
+    shxfile = File.open( shx )
+    dbffile = File.open( dbf )
+    #xmlfile = File.open( xml )
+    params = {}
+    params["overlay[shp]"] = shpfile
+    params["overlay[shx]"] = shxfile
+    params["overlay[dbf]"] = dbffile
+   
+    response = upload(params, cookie)
+    
+    shpfile.close
+    shxfile.close
+    dbffile.close
+    
+    case response
+    when Net::HTTPCreated
+      ids << response.header["location"]
+    else
+      puts "error uploading file: #{response.body}."
+      next
+    end
+    puts response.message.inspect
+    overlay_id = response.header["location"].match(/(\d+)\.xml/)[1]
+    
+    # Upload the overlay metadata
+    params = {}    
+    mapping = {"overlay_meta"=>["lineage", "metadata_url", "contact_address", "contact_phone", 
+                      "citation_url", "shared", "description", "contact_name", 
+                      "english_reference_date"], "overlay"=>["name"]}
+    
+    if options.metadata
+      f = File.open(xml)
+      overlay = REXML::Document.new(f)
+      f.close()
+      
+      mapping.each do |set, attributes|
+        attributes.each do |attribute| 
+          value = overlay.elements["//#{set.gsub(/_/,'-')}/#{attribute.gsub(/_/,'-')}"]
+          params["#{set}[#{attribute}]"] = value.text unless value.nil?
+        end
+      end
+
+      tags = REXML::XPath.match(overlay, "//tag/name").collect { |t| t.text }
+      params["overlay[tag_list]"] = tags
+      
+      
+    else
+      params["overlay[name]"] = options.title if options.title
+      params["overlay_meta[description]"] = options.description if options.description
+      params["overlay[tag_list]"] = options.tags.join(" ") if options.tags
+      params["overlay_meta[shared]"] = options.private ? false : true
+    end
+    
+    response = metadata(overlay_id, params, cookie)
+
+    case response
+    when Net::HTTPOK
+      puts "Uploaded! #{ids.last.gsub(/\.xml/,'')}"
+
+    else
+
+      puts "no files uploaded."
+      puts response.body
+    end
+  end
+
+
+end

badger_ui/.DS_Store

@@ -0,0 +1,156 @@
+require 'net/http'
+require 'rexml/document'
+require 'uri'
+require 'cgi'
+require 'optparse'
+require 'ostruct'
+require 'yaml'
+require 'open-uri'
+require 'f1/multipart'
+
+
+class Badger
+  def initialize(finder_path,login,password)
+    @finder_path = finder_path
+    @login = login
+    @password = password
+    @cookie = login(login, password)
+    raise "Login Failure" if @cookie.nil?
+  end
+  
+  def process(stem)
+    overlay_url = upload_shapefile(stem)
+    metadata = metadata_params(stem)
+    upload_metadata(overlay_url, metadata, @cookie)
+    attribute_data = attribute_params(overlay_url, stem, @cookie)
+    update_attributes("#{overlay_url.sub(/\.xml$/,'')}/attributes", attribute_data, @cookie)
+  end
+  
+  private
+  def login( username, password )
+    uri = URI.parse(@finder_path)
+    res = Net::HTTP.new(uri.host, uri.port).start do |http|
+      #make the initial get to get the JSESSION cookie
+      post = Net::HTTP::Post.new("/sessions")
+      post.set_form_data( {'login' => username, 'password' => password} )
+      response = http.request(post)
+      case response
+      when Net::HTTPFound
+        puts "Badger got a cookie (logged in)"
+        return response.response['set-cookie']  
+      else
+        puts "No cookies for badger (login failed)"
+        return nil
+      end    
+      # get original cookie contains _f1gc_session=blahblahblah
+    end
+  end
+
+  def metadata_params(stem)
+    mapping = {"overlay_meta"=>["lineage", "metadata_url", "contact_address", "contact_phone", 
+                      "citation_url", "shared", "description", "contact_name", 
+                      "english_reference_date"], "overlay"=>["name", "tag_cache"]}
+    
+    # read in the metadata
+    xml = "#{stem}.xml"
+    raise IOError, "Metadata XML not found: #{xml}" unless File.exists?(xml)
+    f = File.open(xml)
+    metadata = REXML::Document.new(f)
+    f.close()
+    
+    params = Hash.new
+    mapping.each do |set, attributes|
+      attributes.each do |attribute| 
+        value = metadata.elements["//#{set.gsub(/_/,'-')}/#{attribute.gsub(/_/,'-')}"]
+        params["#{set}[#{attribute}]"] = value.text unless value.nil?
+        if(attribute == "tag_cache")
+          params["#{set}[tag_list]"] = value.text unless value.nil?          
+        end
+      end
+    end
+    return params
+  end
+
+  def attribute_params(resource, stem, cookie=nil)
+    # read in the metadata
+    xml = "#{stem}.xml"
+    raise IOError, "Metadata XML not found: #{xml}" unless File.exists?(xml)
+    f = File.open(xml)
+    metadata = REXML::Document.new(f)
+    f.close()
+    
+    url = URI.parse(resource)
+    req = Net::HTTP::Get.new(url.path)
+    req["Cookie"] = cookie
+    response = Net::HTTP.new(url.host, url.port).start {|http| http.request(req) }
+    
+    current_metadata = REXML::Document.new(response.body)
+    
+    new_attributes = metadata.root.elements["overlay-meta"].elements["data-attributes"]
+    current_attributes = current_metadata.root.elements["overlay-meta"].elements["data-attributes"]
+    
+    # now we actually need to build the request
+    params = {}
+    attributes = []
+    # yes... I know
+    current_attributes.elements.each do |child|
+      a = {"original_name" => child.elements["original-name"].text, "id" => child.elements["id"].text}
+      new_attributes.elements.each do |new_child|
+        if new_child.elements["original-name"].text == child.elements["original-name"].text
+          attributes << a.merge({"name" => new_child.elements["name"].text, "description" => new_child.elements["description"].text})
+          break
+        end
+      end
+    end
+    
+    attributes.each_with_index do |a,i|
+      a.each_pair do |k,v|
+        params["data_attributes[#{i}][#{k}]"] = v
+      end
+    end
+
+    return params
+  end
+
+  def upload_shapefile(stem)
+    # generate the filenames
+    shp = "#{stem}.shp"; shx = "#{stem}.shx"; dbf = "#{stem}.dbf"
+    raise IOError, "File not found: #{shp}" unless File.exists?(shp)
+    total_file_size = File.size(shp) + File.size(dbf) + File.size(shx)
+    raise StandardError, "File is too large to upload: #{shp}" if (total_file_size > 10485760) # 10 MB
+    # open the shapefile components
+    shpfile = File.open(shp); shxfile = File.open(shx); dbffile = File.open(dbf)
+    response = upload({"overlay[shp]" => shpfile, "overlay[dbf]" => dbffile, "overlay[shx]" => shxfile}, @cookie)
+    shpfile.close; shxfile.close; dbffile.close
+    if response.is_a?(Net::HTTPCreated)
+      return response.header["location"]
+    else
+      raise StandardError, "Upload Failure: #{response.body} for #{stem}"
+    end
+  end
+
+  def upload( query,cookie = nil )
+    url = URI.parse(@finder_path)
+    req = Net::HTTP::Post.new("/overlays.xml")
+    req["Cookie"] = cookie  
+    req.set_multipart_form_data(query)
+    res = Net::HTTP.new(url.host, url.port).start {|http| http.request(req) }
+  end
+
+  def upload_metadata(resource, params, cookie=nil)
+    url = URI.parse(resource)
+    req = Net::HTTP::Put.new(url.path)
+    req["Cookie"] = cookie
+    req.set_form_data(params)
+    response = Net::HTTP.new(url.host, url.port).start {|http| http.request(req) }
+    if response.is_a?(Net::HTTPSuccess) || response.is_a?(Net::HTTPRedirection)
+      return response
+    else
+      raise StandardError, "Metadata Fail: #{response.body} for #{resource}"
+    end
+  end
+  
+  def update_attributes(resource, params, cookie=nil)
+    upload_metadata(resource, params, cookie)
+  end  
+end