superset 0.1.6

data/lib/superset/dashboard/list.rb

@@ -0,0 +1,99 @@
+# Usage: Superset::Dashboard::List.new.list
+# Usage: Superset::Dashboard::List.new(page_num: 1, title_contains: 'Test').list
+# Usage: Superset::Dashboard::List.new(tags_equal: ['embedded', 'product:acme']).list
+
+module Superset
+  module Dashboard
+    class List < Superset::Request
+      attr_reader :title_contains, :tags_equal, :ids_not_in
+
+      def initialize(page_num: 0, title_contains: '', tags_equal: [], ids_not_in: [])
+        @title_contains = title_contains
+        @tags_equal = tags_equal
+        @ids_not_in = ids_not_in
+        super(page_num: page_num)
+      end
+
+      def self.call
+        self.new.list
+      end
+
+      def response
+        validate_constructor_args
+        super
+      end
+
+      def all
+        result.map do |d|
+          OpenStruct.new(
+            list_attributes.map { |la| [la, d[la]] }.to_h.
+              merge(retrieve_schemas(d[:id])).
+              merge(retrieve_embedded_details(d[:id]))
+            )
+        end
+      end
+
+      def retrieve_schemas(id)
+        { schemas: Datasets::List.new(id).schemas }
+      rescue StandardError => e
+        # within Superset, a bug exists around deleting dashboards failing and the corrupting datasets configs, so handle errored datasets gracefully
+        # ref NEP-17532
+        {}
+      end
+
+      def retrieve_embedded_details(id)
+        embedded_dashboard = Dashboard::Embedded::Get.new(id)
+        { allowed_embedded_domains: embedded_dashboard.allowed_domains,
+          uuid: embedded_dashboard.uuid,}
+      end
+
+      def rows
+        result.map do |d|
+          list_attributes.map do |la|
+            la == :url ? "#{superset_host}#{d[la]}" : d[la]
+          end
+        end
+      end
+
+      def ids
+        result.map { |d| d[:id] }
+      end
+
+      private
+
+      def route
+        "dashboard/?q=(#{query_params})"
+      end
+
+      def filters
+        # TODO filtering across all list classes can be refactored to support multiple options in a more flexible way
+        filter_set = []
+        filter_set << "(col:dashboard_title,opr:ct,value:'#{title_contains}')" if title_contains.present?
+        filter_set << tag_filters if tags_equal.present?
+        filter_set << ids_not_in_filters if ids_not_in.present?
+        unless filter_set.empty?
+          "filters:!(" + filter_set.join(',') + "),"
+        end
+      end
+
+      def tag_filters
+        tags_equal.map {|tag| "(col:tags,opr:dashboard_tags,value:'#{tag}')"}.join(',')
+      end
+
+      def ids_not_in_filters
+        ids_not_in.map {|id| "(col:id,opr:neq,value:'#{id}')"}.join(',')
+      end
+
+      def list_attributes
+        [:id, :dashboard_title, :status, :url]
+      end
+
+      def validate_constructor_args
+        raise InvalidParameterError, "title_contains must be a String type" unless title_contains.is_a?(String)
+        raise InvalidParameterError, "tags_equal must be an Array type" unless tags_equal.is_a?(Array)
+        raise InvalidParameterError, "tags_equal array must contain string only values" unless tags_equal.all? { |item| item.is_a?(String) }
+        raise InvalidParameterError, "ids_not_in must be an Array type" unless ids_not_in.is_a?(Array)
+      end
+    end
+  end
+end

data/lib/superset/dashboard/put.rb

@@ -0,0 +1,37 @@
+
+# frozen_string_literal: true
+
+module Superset
+  module Dashboard
+    class Put < Superset::Request
+
+      attr_reader :target_dashboard_id, :params
+
+      def initialize(target_dashboard_id:, params:)
+        @target_dashboard_id = target_dashboard_id
+        @params = params
+      end
+
+      def perform
+        raise "Error: target_dashboard_id integer is required" unless target_dashboard_id.present? && target_dashboard_id.is_a?(Integer)
+        raise "Error: params hash is required" unless params.present? && params.is_a?(Hash)
+
+        response
+      end
+
+      def response
+        @response ||= client.put(route, params)
+      end
+
+      def id
+        response["result"]["id"]
+      end
+
+      private
+
+      def route
+        "dashboard/#{target_dashboard_id}"
+      end
+    end
+  end
+end

data/lib/superset/dashboard/warm_up_cache.rb

@@ -0,0 +1,42 @@
+module Superset
+  module Dashboard
+    class WarmUpCache < Superset::Request
+
+      attr_reader :dashboard_id
+      
+      def initialize(dashboard_id:)
+        @dashboard_id = dashboard_id
+      end
+
+      def perform
+        validate_dashboard_id
+        response
+      end
+
+      def response
+        dataset_details = fetch_dataset_details(dashboard_id)
+        dataset_details.each do |dataset|
+          begin
+            warm_up_dataset(dataset["datasource_name"], dataset["name"])
+          rescue => e
+            Rollbar.error("Warm up cache failed for the dashboard #{dashboard_id.to_s} and for the dataset #{dataset["datasource_name"]} - #{e}")
+          end 
+        end
+      end
+
+      def warm_up_dataset(dataset_name, db_name)
+        Superset::Dataset::WarmUpCache.new(dashboard_id: dashboard_id, table_name: dataset_name, db_name: db_name).perform
+      end
+
+      private
+      
+      def validate_dashboard_id
+        raise InvalidParameterError, "dashboard_id must be present and must be an integer" unless dashboard_id.present? && dashboard_id.is_a?(Integer)
+      end
+
+      def fetch_dataset_details(dashboard_id)
+        Superset::Dashboard::Datasets::List.new(dashboard_id).datasets_details.map { |dataset| dataset['database'].slice('name').merge(dataset.slice('datasource_name'))}
+      end
+    end
+  end
+end

data/lib/superset/database/get.rb

@@ -0,0 +1,30 @@
+module Superset
+  module Database
+    class Get < Superset::Request
+
+      attr_reader :id
+
+      def initialize(id)
+        @id = id
+      end
+
+      def self.call(id)
+        self.new(id).list
+      end
+
+      def result
+        [ super ]
+      end
+
+      private
+
+      def route
+        "database/#{id}"
+      end
+
+      def list_attributes
+        %w(id database_name backend driver expose_in_sqllab cache_timeout allow_file_upload)
+      end
+    end
+  end
+end

data/lib/superset/database/get_schemas.rb

@@ -0,0 +1,25 @@
+module Superset
+  module Database
+    class GetSchemas < Superset::Request
+
+      alias :schemas :result
+      alias :list :result
+
+      attr_reader :id
+
+      def initialize(id)
+        @id = id
+      end
+
+      def self.call(id)
+        self.new(id).schemas
+      end
+ 
+      private
+
+      def route
+        "database/#{id}/schemas/"
+      end
+    end
+  end
+end

data/lib/superset/database/list.rb

@@ -0,0 +1,51 @@
+# Usage: Superset::Database::List.call
+# Usage: Superset::Dashboard::List.new(title_contains: 'test').list
+
+module Superset
+  module Database
+    class List < Superset::Request
+      attr_reader :title_contains
+
+      def initialize(page_num: 0, title_contains: '')
+        @title_contains = title_contains
+        super(page_num: page_num)
+      end
+
+      def self.call
+        self.new.list
+      end
+
+      def response
+        validate_constructor_args
+        super
+      end
+
+      def ids
+        result.map { |d| d[:id] }
+      end
+
+      private
+
+      def route
+        "database/?q=(#{query_params})"
+      end
+
+      def filters
+        # TODO filtering across all list classes can be refactored to support multiple options in a more flexible way
+        filter_set = []
+        filter_set << "(col:database_name,opr:ct,value:'#{title_contains}')" if title_contains.present?
+        unless filter_set.empty?
+          "filters:!(" + filter_set.join(',') + "),"
+        end
+      end
+
+      def list_attributes
+        [:id, :database_name, :backend, :expose_in_sqllab]
+      end
+
+      def validate_constructor_args
+        raise InvalidParameterError, "title_contains must be a String type" unless title_contains.is_a?(String)
+      end
+    end
+  end
+end

data/lib/superset/dataset/bulk_delete.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+# TODO: the gui delete has a confirmation step, this API call does not.
+# Potentially we could add a confirm_delete parameter to the constructor that would ensure that all datasets either
+#   1 belong to only an expected charts or filters before deleting
+#   2 or do not belong to any charts or filters
+#  ( not sure if this needed at this point )
+
+module Superset
+  module Dataset
+    class BulkDelete < Superset::Request
+      attr_reader :dataset_ids
+
+      def initialize(dataset_ids: [])
+        @dataset_ids = dataset_ids
+      end
+
+      def perform
+        raise InvalidParameterError, "dataset_ids array of integers expected" unless dataset_ids.is_a?(Array)
+        raise InvalidParameterError, "dataset_ids array must contain Integer only values" unless dataset_ids.all? { |item| item.is_a?(Integer) }
+
+        logger.info("Attempting to delete datasets with id: #{dataset_ids.join(', ')}")
+        response
+      end
+
+      def response
+        @response ||= client.delete(route, params)
+      end
+
+      private
+
+      def params
+        { q: "!(#{dataset_ids.join(',')})" }
+      end
+
+      def route
+        "dataset/"
+      end
+    end
+  end
+end

data/lib/superset/dataset/create.rb

@@ -0,0 +1,62 @@
+# The API demands that the new_dataset_name be uniq within the schema it points to.
+# same behaviour as in the GUI
+
+module Superset
+  module Dataset
+    class Create < Superset::Request
+
+      attr_reader :target_database_id, :new_dataset_name, :new_dataset_schema, :sql
+
+      def initialize(target_database_id: , new_dataset_name: , new_dataset_schema: 'public', sql: )
+        @target_database_id = target_database_id
+        @new_dataset_name = new_dataset_name
+        @new_dataset_schema = new_dataset_schema
+        @sql = sql
+      end
+
+      def perform
+        raise "Error: target_database_id integer is required" unless target_database_id.present? && target_database_id.is_a?(Integer)
+        raise "Error: new_dataset_name string is required" unless new_dataset_name.present? && new_dataset_name.is_a?(String)
+        raise "Error: Dataset Name #{new_dataset_name} is already in use in the schema: #{new_dataset_schema}. Suggest you add (COPY) as a suffix to the name" if new_dataset_name_already_in_use?
+        raise "Error: sql string is required" unless sql.present? && sql.is_a?(String)
+
+        logger.info("Creating New Dataset #{new_dataset_name} in DB #{target_database_id} Schema #{new_dataset_schema}")
+
+        response
+        { id: response['id'], dataset_name: response['data']['datasource_name'] }
+      end
+
+      def response
+        @response ||= client.post(route, params)
+      end
+
+      def params
+        {
+          "schema": new_dataset_schema,
+          "sql": sql,
+          "table_name": new_dataset_name,
+          "database": target_database_id
+
+          # Optional Params .. pulled straight from the GUI swagger example
+
+          #"always_filter_main_dttm": false,
+          #"external_url": "string",
+          #"is_managed_externally": false,
+          #"normalize_columns": false,
+          # "owners": [ 0 ],
+        }
+      end
+
+      private
+
+      # The API demands that the new_dataset_name be uniq within the schema it points to.
+      def new_dataset_name_already_in_use?
+        Dataset::List.new(title_equals: new_dataset_name, schema_equals: new_dataset_schema, database_id_eq: target_database_id).result.any?
+      end
+
+      def route
+        "dataset/"
+      end
+    end
+  end
+end

data/lib/superset/dataset/delete.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Superset
+  module Dataset
+    class Delete < Superset::Request
+      attr_reader :dataset_id
+
+      def initialize(dataset_id: )
+        @dataset_id = dataset_id
+      end
+
+      def perform
+        raise InvalidParameterError, "dataset_id integer is required" unless dataset_id.present? && dataset_id.is_a?(Integer)
+
+        logger.info("Attempting to delete dataset with id: #{dataset_id}")
+        response
+      end
+
+      def response
+        @response ||= client.delete(route)
+      end
+
+      private
+
+      def route
+        "dataset/#{dataset_id}"
+      end
+    end
+  end
+end

data/lib/superset/dataset/duplicate.rb

@@ -0,0 +1,62 @@
+# The API demands that the new_dataset_name be uniq within the schema it points to.
+# same behaviour as in the GUI
+
+module Superset
+  module Dataset
+    class Duplicate < Superset::Request
+
+      attr_reader :source_dataset_id, :new_dataset_name
+
+      def initialize(source_dataset_id: , new_dataset_name: )
+        @source_dataset_id = source_dataset_id
+        @new_dataset_name = new_dataset_name
+      end
+
+      def perform
+        raise "Error: source_dataset_id integer is required" unless source_dataset_id.present? && source_dataset_id.is_a?(Integer)
+        raise "Error: new_dataset_name string is required" unless new_dataset_name.present? && new_dataset_name.is_a?(String)
+        raise "Error: new_dataset_name already in use in this schema: #{new_dataset_name}. Suggest you add (COPY) as a suffix to the name" if new_dataset_name_already_in_use?
+
+        logger.info("Duplicating Source Dataset #{source_dataset.title} with id #{source_dataset_id}")
+
+        new_dataset_id
+      end
+
+      def response
+        @response ||= client.post(route, params)
+      end
+
+      def params
+        {
+          "base_model_id" => source_dataset_id,
+          "table_name" => new_dataset_name
+        }
+      end
+
+      private
+
+      def source_dataset
+        @source_dataset ||= Dataset::Get.new(source_dataset_id).perform
+      end
+
+      # The API demands that the new_dataset_name be uniq within the schema it points to.
+      def new_dataset_name_already_in_use?
+        Dataset::List.new(title_equals: new_dataset_name, schema_equals: source_dataset.schema).result.any?
+      end
+
+      def new_dataset_id
+        if response["id"].present?
+          logger.info("    Finished. Duplicate Dataset Name #{new_dataset_name} with id #{response['id']}")
+          response["id"]
+        else
+          logger.error("Error: Unable to duplicate dataset: #{response}")
+          raise "Error: Unable to duplicate dataset: #{response}"
+        end
+      end
+
+      def route
+        "dataset/duplicate"
+      end
+    end
+  end
+end

data/lib/superset/dataset/get.rb

@@ -0,0 +1,56 @@
+module Superset
+  module Dataset
+    class Get < Superset::Request
+
+      attr_reader :id
+
+      def initialize(id)
+        @id = id
+      end
+
+      def self.call(id)
+        self.new(id).list
+      end
+
+      def perform
+        response
+        self
+      end
+
+      def rows
+        [ [title, schema, database_name, database_id] ]
+      end
+
+      def schema
+        result['schema']
+      end
+
+      def title
+        result['name']
+      end
+
+      private
+
+      def route
+        "dataset/#{id}"
+      end
+
+      def display_headers
+        %w[title schema database_name, database_id]
+      end
+  
+
+      def database_name
+        result['database']['database_name']
+      end
+
+      def database_id
+        result['database']['id']
+      end
+
+      def sql
+        ['sql']
+      end
+    end
+  end
+end

data/lib/superset/dataset/list.rb

@@ -0,0 +1,41 @@
+module Superset
+  module Dataset
+    class List < Superset::Request
+      attr_reader :title_contains, :title_equals, :schema_equals, :database_id_eq
+
+      def initialize(page_num: 0, title_contains: '', title_equals: '', schema_equals: '', database_id_eq: '')
+        @title_contains = title_contains
+        @title_equals = title_equals
+        @schema_equals = schema_equals
+        @database_id_eq = database_id_eq
+        super(page_num: page_num)
+      end
+
+      def self.call
+        self.new.list
+      end
+
+      private
+
+      def route
+        "dataset/?q=(#{query_params})"
+      end
+
+      def filters
+        # TODO filtering across all list classes can be refactored to support multiple options in a more flexible way
+        filters = []
+        filters << "(col:table_name,opr:ct,value:'#{title_contains}')" if title_contains.present?
+        filters << "(col:table_name,opr:eq,value:'#{title_equals}')" if title_equals.present?
+        filters << "(col:schema,opr:eq,value:'#{schema_equals}')" if schema_equals.present?
+        filters << "(col:database,opr:rel_o_m,value:#{database_id_eq})" if database_id_eq.present? # rel one to many
+        unless filters.empty?
+          "filters:!(" + filters.join(',') + "),"
+        end
+      end
+
+      def list_attributes
+        ['id', 'table_name', 'schema', 'changed_by_name']
+      end
+    end
+  end
+end

data/lib/superset/dataset/update_query.rb

@@ -0,0 +1,56 @@
+module Superset
+  module Dataset
+    class UpdateQuery < Superset::Request
+
+      attr_reader :new_query, :dataset_id
+
+      def initialize(dataset_id: ,new_query: )
+        @new_query = new_query
+        @dataset_id = dataset_id
+      end
+
+      def perform
+        validate_proposed_changes
+
+        response
+      end
+
+      def response
+        @response ||= client.put(route, params)
+      end
+
+      def params
+        { "sql": new_query }
+      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?
+        new_query.include?("#{source_dataset['schema']}.")
+      end
+
+      def source_dataset
+        # will raise an error if the dataset does not exist
+        @source_dataset ||= begin
+          dataset = Get.new(dataset_id)
+          dataset.result
+        end
+      end
+
+      private
+
+      def validate_proposed_changes
+        logger.info "    Validating Dataset ID: #{dataset_id} query update to '#{new_query}'"
+        raise "Error: dataset_id integer is required"  unless dataset_id.present? && dataset_id.is_a?(Integer)
+        raise "Error: new_query string is required"       unless new_query.present? && new_query.is_a?(String)
+
+        # does the sql query hard code the current schema name?
+        raise "Error: >>WARNING<< The Dataset ID #{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
+
+      def route
+        "dataset/#{dataset_id}"
+      end
+    end
+  end
+end