superset 0.1.6

data/lib/superset/dataset/update_schema.rb

@@ -0,0 +1,120 @@
+module Superset
+  module Dataset
+    class UpdateSchema < Superset::Request
+
+      attr_reader :source_dataset_id, :target_database_id, :target_schema, :remove_copy_suffix
+
+      def initialize(source_dataset_id: , target_database_id: , target_schema: , remove_copy_suffix: false)
+        @source_dataset_id = source_dataset_id
+        @target_database_id = target_database_id
+        @target_schema = target_schema
+        @remove_copy_suffix = remove_copy_suffix
+      end
+
+      def perform
+        validate_proposed_changes
+
+        response
+
+        msg = if result['schema'] == target_schema
+          "Successfully updated dataset schema to #{target_schema} on Database: #{target_database_id}"
+        else
+          "Error: Failed to update dataset schema to #{target_schema} on Database: #{target_database_id}"
+        end
+
+        logger.info "    #{msg}"
+        msg
+
+      end
+
+      def response
+        @response ||= client.put(route, params_updated)
+      end
+
+      def params_updated
+        @params_updated ||= begin
+          new_params = source_dataset.slice(*acceptable_attributes).with_indifferent_access
+          
+          # primary database and schema changes
+          new_params.merge!("database_id": target_database_id)  # add the target database id
+          new_params['schema'] = target_schema
+          new_params['owners'] = new_params['owners'].map {|o| o['id'] } # expects an array of user ids
+          new_params['table_name'] = new_params['table_name'].gsub(/ \(COPY\)/, '') if remove_copy_suffix
+
+          # remove unwanted fields from metrics and columns arrays
+          new_params['metrics'].each {|m| m.delete('changed_on') }
+          new_params['metrics'].each {|m| m.delete('created_on') }
+          new_params['columns'].each {|m| m.delete('changed_on') }
+          new_params['columns'].each {|m| m.delete('created_on') }
+          new_params['columns'].each {|m| m.delete('type_generic') }
+          new_params
+        end
+      end
+
+      # check if the sql query embedds the schema name, if so it can not be duplicated cleanly
+      def sql_query_includes_hard_coded_schema?
+        source_dataset['sql'].include?("#{source_dataset['schema']}.")
+      end
+
+      private
+
+      def source_dataset
+        # will raise an error if the dataset does not exist
+        @source_dataset ||= begin
+          dataset = Get.new(source_dataset_id)
+          dataset.result
+        end
+      end
+
+      def validate_proposed_changes
+        logger.info "    Validating Dataset ID: #{source_dataset_id} schema update to #{target_schema} on Database: #{target_database_id}"
+        raise "Error: source_dataset_id integer is required"  unless source_dataset_id.present? && source_dataset_id.is_a?(Integer)
+        raise "Error: target_database_id integer is required" unless target_database_id.present? && target_database_id.is_a?(Integer)
+        raise "Error: target_schema string is required"       unless target_schema.present? && target_schema.is_a?(String)
+
+        # confirm the dataset exist? ... no need as the load_source_dataset method will raise an error if the dataset does not exist
+ 
+        # does the target schema exist in the target database?
+        raise "Error: Schema #{target_schema} does not exist in database: #{target_database_id}" unless target_database_available_schemas.include?(target_schema)
+
+        # does the sql query hard code the current schema name?
+        raise "Error: >>WARNING<< The Dataset ID #{source_dataset_id} SQL query is hard coded with the schema value and can not be duplicated cleanly.  " +
+              "Remove all direct embedded schema calls from the Dataset SQL query before continuing." if sql_query_includes_hard_coded_schema?
+      end
+
+      # attrs as per swagger docs for dataset patch
+      def acceptable_attributes
+        %w(
+          always_filter_main_dttm
+          cache_timeout
+          columns
+          database_id
+          default_endpoint
+          description
+          extra
+          fetch_values_predicate
+          filter_select_enabled
+          is_managed_externally
+          is_sqllab_view
+          main_dttm_col
+          metrics
+          normalize_columns
+          offset
+          owners
+          schema
+          sql
+          table_name
+          template_params
+        )
+      end
+
+      def route
+        "dataset/#{source_dataset_id}"
+      end
+
+      def target_database_available_schemas
+        Superset::Database::GetSchemas.call(target_database_id)
+      end
+    end
+  end
+end

data/lib/superset/dataset/warm_up_cache.rb

@@ -0,0 +1,41 @@
+module Superset
+  module Dataset
+    class WarmUpCache < Superset::Request
+
+      attr_reader :dashboard_id, :table_name, :db_name
+      
+      def initialize(dashboard_id:, table_name:, db_name:)
+        @dashboard_id = dashboard_id
+        @table_name = table_name
+        @db_name = db_name
+      end
+
+      def perform
+        response
+      end
+
+      def response
+        logger.info("Hitting #{route} for warming up the cache for the dashboard #{dashboard_id.to_s} and for the dataset #{table_name}")
+        client.put(route, params(dashboard_id, table_name, db_name))
+      end
+
+      def params(dashboard_id, table_name, db_name)
+        {
+          "dashboard_id" => dashboard_id,
+          "table_name" => table_name,
+          "db_name" => db_name
+        }
+      end
+
+      private
+
+      def route
+        "dataset/warm_up_cache"
+      end
+
+      def logger
+        @logger ||= Superset::Logger.new
+      end
+    end
+  end
+end

data/lib/superset/display.rb

@@ -0,0 +1,42 @@
+module Superset
+  module Display
+    def list
+      puts table.to_s
+    end
+
+    def table
+      Terminal::Table.new(
+        title: title,
+        headings: headings,
+        rows: rows
+      )
+    end
+
+    def rows
+      result.map do |d|
+        list_attributes.map { |la| d[la].to_s }
+      end
+    end
+
+    def title
+      self.class.to_s
+    end
+
+    def headings
+      headings = display_headers ? display_headers : list_attributes
+      headings.map(&:to_s).map(&:humanize)
+    end
+
+    def display_headers
+      # optionally override this method to display custom headers
+    end
+
+    def list_attributes
+      raise NotImplementedError.new("You must implement list_attributes.")
+    end
+
+    def result
+      raise NotImplementedError.new("You must implement result.")
+    end
+  end
+end

data/lib/superset/enumerations/object_type.rb

@@ -0,0 +1,11 @@
+class ObjectType < EnumerateIt::Base
+# replicates the Superset Core code base enum for Object Types
+# https://github.com/apache/superset/blob/40e77be813c789c8b01aece739f32ff5753436b4/superset/tags/models.py#L79
+
+  associate_values(
+    query:   1,
+    chart:  2,
+    dashboard: 3,
+    dataset: 4
+  )
+end

data/lib/superset/file_utilities.rb

@@ -0,0 +1,19 @@
+require 'zip'
+
+module Superset
+  module FileUtilities
+    def unzip_file(zip_file, destination)
+      entries = []
+      Zip::File.open(zip_file) do |zip|
+        zip.each do |entry|
+          entry_path = File.join(destination, entry.name)
+          entries << entry_path
+          FileUtils.mkdir_p(File.dirname(entry_path))
+          zip.extract(entry, entry_path)
+        end
+      end
+      puts entries
+      entries # return array of extracted files
+    end
+  end
+end

data/lib/superset/guest_token.rb

@@ -0,0 +1,69 @@
+module Superset
+  class GuestToken
+    include Credential::EmbeddedUser
+
+    attr_accessor :embedded_dashboard_id, :current_user
+
+    def initialize(embedded_dashboard_id: , current_user: nil)
+      @embedded_dashboard_id = embedded_dashboard_id
+      @current_user = current_user
+    end
+
+    def guest_token
+      response_body['token']
+    end
+
+    def params
+      {
+        "resources": [
+          {
+            "id": embedded_dashboard_id.to_s,
+            "type": "dashboard" }
+        ],
+        "rls": [],
+        "user": current_user_params
+      }
+    end
+
+    private
+
+    # optional param to be available in Superset for query templating using jinja
+    # ss expects username .. which could be used to query as current_user.id
+    def current_user_params
+      if current_user
+        { "username": current_user.id.to_s }
+      else
+        { }
+      end
+    end
+
+    def response_body
+      response.env.body
+    end
+
+    def route
+      'api/v1/security/guest_token/'
+    end
+
+    def response
+      @response ||= connection.post(route, params.to_json)
+    end
+
+    def connection
+      @connection ||= Faraday.new(authenticator.superset_host) do |f|
+        f.authorization :Bearer, access_token
+        f.use FaradayMiddleware::ParseJson, content_type: 'application/json'
+        f.request :json
+        f.adapter :net_http
+      end
+    end
+
+    def access_token
+      @access_token ||= authenticator.access_token
+    end
+
+    def authenticator
+      @authenticator ||= Superset::Authenticator.new(credentials)
+    end
+  end
+end

data/lib/superset/logger.rb

@@ -0,0 +1,20 @@
+module Superset
+  class Logger
+    
+    def info(msg)
+      # puts msg   # allow logs to console
+      logger.info msg
+    end
+
+    def error(msg)
+      # puts msg   # allow logs to console
+      logger.error msg
+    end
+
+    def logger
+      @logger ||= begin
+        ::Logger.new("log/superset-client.log")
+      end
+    end
+  end
+end

data/lib/superset/request.rb

@@ -0,0 +1,62 @@
+module Superset
+  class Request
+    include Display
+
+    class InvalidParameterError < StandardError; end
+    class ValidationError < StandardError; end
+
+
+    PAGE_SIZE = 100
+
+    attr_accessor :page_num
+
+    def initialize(page_num: 0)
+      @page_num = page_num
+    end
+
+    def self.call
+      self.new.response
+    end
+
+    def response
+      @response ||= client.get(route)
+    rescue => e
+      logger.error("#{e.message}")
+      raise e
+    end
+
+    def result
+      response['result']
+    end
+
+    def superset_host
+      client.superset_host
+    end
+
+    def query_params
+      [filters, pagination].join
+    end
+
+    private
+
+    def route
+      raise NotImplementedError.new("You must implement route.")
+    end
+
+    def client
+      @client ||= Superset::Client.new
+    end
+
+    def pagination
+      "page:#{page_num},page_size:#{PAGE_SIZE}"
+    end
+
+    def filters
+      ""
+    end
+
+    def logger
+      @logger ||= Superset::Logger.new
+    end
+  end
+end

data/lib/superset/route_info.rb

@@ -0,0 +1,34 @@
+module Superset
+  class RouteInfo < Superset::Request
+    alias result response
+
+    attr_reader :route
+
+    def initialize(route:)
+      @route = route
+    end
+
+    def perform
+      validate_route
+      response
+    end
+
+    def response
+      validate_route
+      @response ||= client.get(route)
+    end
+
+    def filters
+      result['filters']
+    end
+
+    private
+
+    def validate_route
+      unless route.present? && route.is_a?(String)
+        puts "Example Route: 'dashboard/_info' "
+        raise "Error: route string is required" unless route.present? && route.is_a?(String)
+      end
+    end
+  end
+end

data/lib/superset/security/permissions_resources/list.rb

@@ -0,0 +1,22 @@
+module Superset
+  module Security
+    module PermissionsResources
+      class List < Superset::Request
+
+        def initialize(page_num: 0)         
+          super(page_num: page_num)
+        end
+
+        private
+
+        def list_attributes
+          [:id, :permission, :view_menu]
+        end
+
+        def route
+          "security/permissions-resources/?q=(#{pagination})"
+        end
+      end
+    end
+  end
+end

data/lib/superset/security/role/create.rb

@@ -0,0 +1,25 @@
+module Superset
+  module Security
+    module Role
+      class Create < Superset::Request
+        attr_reader :name
+
+        def initialize(name: '')
+          @name = name
+        end
+
+        def response
+          raise InvalidParameterError unless name.present?
+
+          @response ||= client.post(route, { 'name' => name } )
+        end
+
+        private
+
+        def route
+          "security/roles/"
+        end
+      end
+    end
+  end
+end

data/lib/superset/security/role/get.rb

@@ -0,0 +1,32 @@
+module Superset
+  module Security
+    module Role
+      class Get < Superset::Request
+        attr_reader :id
+
+        def initialize(id)
+          @id = id
+        end
+
+        def result
+          [ super ]
+        end
+
+        def id_and_name
+          result.first.slice(:id, :name).values.join(': ')
+        end
+
+        private
+
+        def list_attributes
+          [:id, :name]
+        end
+
+        def route
+          "security/roles/#{id}"
+        end
+      end
+    end
+  end
+end
+

data/lib/superset/security/role/list.rb

@@ -0,0 +1,45 @@
+module Superset
+  module Security
+    module Role
+      class List < Superset::Request
+        attr_reader :name_contains, :name_equals
+
+        def initialize(page_num: 0, name_contains: nil, name_equals: nil)
+          @name_contains= name_contains
+          @name_equals= name_equals
+          super(page_num: page_num)
+        end
+
+        def query_params
+          [filters, pagination].join
+        end
+
+        private
+
+        def route
+          "security/roles/?q=(#{query_params})"
+        end
+
+        def filters
+          raise 'ERROR: only one filter supported currently' if  name_contains.present? && name_equals.present?
+
+          if name_contains.present?
+            "filters:!((col:name,opr:ct,value:'#{name_contains}')),"
+          elsif name_equals.present?
+            "filters:!((col:name,opr:eq,value:'#{name_equals}')),"
+          else
+            ''
+          end
+        end
+
+        def title
+          "#{response[:count]} Roles for Host: #{superset_host}"
+        end
+
+        def list_attributes
+          [:id, :name]
+        end
+      end
+    end
+  end
+end

data/lib/superset/security/role/permission/create.rb

@@ -0,0 +1,35 @@
+module Superset
+  module Security
+    module Role
+      module Permission
+        class Create < Superset::Request
+          attr_reader :role_id, :permission_view_menu_ids
+
+          def initialize(role_id:, permission_view_menu_ids: [])
+            @permission_view_menu_ids = permission_view_menu_ids
+            @role_id = role_id
+          end
+
+          def response
+            raise InvalidParameterError unless valid_params?
+
+            @response ||= client.post(route,
+                                      { "permission_view_menu_ids": permission_view_menu_ids } )
+          end
+
+          private
+
+          def valid_params?
+            role_id.present? &&
+              permission_view_menu_ids.is_a?(Array) &&
+              !permission_view_menu_ids.empty?
+          end
+
+          def route
+            "security/roles/#{role_id}/permissions"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/superset/security/role/permission/get.rb

@@ -0,0 +1,37 @@
+module Superset
+  module Security
+    module Role
+      module Permission
+        class Get < Superset::Request
+          attr_reader :id
+
+          def initialize(id)
+            @id = id
+          end
+
+          def self.call(id)
+            self.new(id)
+          end
+
+          def result
+            response[:result]
+          end
+
+          private
+
+          def list_attributes
+            [:id, :permission_name, :view_menu_name]
+          end
+
+          def route
+            "security/roles/#{id}/permissions/"
+          end
+
+          def title
+            Superset::Security::Role::Get.new(id).id_and_name
+          end
+        end
+      end
+    end
+  end
+end

data/lib/superset/security/user/create.rb

@@ -0,0 +1,49 @@
+module Superset
+  module Security
+    module User
+      class Create < Superset::Request
+        attr_reader :user_params
+
+        def initialize(user_params: {})
+          @user_params = user_params.with_indifferent_access
+        end
+
+        def response
+          validate_user_params
+
+          @response ||= client.post(route, user_params)
+        end
+
+        def validate_user_params
+          raise InvalidParameterError, "Missing user params. Expects #{valid_user_params_keys}" unless symbolized_user_param_keys == valid_user_params_keys
+          raise InvalidParameterError, 'Roles must be an array ' unless user_params[:roles].is_a?(Array)
+          confirm_all_params_present
+        end
+
+        private
+
+        def error_message
+          errors = ''
+        end
+
+        def confirm_all_params_present
+          symbolized_user_param_keys.each do |key|
+            raise InvalidParameterError, "Missing #{key}" unless user_params[key].present?
+          end
+        end
+
+        def symbolized_user_param_keys
+          user_params.keys.map(&:to_sym)
+        end
+
+        def  valid_user_params_keys
+          [ :active, :email, :first_name, :last_name, :password, :roles, :username ]
+        end
+
+        def route
+          "security/users/"
+        end
+      end
+    end
+  end
+end