geoiq 0.0.3

data/lib/geoiq.rb

@@ -0,0 +1,53 @@
+require 'httparty'
+require 'pathname'
+require 'uri'
+require 'json'
+require 'base64'
+
+dir = Pathname(__FILE__).dirname.expand_path
+require dir+"geoiq/auth"
+
+require dir+"geoiq/base_model"
+require dir+"geoiq/errors"
+require dir+"geoiq/search"
+require dir+"geoiq/map"
+require dir+"geoiq/dataset"
+require dir+"geoiq/analysis"
+
+
+class Geoiq
+  attr_reader :request, :auth, :api_methods
+
+  def initialize(url, username, password, options = {})
+   # @api_methods = %w(clients contacts projects tasks people)
+    @api_methods = %w(dataset search map)
+    
+    @auth = Auth.new(url, username, password)
+  #  raise InvalidCredentials unless credentials.valid?
+  end
+
+  def dataset
+    @dataset||= Geoiq::Dataset.new(auth)
+  end
+
+  def search(query, options={}, format='json')
+    Geoiq::Search.new(auth).search(query, options, format)
+  end
+
+  def map(options={})
+    Geoiq::Map.new(auth, options)
+  end
+
+  def analysis(options={})
+    Geoiq::Analysis.new(auth, options)
+  end
+  
+
+  class << self
+    def client(url, username, password, options = {})
+      new(url, username, password, options)
+    end
+end
+
+end
+

data/lib/geoiq/analysis.rb

@@ -0,0 +1,21 @@
+class Geoiq
+  class Analysis < BaseModel
+    
+
+    def initialize(auth, options={})
+      super
+    end
+
+    def create(options={})
+      response = request(:post, "/analysis.json", {:query => options})
+      id =  response.headers["location"].match(/(\d+)\.json/)[1].to_i
+      
+      return  Geoiq::Dataset.new(auth).find(id)
+    end
+
+
+   
+
+  end
+
+end

data/lib/geoiq/auth.rb

@@ -0,0 +1,21 @@
+class Geoiq
+  class Auth
+    attr_accessor :url, :username, :password, :ssl
+
+    def initialize(url, username, password)
+      @url, @username, @password  = url, username, password
+    end
+
+    def valid?
+      !url.nil? && !username.nil? && !password.nil?
+    end
+
+    def basic_auth
+      Base64.encode64("#{username}:#{password}").delete("\r\n")
+    end
+
+    def host
+      @url
+    end
+  end
+end

data/lib/geoiq/base_model.rb

@@ -0,0 +1,59 @@
+class Geoiq
+  class BaseModel
+    attr_reader :auth, :json
+
+    def initialize(auth, options={})
+      @auth = auth
+    end
+
+
+    class << self
+      def api_methods(methods)
+        class_eval <<-END
+        def api_methods
+          #{methods.inspect}
+        end
+        END
+      end
+
+      def crud
+        %w(find create update delete)
+      end
+
+
+    end
+
+    protected
+
+    # parse in json and create a new model
+    def self.parse(response, auth, options=nil)
+      model = self.new(auth, options)
+      json = JSON.parse(response.body)
+      model.json = json  #stuff the json in there for good measure
+      model.attributes.each do |a|
+        model.send("#{a}=", json[a])
+      end
+
+      model
+
+    end
+
+    def request(method,  path, options = {})
+
+      response = HTTParty.send(method, "#{auth.url}#{path}", :query => options[:query], :body => options[:body], :headers => {"Accept" => "application/xml", "Content-Type" => "application/xml; charset=utf-8", "Authorization" => "Basic #{auth.basic_auth}"}.update(options[:headers] || {}), :format => :plain)
+      case response.code
+      when 503
+        p 503 #TODO, raise errors
+      else
+        response
+      end
+    end
+
+
+    def requires_geoiq_id
+      raise NoGeoiqIDFoundError unless self.geoiq_id
+    end
+    
+  end
+end
+

data/lib/geoiq/client.rb

@@ -0,0 +1,18 @@
+module Geoiq
+
+  class Client
+    include HTTParty
+    default_timeout 240
+   
+     def initialize(url, username=nil, password=nil)
+      @username = username
+      @url = url
+      self.class.base_uri(url)
+      @auth = {:username => username, :password => password}
+    end
+
+
+  end
+
+end
+

data/lib/geoiq/dataset.rb

@@ -0,0 +1,123 @@
+class Geoiq
+  class Dataset < BaseModel
+    api_methods crud + %w(features csv_upload)
+
+    attr_accessor :geoiq_id, :title, :description, :tags, :published, :data_type, :feature_count, :link, :json
+
+    def attributes
+      %w{title description tags published data_type feature_count link}
+    end
+
+    def initialize(auth, options = {})
+      self.geoiq_id = options.delete(:geoiq_id) if options.include?(:geoiq_id)
+      self.title = options[:title] || "Untitled"
+      self.description = options[:description] || ""
+      self.tags = options[:tags] || ""
+      super
+    end
+
+    # datasets.find(123)
+    def find(id, options={})
+      options = {:include_geometry=>0}
+      response = request(:get, "/datasets/#{id}.json", {:query => options})
+      dataset = Geoiq::Dataset.parse(response, auth, {:geoiq_id => id})
+      dataset
+    end
+
+    def update(options)
+      requires_geoiq_id
+      self.title ||= options[:title]
+      self.description ||= options[:description]
+      self.tags ||= options[:tags]
+      self.attributes ||= options[:attributes]
+      overlay = {:overlay => options}
+      response = request(:put, "/datasets/#{self.geoiq_id}.json", {:query => overlay})
+      return true if response["status"].to_i == 200 || response["status"].to_i == 201
+    end
+
+    def delete
+      requires_geoiq_id
+      response = request(:delete, "/datasets/#{self.geoiq_id}.json")
+      return true if response["status"].to_i == 204
+    end
+
+
+    def features(options={})
+      requires_geoiq_id
+
+      response = request(:get, "/datasets/#{self.geoiq_id}/features.json", {:query => options})
+      features = JSON.parse(response.body)
+
+
+    end
+
+    def csv_upload(filename,  options={})
+      type = "text/csv"
+
+      content = File.read(filename)
+      response = request(:post, "/datasets.json",
+      {:body => content,
+        :headers =>{ "Content-Type" => "#{type}"},
+      :query => options})
+
+      id =  response.headers["location"].match(/(\d+)\.json/)[1].to_i
+
+      return find(id)
+    end
+
+    def shp_upload(shp_file, dbf_file, shx_file)
+
+      body = shp_upload_body(shp_file, dbf_file, shx_file)
+      response = request(:post, "/datasets.json",
+      {:body => body,
+        :headers =>{ "Content-Type" => "multipart/form-data, boundary=89d6e3836995"}
+      })
+      id =  response.headers["location"].match(/(\d+)\.json/)[1].to_i
+
+      return find(id)
+
+    end
+
+    # Create a new dataset by passing in a url, and optional type
+    # type = csv,kml,rss, wms, tile
+    def url_upload(url, options={})
+      query = {:url => url}.merge(options)
+      response = request(:post, "/datasets.json", {:query => query})
+      id =  response.headers["location"].match(/(\d+)\.json/)[1].to_i
+
+      return find(id)
+    end
+
+    private
+
+    def shp_upload_body(shp_file, dbf_file, shx_file)
+      boundary = "89d6e3836995"
+
+      body = []
+
+      body << "--#{boundary}\r\n"
+      body << "Content-Disposition: form-data; name=\"dataset[shp]\"; filename=\"#{File.basename(shp_file)}\"\r\n"
+      body << "Content-Type: application/octet-stream\r\n"
+      body << "\r\n"
+      body << File.read(shp_file)
+
+      body << "\r\n--#{boundary}\r\n"
+      body << "Content-Disposition: form-data; name=\"dataset[dbf]\"; filename=\"#{File.basename(dbf_file)}\"\r\n"
+      body << "Content-Type: application/octet-stream\r\n"
+      body << "\r\n"
+      body << File.read(dbf_file)
+
+      body << "\r\n--#{boundary}\r\n"
+      body << "Content-Disposition: form-data; name=\"dataset[shx]\"; filename=\"#{File.basename(shx_file)}\"\r\n"
+      body << "Content-Type: application/octet-stream\r\n"
+      body << "\r\n"
+      body << File.read(shx_file)
+
+      body << "\r\n--#{boundary}--\r\n"
+
+      body.join
+    end
+
+  end
+end
+

data/lib/geoiq/errors.rb

@@ -0,0 +1,4 @@
+class Geoiq
+  class InvalidCredentials < StandardError; end
+  class NoGeoiqIDFoundError < StandardError; end
+end

data/lib/geoiq/map.rb

@@ -0,0 +1,63 @@
+class Geoiq
+  class Map < BaseModel
+    api_methods crud + %w(add_layer)
+
+    attr_accessor :geoiq_id, :title, :description, :tags, :basemap, :published, :extent, :layers, :json
+
+    def attributes
+      %w{title description tags basemap extent layers}
+    end
+
+    def initialize(auth, options={})
+      self.geoiq_id = options.delete(:geoiq_id) if options.include?(:geoiq_id)
+      self.title = options[:title] || "Untitled Map"
+      self.tags = (options[:tags] || []).join(",")
+      self.extent = options[:extent] || [-180,-90,180,90]
+      self.basemap = options[:basemap] || "Acetate"
+      self.layers = options[:layers] || []
+      super
+    end
+
+    def find(id, options={})
+      response = request(:get, "/maps/#{id}.json", {:query => options})
+      map = Geoiq::Map.parse(response, auth, {:geoiq_id => id})
+      map
+    end
+
+    def create(options={})
+      self.attributes.each do |a|
+        options.merge!({a => self.send(a)})
+      end
+      
+      response = request(:post, "/maps.json", {:query => options})
+      
+      id =  response.headers["location"].match(/(\d+)\.json/)[1].to_i
+
+      return find(id)
+    end
+
+    def update(options={})
+      requires_geoiq_id
+      response = request(:put, "/maps/#{self.geoiq_id}.json", {:query => options})
+      return true if response["status"].to_i == 200 || response["status"].to_i == 201
+    end
+
+    def delete
+      requires_geoiq_id
+      response = request(:delete, "/maps/#{self.geoiq_id}.json")
+      return true if response["status"].to_i == 204
+    end
+
+    # layers are an array of ids of datasets to add
+    def add_layer(layer)
+      requires_geoiq_id
+      options = {:source => "finder:#{layer}"}
+      response = request(:post, "/maps/#{self.geoiq_id}/layers.json", {:query => options})
+      layer_index = response.headers["location"].match(/(\d+)\.json/)[1].to_i
+      return layer_index if response["status"].to_i == 201
+    end
+
+
+
+  end
+end

data/lib/geoiq/search.rb

@@ -0,0 +1,26 @@
+class Geoiq
+  class Search
+    attr_reader :auth
+    def initialize(auth, options={})
+      @auth = auth
+    end
+
+    #format json/atom/kml
+    def search(query, options={}, format='json')
+      params = {:query => query}.merge(options)
+      response = request(:get, "/search.#{format}", {:query => params })
+      if format == 'json'
+        return results = JSON.parse(response.body)
+      else
+        return response.body
+      end
+    end
+
+    protected
+
+    def request(method,  path, options = {})
+      response = HTTParty.send(method, "#{auth.url}#{path}", :query => options[:query], :body => options[:body], :headers => {"Accept" => "application/xml", "Content-Type" => "application/xml; charset=utf-8", "Authorization" => "Basic #{auth.basic_auth}"}.update(options[:headers] || {}), :format => :plain)
+    end
+
+  end
+end

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification
+name: geoiq
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+  prerelease: 
+platform: ruby
+authors:
+- Tim Waters, John Hinnegan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-30 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: &2151938260 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.7.4
+  type: :runtime
+  prerelease: false
+  version_requirements: *2151938260
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: &2151936400 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.1.9
+  type: :runtime
+  prerelease: false
+  version_requirements: *2151936400
+- !ruby/object:Gem::Dependency
+  name: shoulda
+  requirement: &2151935760 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2151935760
+- !ruby/object:Gem::Dependency
+  name: fakeweb
+  requirement: &2151934960 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2151934960
+- !ruby/object:Gem::Dependency
+  name: geo_ruby
+  requirement: &2151933720 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2151933720
+description: 
+email: tim.waters@geoiq.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/geoiq/analysis.rb
+- lib/geoiq/auth.rb
+- lib/geoiq/base_model.rb
+- lib/geoiq/client.rb
+- lib/geoiq/dataset.rb
+- lib/geoiq/errors.rb
+- lib/geoiq/map.rb
+- lib/geoiq/search.rb
+- lib/geoiq.rb
+homepage: http://github.com/fortiusone/geoiq_gem
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: API Wrapper around Geocommons website and the GeoIQ applications
+test_files: []