cartodb-rb-client-rails-322 0.4.3

data/lib/cartodb-rb-client.rb

@@ -0,0 +1,18 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'ostruct'
+require 'oauth'
+require 'typhoeus'
+require 'mime/types'
+require 'active_support/core_ext/hash/slice'
+require 'active_support/time_with_zone'
+require 'rgeo'
+require 'rgeo/geo_json'
+require 'pg'
+require 'json/ext'
+
+require 'cartodb-rb-client/cartodb'
+
+OpenSSL::SSL.send :remove_const, :VERIFY_PEER
+OpenSSL::SSL::VERIFY_PEER = OpenSSL::SSL::VERIFY_NONE

data/lib/cartodb-rb-client/cartodb.rb

@@ -0,0 +1,6 @@
+require 'cartodb-rb-client/cartodb/init'
+require 'cartodb-rb-client/cartodb/libs'
+require 'cartodb-rb-client/cartodb/helpers'
+require 'cartodb-rb-client/cartodb/client'
+require 'cartodb-rb-client/cartodb/types'
+require 'cartodb-rb-client/cartodb/model'

data/lib/cartodb-rb-client/cartodb/client.rb

@@ -0,0 +1,4 @@
+require 'cartodb-rb-client/cartodb/client/error'
+require 'cartodb-rb-client/cartodb/client/authorization'
+require 'cartodb-rb-client/cartodb/client/utils'
+require 'cartodb-rb-client/cartodb/client/connection'

data/lib/cartodb-rb-client/cartodb/client/authorization.rb

@@ -0,0 +1,92 @@
+require 'oauth/request_proxy/typhoeus_request'
+
+module CartoDB
+  module Client
+    module Authorization
+
+      CRLF = "\r\n"
+
+      def signed_request(request_uri, arguments)
+        arguments[:disable_ssl_peer_verification] = true
+
+        if CartoDB::Settings['api_key'].present?
+          arguments[:params][:api_key] = CartoDB::Settings['api_key']
+        end
+
+        request = Typhoeus::Request.new(request_uri, arguments)
+
+        request = as_multipart(request, arguments[:params]) if arguments[:multipart] == true
+
+        unless arguments[:params][:api_key].present?
+          request.headers.merge!({"Authorization" => oauth_helper(request, request_uri).header})
+        end
+
+        request
+      end
+      private :signed_request
+
+      def access_token
+        return @access_token if @access_token
+
+        @access_token ||= if CartoDB::Settings['oauth_access_token'] && CartoDB::Settings['oauth_access_token_secret']
+          OAuth::AccessToken.new(oauth_consumer, CartoDB::Settings['oauth_access_token'], CartoDB::Settings['oauth_access_token_secret'])
+        elsif CartoDB::Settings['username'] && CartoDB::Settings['password']
+
+          x_auth_params = {
+            :x_auth_mode => :client_auth,
+            :x_auth_username => CartoDB::Settings['username'],
+            :x_auth_password => CartoDB::Settings['password']
+          }
+          response = oauth_consumer.request(:post, oauth_consumer.access_token_url,  nil, {}, x_auth_params)
+
+          values = response.body.split('&').inject({}) { |h,v| h[v.split("=")[0]] = v.split("=")[1]; h }
+
+          OAuth::AccessToken.new(oauth_consumer, values["oauth_token"], values["oauth_token_secret"])
+        else
+          nil
+        end
+      end
+      private :access_token
+
+      def oauth_params
+        {:consumer => oauth_consumer, :token => access_token}
+      end
+      private :oauth_params
+
+      def oauth_consumer
+        @oauth_consumer ||= OAuth::Consumer.new(CartoDB::Settings['oauth_key'], CartoDB::Settings['oauth_secret'], :site => CartoDB::Settings['host'])
+      end
+      private :oauth_consumer
+
+      def oauth_helper(request, request_uri)
+        OAuth::Client::Helper.new(request, oauth_params.merge(:request_uri => request_uri))
+      end
+      private :oauth_helper
+
+      def as_multipart(request, params)
+
+        boundary = Time.now.to_i.to_s(16)
+        request.headers["Content-Type"] = "multipart/form-data; boundary=#{boundary}"
+        body = ""
+        params.each do |key,value|
+          esc_key = CGI.escape(key.to_s)
+          body << "--#{boundary}#{CRLF}"
+          if value.respond_to?(:read)
+            body << "Content-Disposition: form-data; name=\"#{esc_key}\"; filename=\"#{File.basename(value.path)}\"#{CRLF}"
+            body << "Content-Type: application/octet-stream#{CRLF*2}"
+            body << value.read.force_encoding('utf-8')
+          else
+            body << "Content-Disposition: form-data; name=\"#{esc_key}\"#{CRLF*2}#{value}"
+          end
+          body << CRLF
+        end
+        body << "--#{boundary}--#{CRLF*2}"
+        request.body = body
+        request.params = {}
+        request
+      end
+      private :as_multipart
+
+    end
+  end
+end

data/lib/cartodb-rb-client/cartodb/client/cache.rb

@@ -0,0 +1,14 @@
+module CartoDB
+  module Client
+    class Cache < Hash
+
+      def get(key)
+        self[key]
+      end
+
+      def set(key, object, timeout = 0)
+        self[key] = object
+      end
+    end
+  end
+end

data/lib/cartodb-rb-client/cartodb/client/connection.rb

@@ -0,0 +1,4 @@
+require 'cartodb-rb-client/cartodb/client/connection/base'
+require 'cartodb-rb-client/cartodb/client/connection/cartodb'
+require 'cartodb-rb-client/cartodb/client/connection/postgres'
+

data/lib/cartodb-rb-client/cartodb/client/connection/base.rb

@@ -0,0 +1,44 @@
+module CartoDB
+  module Client
+    module Connection
+      class Base
+
+        attr_reader :active_connection
+
+        def initialize
+          raise Exception.new 'CartoDB settings not found' if CartoDB::Settings.nil?
+
+          @active_connection = if cartodb_settings?
+            CartoDB::Client::Connection::CartoDBConnection.new(settings)
+          elsif postgresql_settings?
+            CartoDB::Client::Connection::PostgreSQL.new(settings)
+          end
+        end
+
+        def method_missing(method, *args, &block)
+          if @active_connection.respond_to?(method)
+            @active_connection.send(method, *args, &block)
+          else
+            super
+          end
+        end
+
+        def settings
+          CartoDB::Settings || {}
+        end
+        private :settings
+
+        def cartodb_settings?
+          settings.has_key?('api_key') || (settings.has_key?('oauth_key') && settings.has_key?('oauth_secret'))
+        end
+        private :cartodb_settings?
+
+        def postgresql_settings?
+          settings.has_key?('host') && settings.has_key?('user') && settings.has_key?('password') && settings.has_key?('database')
+        end
+        private :postgresql_settings?
+
+      end
+    end
+  end
+end

data/lib/cartodb-rb-client/cartodb/client/connection/cartodb.rb

@@ -0,0 +1,280 @@
+module CartoDB
+  module Client
+    module Connection
+      class CartoDBConnection
+        include OAuth::RequestProxy::Typhoeus
+        include CartoDB::Client::Authorization
+        include CartoDB::Client::Utils
+        include CartoDB::Helpers::SqlHelper
+
+        VERSION = 'v1'.freeze
+
+        def initialize(connection_settings)
+          @hydra = Typhoeus::Hydra.new(:max_concurrency => 200)
+        end
+
+        def create_table(table_name = nil, schema_or_file = nil, the_geom_type = 'Point')
+
+          params = {:name => table_name}
+          params[:the_geom_type] = the_geom_type.downcase if the_geom_type.present?
+
+          case schema_or_file
+
+          when String
+
+            params[:the_geom_type] = schema_or_file.downcase
+
+            request = cartodb_request 'tables', :post, :params => params do |response|
+              return Utils.parse_json(response)
+            end
+
+          when Array
+
+            schema = schema_or_file if schema_or_file && schema_or_file.is_a?(Array)
+            params[:schema] = schema.map{|s| "#{s[:name]} #{s[:type]}"}.join(', ') if schema
+
+            request = cartodb_request 'tables', :post, :params => params do |response|
+              return Utils.parse_json(response)
+            end
+
+          when File
+
+            file = schema_or_file if schema_or_file && schema_or_file.is_a?(File)
+
+            request = cartodb_request nil, :post, :url => '/upload', :params => {:file => file}, :multipart => true do |response|
+              upload_response = Utils.parse_json(response)
+
+              params = {:name => table_name}
+              params[:url]           = generate_url upload_response[:file_uri]
+              params[:the_geom_type] = the_geom_type.downcase if the_geom_type.present?
+
+              request = cartodb_request 'tables', :post, :params => params do |response|
+                return Utils.parse_json(response)
+              end
+
+            end
+
+          else
+
+            request = cartodb_request 'tables', :post, :params => params do |response|
+              return Utils.parse_json(response)
+            end
+
+          end
+
+          execute_queue
+
+          request.handled_response
+
+        end
+
+        def rename_table(old_table_name, new_table_name)
+          request = cartodb_request "tables/#{old_table_name}",
+                                    :put,
+                                    :params => {
+                                      :name => new_table_name
+                                    } do |response|
+            return Utils.parse_json(response)
+          end
+
+          execute_queue
+
+          request.handled_response
+        end
+
+        def add_column(table_name, column_name, column_type)
+          cartodb_request "tables/#{table_name}/columns",
+                          :post,
+                          :params => {
+                            :name => column_name,
+                            :type => column_type
+                          }
+
+          execute_queue
+        end
+
+        def drop_column(table_name, column_name)
+          cartodb_request "tables/#{table_name}/columns/#{column_name}",
+                          :delete
+
+          execute_queue
+        end
+
+        def change_column(table_name, old_column_name, new_column_name, column_type)
+          cartodb_request "tables/#{table_name}/columns/#{old_column_name}",
+                          :put,
+                          :params => {
+                            :new_name => new_column_name,
+                            :type => column_type
+                          }
+
+          execute_queue
+        end
+
+        def tables
+          request = cartodb_request 'tables' do |response|
+            return Utils.parse_json(response)
+          end
+
+          execute_queue
+
+          request.handled_response
+        end
+
+        def table(table_name)
+          request = cartodb_request "tables/#{table_name}" do |response|
+            return Utils.parse_json(response)
+          end
+
+          execute_queue
+
+          request.handled_response
+        end
+
+        def drop_table(table_name)
+          cartodb_request "tables/#{table_name}", :delete
+
+          execute_queue
+        end
+
+        def row(table_name, row_id)
+          cartodb_request "tables/#{table_name}/records/#{row_id}" do |response|
+            return Utils.parse_json(response)
+          end
+
+          execute_queue
+
+          request.handled_response
+        end
+
+        def insert_row(table_name, row)
+          row = prepare_data(row)
+
+          results = query(<<-SQL
+            INSERT INTO #{table_name}
+            (#{row.keys.join(',')})
+            VALUES (#{row.values.join(',')})
+            RETURNING cartodb_id as id, *;
+          SQL
+          )
+
+          results.rows.first
+        end
+
+        def update_row(table_name, row_id, row)
+          row = prepare_data(row)
+
+          results = query(<<-SQL
+            UPDATE #{table_name}
+            SET (#{row.keys.join(',')})
+            = (#{row.values.join(',')})
+            WHERE cartodb_id = #{row_id}
+            RETURNING cartodb_id as id, *;
+          SQL
+          )
+
+          results.rows.first
+
+        end
+
+        def delete_row(table_name, row_id)
+          query(<<-SQL
+            DELETE FROM #{table_name}
+            WHERE cartodb_id = #{row_id}
+          SQL
+          )
+        end
+
+        def records(table_name, options = {})
+          request = cartodb_request "tables/#{table_name}/records", :params => options.slice(:rows_per_page, :page) do |response|
+            return Utils.parse_json(response)
+          end
+
+          execute_queue
+
+          request.handled_response
+        end
+
+        def query(sql, options = {})
+          params = {:q => sql}
+
+          uri = 'sql'
+          uri_params = []
+
+          if options && options.any?
+            uri_params << "page=#{options[:page]}"                   if options[:page]
+            uri_params << "rows_per_page=#{options[:rows_per_page]}" if options[:rows_per_page]
+            uri << "?#{uri_params.join('&')}" if uri_params.any?
+          end
+
+          request = cartodb_request uri, :post, :params => params do |response|
+            Utils.parse_json(response)
+          end
+
+          execute_queue
+
+          request.handled_response
+        end
+
+        def cartodb_request(uri, method = :get, arguments = {:params => {}}, &block)
+          params = arguments[:params]
+          if method.is_a? Hash
+            params = method[:params]
+            method = :get
+          end
+
+          uri = "/api/#{VERSION}/#{uri}"
+          url = generate_url uri
+          url = generate_url(arguments[:url]) if arguments[:url]
+
+          headers                  = {}
+          headers['Accept']        = MIME::Types['application/json']
+          headers.merge!(arguments[:headers]) if arguments[:headers]
+
+          request = signed_request(url,
+            :method        => method,
+            :headers       => headers,
+            :params        => params,
+            :multipart     => arguments[:multipart],
+            :cache_timeout => settings['cache_timeout'],
+            :verbose       => settings['debug']
+          )
+
+          request.on_complete do |response|
+            if response.success?
+              yield(response) if block_given?
+            else
+              raise CartoDB::Client::Error.new url, method, response
+            end
+          end
+
+          enqueue request
+        end
+        private :cartodb_request
+
+        def enqueue(request)
+          @hydra.queue request
+          request
+        end
+        private :enqueue
+
+        def execute_queue
+          @hydra.run
+        end
+        private :execute_queue
+
+        def generate_url(uri)
+          uri = URI.parse("#{settings['host']}#{uri}")
+          "#{uri.scheme}://#{uri.host}:#{uri.port}#{uri.path}"
+        end
+        private :generate_url
+
+        def settings
+          CartoDB::Settings || {}
+        end
+        private :settings
+
+      end
+    end
+  end
+end