cartodb-rb-client 0.1.8

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

@@ -0,0 +1,231 @@
+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')
+          schema = schema_or_file if schema_or_file && schema_or_file.is_a?(Array)
+          file   = schema_or_file if schema_or_file && schema_or_file.is_a?(File)
+
+          params = {:name => table_name}
+          params[:file] = file if file
+          params[:schema] = schema.map{|s| "#{s[:name]} #{s[:type]}"}.join(', ') if schema
+
+          request = cartodb_request 'tables', :post, :params => params, :the_geom_type => the_geom_type 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(',')});
+
+            SELECT #{table_name}.cartodb_id as id, #{table_name}.*
+            FROM #{table_name}
+            WHERE cartodb_id = currval('public.#{table_name}_cartodb_id_seq');
+          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};
+            SELECT #{table_name}.cartodb_id as id, #{table_name}.*
+            FROM #{table_name}
+            WHERE cartodb_id = currval('public.#{table_name}_cartodb_id_seq');
+          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|
+            return 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
+
+          headers                  = {}
+          headers['Accept']        = MIME::Types['application/json']
+          headers.merge!(arguments[:headers]) if arguments[:headers]
+
+          request = signed_request(url,
+            :method        => method,
+            :headers       => headers,
+            :params        => params,
+            :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

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

@@ -0,0 +1,255 @@
+module CartoDB
+  module Client
+    module Connection
+      class PostgreSQL
+        include CartoDB::Helpers::SqlHelper
+
+        DATA_TYPES_TRANSLATION_TABLE = {
+          'int4'      => 'number',
+          'numeric'   => 'number',
+          'text'      => 'string',
+          'varchar'   => 'string',
+          'date'      => 'date',
+          'timestamp' => 'date',
+          'bool'      => 'boolean',
+          'geometry'  => 'geometry'
+        }
+
+        def initialize(connection_settings)
+          @pg = connect_to_postgres(connection_settings)
+        end
+
+        def connect_to_postgres(settings)
+          pg_connection = PGconn.open(
+            :host     => settings['host'],
+            :port     => settings['port'],
+            :user     => settings['user'],
+            :password => settings['password'],
+            :dbname   => settings['database']
+          )
+          pg_connection.set_notice_processor{|message| nil}
+          pg_connection
+        end
+        private :connect_to_postgres
+
+        def create_table(table_name = nil, schema_or_file = nil, the_geom_type = 'Point')
+          schema = schema_or_file if schema_or_file && schema_or_file.is_a?(Array)
+          file   = schema_or_file if schema_or_file && schema_or_file.is_a?(File)
+
+          params = {:name => table_name}
+          params[:file] = file if file
+
+          table_name = table_name.sanitize
+
+          if schema.nil? || schema.empty?
+            schema = []
+            schema << {:name => 'name',        :type => 'text'} if schema.select{|c| c[:name].eql?('name')}.empty?
+            schema << {:name => 'description', :type => 'text'} if schema.select{|c| c[:name].eql?('description')}.empty?
+            create_the_geom = "SELECT AddGeometryColumn('public', '#{table_name}', 'the_geom', 4326, 'POINT', 2)"
+          end
+
+          schema << {:name => 'cartodb_id',  :type => 'serial',    :extra => 'NOT NULL'}                                                                 if schema.select{|c| c[:name].eql?('cartodb_id')}.empty?
+          schema << {:name => 'created_at',  :type => 'timestamp', :extra => 'without time zone DEFAULT current_timestamp::timestamp without time zone'} if schema.select{|c| c[:name].eql?('created_at')}.empty?
+          schema << {:name => 'updated_at',  :type => 'timestamp', :extra => 'without time zone DEFAULT current_timestamp::timestamp without time zone'} if schema.select{|c| c[:name].eql?('updated_at')}.empty?
+          if schema.any? && schema.select{|c| c[:name].downcase.match(/geo/)}.any?
+            the_geom_field = schema.select{|c| c[:name].downcase.match(/geo/)}.first
+            create_the_geom = "SELECT AddGeometryColumn('public', '#{table_name}', 'the_geom', 4326, '#{the_geom_field[:geometry_type].upcase}', 2)"
+            schema.reject!{|c| c[:name].downcase.match(/geo/)}
+          end
+
+          @pg.query(<<-SQL
+            CREATE TABLE #{table_name}
+            (
+              #{schema.map{|s| "#{s[:name]} #{s[:type]} #{s[:extra]}"}.join(', ')}
+            )
+            WITH (
+              OIDS=FALSE
+            );
+            ALTER TABLE #{table_name} OWNER TO #{@pg.user};
+          SQL
+          )
+
+          @pg.query(create_the_geom) if create_the_geom
+
+          table table_name
+        end
+
+        def add_column(table_name, column_name, column_type)
+          @pg.query(<<-SQL
+            ALTER TABLE #{table_name} ADD COLUMN #{column_name} #{column_type};
+          SQL
+          )
+        end
+
+        def drop_column(table_name, column_name)
+          @pg.query(<<-SQL
+            ALTER TABLE #{table_name} DROP COLUMN #{column_name};
+          SQL
+          )
+        end
+
+        def change_column(table_name, old_column_name, new_column_name, column_type)
+          add_column table_name, new_column_name, column_type
+          @pg.query(<<-SQL
+            UPDATE #{table_name} SET #{new_column_name}=cast(#{old_column_name} as #{column_type})
+          SQL
+          )
+          drop_column table_name, old_column_name
+        end
+
+        def tables
+          pg_result = @pg.query(<<-SQL
+            SELECT columns.table_name, columns.column_name, columns.udt_name as data_type
+            FROM information_schema.tables tables
+            INNER JOIN information_schema.columns columns ON columns.table_name = tables.table_name
+            WHERE tables.table_schema = 'public' AND tables.table_name not IN ('spatial_ref_sys', 'geometry_columns', 'geography_columns')
+          SQL
+          )
+
+          result = CartoDB::Types::Metadata.new
+          tables = {}
+          pg_result.each do |column|
+            tables[column['table_name']] = CartoDB::Types::Metadata.from_hash({:name => column['table_name'], :schema => []}) unless tables[column['table_name']]
+            tables[column['table_name']].schema << %W(#{column['column_name']} #{CartoDB::Client::Connection::PostgreSQL::DATA_TYPES_TRANSLATION_TABLE[column['data_type']]})
+          end
+
+          result.total_entries = tables.to_a.length
+          result.tables = tables.to_a.map(&:last)
+          result
+        end
+
+        def table(table_name)
+          pg_result = @pg.query(<<-SQL
+            SELECT columns.table_name, columns.column_name, columns.udt_name as data_type, geo_cols.type as geometry_type
+            FROM information_schema.tables tables
+            INNER JOIN information_schema.columns columns ON columns.table_name = tables.table_name
+            LEFT OUTER JOIN public.geometry_columns geo_cols ON geo_cols.f_table_schema = columns.table_schema AND geo_cols.f_table_name = columns.table_name AND geo_cols.f_geometry_column = columns.column_name
+            WHERE tables.table_schema = 'public' AND tables.table_name not IN ('spatial_ref_sys', 'geometry_columns', 'geography_columns') AND tables.table_name ilike '#{table_name}'
+          SQL
+          )
+
+          if pg_result.to_a.empty?
+            non_existing_table = @pg.query(<<-SQL
+              SELECT tables.table_name
+              FROM information_schema.tables tables
+              WHERE tables.table_schema = 'public' AND tables.table_name not IN ('spatial_ref_sys', 'geometry_columns', 'geography_columns') AND tables.table_name ilike '#{table_name}'
+            SQL
+            )
+            raise CartoDB::Client::Error.new if non_existing_table.to_a.empty?
+          end
+
+          table_result = nil
+          pg_result.each do |column|
+            table_result = CartoDB::Types::Metadata.from_hash({:name => column['table_name'], :schema => []}) unless table_result
+            table_result.schema << %W(#{column['column_name']} #{CartoDB::Client::Connection::PostgreSQL::DATA_TYPES_TRANSLATION_TABLE[column['data_type']]})
+            table_result.schema.last << CartoDB::Client::Connection::PostgreSQL::DATA_TYPES_TRANSLATION_TABLE[column['data_type']]  if column['geometry_type']
+            table_result.schema.last << column['geometry_type'].downcase if column['geometry_type']
+          end
+          table_result
+        end
+
+        def drop_table(table_name)
+          @pg.query(<<-SQL
+            DROP TABLE #{table_name}
+          SQL
+          )
+        end
+
+        def row(table_name, row_id)
+          results = query(<<-SQL
+            SELECT #{table_name}.cartodb_id as id, #{table_name}.*
+            FROM #{table_name}
+            WHERE cartodb_id = #{row_id};
+          SQL
+          )
+
+          results.rows.first
+        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(',')});
+
+            SELECT #{table_name}.cartodb_id as id, #{table_name}.*
+            FROM #{table_name}
+            WHERE cartodb_id = currval('public.#{table_name}_cartodb_id_seq');
+          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};
+            SELECT #{table_name}.cartodb_id as id, #{table_name}.*
+            FROM #{table_name}
+            WHERE cartodb_id = currval('public.#{table_name}_cartodb_id_seq');
+          SQL
+          )
+
+          results.rows.first
+        end
+
+        def delete_row(table_name, row_id)
+          @pg.query(<<-SQL
+            DELETE FROM #{table_name}
+            WHERE cartodb_id = #{row_id}
+          SQL
+          )
+        end
+
+        def records(table_name, options = {})
+          sql = <<-SQL
+            SELECT #{table_name}.cartodb_id AS id, #{table_name}.*
+            FROM #{table_name}
+          SQL
+
+          results = query(sql, options)
+
+          results[:name] = table_name
+          results
+        end
+
+        def query(sql, options = {})
+          sql = sql.strip if sql
+
+          if sql.include?('*')
+            table_name = sql.match(/select(.*)\s((\w+\.)?\*)(.*)from\s+(\w*)[^;]*;?/im)[5]
+            schema = table(table_name).schema if table_name
+
+            sql.gsub!(/^select(.*)\s((\w+\.)?\*)(.*)from/im) do |matches|
+              %Q{SELECT #{$1.strip} #{schema.map{|c| "#{$3}#{c[0]}"}.join(', ')} #{$4.strip} FROM}
+            end
+          end
+
+          crono = Time.now
+          begin
+            result = @pg.query(<<-SQL
+              #{sql}
+            SQL
+            )
+          rescue PGError => e
+            raise CartoDB::Client::Error.new(nil, nil, nil, e.message)
+          end
+
+          CartoDB::Types::Metadata.from_hash({
+            :time => Time.now - crono,
+            :total_rows => result.cmd_tuples,
+            :rows       => result.map{|row| CartoDB::Types::Metadata.from_hash(row)}
+          })
+        end
+
+      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/error.rb

@@ -0,0 +1,68 @@
+module CartoDB
+  module Client
+    class Error < Exception
+      attr_accessor :status_code
+
+      HTTP_MESSAGES = {
+                        401 => 'Unauthorized request',
+                        404 => 'Not found',
+                        500 => 'Server error'
+                      }
+
+      def initialize(uri = nil, method = nil, http_response = nil, error_message = nil)
+        @uri            = uri
+        @method         = method
+        @error_messages = ['undefined CartoDB error']
+        @status_code    = 400
+        @error_messages = [uri] if method == nil && http_response == nil && error_message == nil
+        @error_messages = [error_message] if error_message
+
+        if http_response
+          @status_code = http_response.code
+          @error_messages = custom_error(http_response) || standard_error
+          @body = http_response.body
+        end
+
+      end
+
+      def to_s
+        message = <<-EOF
+          #{http_error_message_header}
+          #{format_error_messages}
+          #{@body}
+        EOF
+        message.strip
+      end
+
+      def http_error_message_header
+        if @method && @uri
+          %{There were errors running the #{@method.to_s.upcase} request "#{@uri}":}
+        end
+      end
+      private :http_error_message_header
+
+      def custom_error(http_response)
+        json = Utils.parse_json(http_response)
+        json[:error] if json
+      end
+
+      def standard_error
+        "#{status_code} - #{HTTP_MESSAGES[status_code.to_i]}"
+      end
+      private :standard_error
+
+      def format_error_messages
+        return '' unless @error_messages
+        if @error_messages.is_a?(String)
+          @error_messages
+        elsif @error_messages.is_a?(Array) && @error_messages.count == 1
+          @error_messages.first
+        else
+          @error_messages.map{|e| "- #{e}"}.join("\n")
+        end
+      end
+      private :format_error_messages
+
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module CartoDB
+  module Client
+    module Utils
+
+      def self.parse_json(response)
+        json = nil
+
+        unless response.nil? || response.body.nil? || response.body.strip == ''
+          begin
+            json = ::JSON.parse(response.body, :object_class => CartoDB::Types::Metadata, :symbolize_names => true)
+          rescue JSON::ParserError => e
+            json = CartoDB::Types::Metadata.new
+          end
+        end
+        json
+      end
+
+    end
+  end
+end

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/helpers/sql_helper.rb

@@ -0,0 +1,30 @@
+module CartoDB
+  module Helpers
+    module SqlHelper
+
+      def prepare_data(hash)
+        hash.each do |key, value|
+          hash[key] = format_value(value)
+        end
+        hash
+      end
+
+      def format_value(value)
+        case value
+        when ::String
+          "'#{value}'"
+        when ::Date, ::DateTime, ::Time
+          "'#{value}'"
+        when RGeo::Feature::Geometry
+          "'#{RGeo::WKRep::WKBGenerator.new(:type_format => :ewkb, :emit_ewkb_srid => true, :hex_format => true).generate(value)}'"
+        when NilClass
+          'NULL'
+        else
+          value
+        end
+      end
+      private :format_value
+
+    end
+  end
+end

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

@@ -0,0 +1 @@
+require 'cartodb-rb-client/cartodb/helpers/sql_helper'

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

@@ -0,0 +1,30 @@
+module CartoDB
+ class Init
+
+    class << self
+
+      def start(cartodb_settings = nil)
+        if cartodb_settings.blank?
+          config_path = Rails.root.join('config/cartodb_config.yml')
+          cartodb_settings = YAML.load_file(config_path)[Rails.env.to_s] if File.exists?(config_path)
+        end
+
+        return if cartodb_settings.blank?
+
+        if CartoDB.const_defined?('Settings')
+          CartoDB::Settings.merge!(cartodb_settings)
+        else
+          CartoDB.const_set('Settings', cartodb_settings)
+        end
+
+        CartoDB.const_set('Connection', CartoDB::Client::Connection::Base.new) unless CartoDB.const_defined?('Connection')
+
+
+      end
+
+    end
+
+  end
+end
+
+

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

@@ -0,0 +1,15 @@
+  # coding: UTF-8
+class Object
+  def needsQuotes?
+    return false unless self
+
+    case self
+    when ::String
+      true
+    when ::Date, ::DateTime, ::Time
+      true
+    else
+      false
+    end
+  end
+end