superset 0.1.6

data/lib/superset/dashboard/bulk_delete_cascade.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+# WARNING: DESTRUCTIVE OPERATION .. use with caution
+# This class is used to delete multiple dashboards and all related charts and datasets.
+# There are NO CHECKS currently to confirm if a dataset is used on other dashboards.
+
+module Superset
+  module Dashboard
+    class BulkDeleteCascade
+      class InvalidParameterError < StandardError; end
+
+      attr_reader :dashboard_ids
+
+      def initialize(dashboard_ids: [])
+        @dashboard_ids = dashboard_ids
+      end
+
+      def perform
+        raise InvalidParameterError, "dashboard_ids array of integers expected" unless dashboard_ids.is_a?(Array)
+        raise InvalidParameterError, "dashboard_ids array must contain Integer only values" unless dashboard_ids.all? { |item| item.is_a?(Integer) }
+
+        dashboard_ids.sort.each do |dashboard_id|
+          logger.info("Dashboard Id: #{dashboard_id.to_s} Attempting CASCADE delete of dashboard, charts, datasets")
+          delete_datasets(dashboard_id)
+          delete_charts(dashboard_id)
+          delete_dashboard(dashboard_id)
+        end
+        true
+      end
+
+      private
+
+      def delete_datasets(dashboard_id)
+        datasets_to_delete = Superset::Dashboard::Datasets::List.new(dashboard_id).datasets_details.map{|d| d[:id] }
+        Superset::Dataset::BulkDelete.new(dataset_ids: datasets_to_delete).perform if datasets_to_delete.any?
+      end
+
+      def delete_charts(dashboard_id)
+        charts_to_delete = Superset::Dashboard::Charts::List.new(dashboard_id).chart_ids
+        Superset::Chart::BulkDelete.new(chart_ids: charts_to_delete).perform if charts_to_delete.any?
+      end
+
+      def delete_dashboard(dashboard_id)
+        Superset::Dashboard::Delete.new(dashboard_id: dashboard_id, confirm_zero_charts: true).perform
+      end
+
+      def logger
+        @logger ||= Superset::Logger.new
+      end
+    end
+  end
+end

data/lib/superset/dashboard/charts/list.rb

@@ -0,0 +1,47 @@
+module Superset
+  module Dashboard
+    module Charts
+      class List < Superset::Request
+        attr_reader :id  # dashboard id
+
+        def self.call(id)
+          self.new(id).list
+        end
+
+        def initialize(id)
+          @id = id
+        end
+
+        def chart_ids
+          result.map { |c| c[:id] }
+        end
+
+        def rows
+          result.map do |c|
+            [
+              c[:id],
+              c[:slice_name],
+              c[:form_data][:datasource],
+              # c[:form_data][:dashboards]  # NOTE: form_data dashboards is not accurate .. looks to be bugs related to copying charts
+            ]
+          end
+        end
+
+        private
+
+        def route
+          "dashboard/#{id}/charts"
+        end
+
+        def list_attributes
+          ['id', 'slice_name', 'datasource'].map(&:to_sym)
+        end
+
+        # when displaying a list of datasets, show dashboard id and title as well
+        def title
+          @title ||= [id, Superset::Dashboard::Get.new(id).title].join(' ')
+        end
+      end
+    end
+  end
+end

data/lib/superset/dashboard/compare.rb

@@ -0,0 +1,94 @@
+# A validation checker for comparing dashboards.
+# This class is used to compare two dashboards by their datasets, charts, native filters and cross filters.
+# Output is displayed in a table format to the ruby console
+# 
+# Usage:  Superset::Dashboard::Compare.new(first_dashboard_id: 322, second_dashboard_id: 347).perform
+#
+module Superset
+  module Dashboard
+    class Compare
+
+      attr_reader :first_dashboard_id, :second_dashboard_id
+
+      def initialize(first_dashboard_id: , second_dashboard_id: )
+        @first_dashboard_id = first_dashboard_id
+        @second_dashboard_id = second_dashboard_id
+      end
+
+
+      def perform
+        raise "Error: first_dashboard_id integer is required" unless first_dashboard_id.present? && first_dashboard_id.is_a?(Integer)
+        raise "Error: second_dashboard_id integer is required" unless second_dashboard_id.present? && second_dashboard_id.is_a?(Integer)
+
+        list_datasets
+        list_charts
+        list_native_filters
+        list_cross_filters
+
+      end
+
+      def first_dashboard
+        @first_dashboard ||= Get.new(first_dashboard_id).result
+      end
+
+      def second_dashboard
+        @second_dashboard ||= Get.new(second_dashboard_id).result
+      end
+
+      def list_datasets
+        puts "\n ====== DASHBOARD DATASETS ====== "
+        Superset::Dashboard::Datasets::List.new(first_dashboard_id).list
+        Superset::Dashboard::Datasets::List.new(second_dashboard_id).list
+      end
+
+      def list_charts
+        puts "\n ====== DASHBOARD CHARTS ====== "
+        Superset::Dashboard::Charts::List.new(first_dashboard_id).list
+        puts ''
+        Superset::Dashboard::Charts::List.new(second_dashboard_id).list
+      end
+
+      def list_native_filters
+        puts "\n ====== DASHBOARD NATIVE FILTERS ====== "
+        list_native_filters_for(first_dashboard)
+        puts ''
+        list_native_filters_for(second_dashboard)
+      end
+
+      def list_cross_filters
+        puts "\n ====== DASHBOARD CROSS FILTERS ====== "
+        list_cross_filters_for(first_dashboard)
+        puts ''
+        list_cross_filters_for(second_dashboard)
+      end
+
+      def native_filter_configuration(dashboard_result)
+        rows = []
+        JSON.parse(dashboard_result['json_metadata'])['native_filter_configuration'].each do |filter|
+          filter['targets'].each {|t| rows << [ t['column']['name'], t['datasetId'] ] }
+        end
+        rows
+      end
+
+      def list_native_filters_for(dashboard_result)
+        puts Terminal::Table.new(
+          title: [dashboard_result['id'], dashboard_result['dashboard_title']].join(' - '),
+          headings: ['Filter Name', 'Dataset Id'],
+          rows: native_filter_configuration(dashboard_result)
+        )
+      end
+
+      def cross_filter_configuration(dashboard_result)
+        JSON.parse(dashboard_result['json_metadata'])['chart_configuration'].map {|k, v| [ v['id'], v['crossFilters'].to_s ] }
+      end
+
+      def list_cross_filters_for(dashboard_result)
+        puts Terminal::Table.new(
+          title: [dashboard_result['id'], dashboard_result['dashboard_title']].join(' - '),
+          headings: ['Chart Id', 'Cross Filter Config'],
+          rows: cross_filter_configuration(dashboard_result)
+        )
+      end
+    end
+  end
+end

data/lib/superset/dashboard/copy.rb

@@ -0,0 +1,78 @@
+
+# TODO: some work to happen around TAGS still .. ie 'template' tag would indicate it tested and available to be copied.
+# TODO: also need to ensoure that the embedded details are not duplicated across to the new dashboard
+
+module Superset
+  module Dashboard
+    class Copy < Superset::Request
+
+      attr_reader :source_dashboard_id, :duplicate_slices, :clear_shared_label_colors
+
+      def initialize(source_dashboard_id: , duplicate_slices: false, clear_shared_label_colors: false)
+        @source_dashboard_id = source_dashboard_id
+        @duplicate_slices = duplicate_slices # boolean indicates whether to duplicate charts OR keep the new dashboard pointing to the same charts as the original
+        @clear_shared_label_colors = clear_shared_label_colors
+      end
+
+      def perform
+        raise "Error: source_dashboard_id integer is required" unless source_dashboard_id.present? && source_dashboard_id.is_a?(Integer)
+        raise "Error: duplicate_slices must be a boolean" unless duplicate_slices_is_boolean?
+
+        adjust_json_metadata
+        response
+        Superset::Dashboard::Get.new(id).perform  # return the full new dashboard object
+      end
+
+      def params
+        {
+          "css" => "{}",
+          "dashboard_title" => "#{source_dashboard.title}",
+          "duplicate_slices" => duplicate_slices,
+          "json_metadata" => new_dashboard_json_metadata.to_json,
+        }
+      end
+
+      def response
+        @response ||= client.post(route, params)
+      end
+
+      def id
+        response["result"]["id"]
+      end
+
+      private
+
+      def route
+        "dashboard/#{source_dashboard_id}/copy/"
+      end
+
+      def adjust_json_metadata
+        # when copying a DB via the API, chart positions need to be nested under json_metadata according to the GUI copy function  (as per dev tools investigation in browser)
+        new_dashboard_json_metadata.merge!( "positions" => source_dashboard.positions )
+
+        if clear_shared_label_colors
+          # if coping a dashboard to a new db schema .. shared label colors will not be relevant/match as they are specific to the previous schemas dataset values
+          new_dashboard_json_metadata.merge!( "shared_label_colors" => {} )
+        end
+      end
+
+      def source_dashboard
+        @source_dashboard ||= begin
+          dash = Get.new(source_dashboard_id)
+          dash.response
+          dash
+        rescue => e
+          raise "Error retrieving source dashboard #{e.message}"
+        end
+      end
+
+      def new_dashboard_json_metadata
+        @new_dashboard_json_metadata ||= source_dashboard.json_metadata
+      end
+
+      def duplicate_slices_is_boolean?
+        [true, false].include?(duplicate_slices)
+      end
+    end
+  end
+end

data/lib/superset/dashboard/datasets/list.rb

@@ -0,0 +1,74 @@
+# WARNING: Does not take into account datasets with queries that have embedded schema references.
+# ie " select * from schema1.table join schema2.table" for a dataset query will ONLY return the datasets config schema setting not the sql query schema references which refers to 2 distinct schemas.
+#
+# WARNING: Does not return Filter Datasets for the dashboard
+
+module Superset
+  module Dashboard
+    module Datasets
+      class List < Superset::Request
+        attr_reader :id  # dashboard id
+
+        def self.call(id)
+          self.new(id).list
+        end
+
+        def initialize(id)
+          @id = id
+        end
+
+        def perform
+          response
+          self
+        end
+
+        def schemas
+          @schemas ||= begin
+            all_dashboard_schemas = result.map {|d| d[:schema] }.uniq
+
+            # For the current superset setup we will assume a dashboard datasets will point to EXACTLY one schema, their own.
+            # if not .. we need to know about it. Potentially we could override this check if others do not consider it a problem.
+            if all_dashboard_schemas.count > 1
+              Rollbar.error("SUPERSET DASHBOARD ERROR: Dashboard id #{id} has multiple dataset schema linked: #{all_dashboard_schemas.to_s}")
+            end
+            all_dashboard_schemas
+          end
+        end
+
+        def datasets_details
+          result.map do |details|
+            details.slice('id', 'datasource_name', 'schema', 'sql').merge('database' => details['database'].slice('id', 'name', 'backend')).with_indifferent_access
+          end
+        end
+
+        private
+
+        def route
+          "dashboard/#{id}/datasets"
+        end
+
+        def list_attributes
+          ['id', 'datasource_name', 'database_id', 'database_name', 'database_backend', 'schema'].map(&:to_sym)
+        end
+
+        def rows
+          result.map do |d|
+            [
+              d[:id],
+              d[:datasource_name],
+              d[:database][:id],
+              d[:database][:name],
+              d[:database][:backend],
+              d[:schema]
+            ]
+          end
+        end
+
+        # when displaying a list of datasets, show dashboard title as well
+        def title
+          @title ||= [id, Superset::Dashboard::Get.new(id).title].join(' ')
+        end
+      end
+    end
+  end
+end

data/lib/superset/dashboard/delete.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Superset
+  module Dashboard
+    class Delete < Superset::Request
+
+      attr_reader :dashboard_id, :confirm_zero_charts
+
+      def initialize(dashboard_id: , confirm_zero_charts: true)
+        @dashboard_id = dashboard_id
+        @confirm_zero_charts = confirm_zero_charts
+      end
+
+      def perform
+        raise InvalidParameterError, "dashboard_id integer is required" unless dashboard_id.present? && dashboard_id.is_a?(Integer)
+
+        confirm_zero_charts_on_dashboard if confirm_zero_charts
+
+        logger.info("Attempting to delete dashboard with id: #{dashboard_id}")
+        response
+      end
+
+      def response
+        @response ||= client.delete(route)
+      end
+
+      private
+
+      def confirm_zero_charts_on_dashboard
+        raise "Error: Dashboard includes #{dashboard_charts.count} charts. Please delete all charts before deleting the dashboard or override and set confirm_zero_charts: false" if dashboard_charts.count.positive?
+      end
+
+      def dashboard_charts
+        @dashboard_charts ||= Superset::Dashboard::Charts::List.new(dashboard_id).rows
+      end
+
+      def route
+        "dashboard/#{dashboard_id}"
+      end
+    end
+  end
+end

data/lib/superset/dashboard/embedded/get.rb

@@ -0,0 +1,56 @@
+module Superset
+  module Dashboard
+    module Embedded
+      class Get < Superset::Request
+        attr_reader :id  # dashboard id
+
+        def self.call(id)
+          self.new(id).list
+        end
+
+        def initialize(id)
+          @id = id
+        end
+
+        def response
+          @response ||= client.get(route)
+        rescue Happi::Error::NotFound => e
+          logger.info("Dashboard #{id} has no Embedded settings. (skipping)") # some dashboards don't have embedded settings, fine to ignore.
+          @response = { result: [] }.with_indifferent_access
+          @response
+        end
+
+        def result
+          response[:result].empty? ? [] : [ super ] # wrap single result in an array so it can be used in the tt list and table
+        end
+
+        def allowed_domains
+          result.first['allowed_domains'] unless response[:result].empty?
+        end
+
+        def uuid
+          result.first['uuid'] unless response[:result].empty?
+        end
+
+        def list
+          super unless response[:result].empty?
+        end
+
+        private
+
+        def route
+          "dashboard/#{id}/embedded"
+        end
+
+        def list_attributes
+          [:dashboard_id, :uuid, :allowed_domains, :changed_on]
+        end
+
+        # when displaying embedded details, show dashboard title as well
+        def title
+          Superset::Dashboard::Get.new(id).title
+        end
+      end
+    end
+  end
+end

data/lib/superset/dashboard/embedded/put.rb

@@ -0,0 +1,35 @@
+module Superset
+  module Dashboard
+    module Embedded
+      class Put < Superset::Request
+        attr_reader :dashboard_id, :allowed_domains
+
+        def initialize(dashboard_id: , allowed_domains: )
+          @dashboard_id = dashboard_id
+          @allowed_domains = allowed_domains
+        end
+
+        def response
+          raise  InvalidParameterError, 'dashboard_id integer is required' if dashboard_id.nil? || dashboard_id.class != Integer
+          raise  InvalidParameterError, 'allowed_domains array is required' if allowed_domains.nil? || allowed_domains.class != Array
+
+          @response ||= client.put(route, params)
+        end
+
+        def params
+          { "allowed_domains": allowed_domains }
+        end
+
+        def uuid
+          result['uuid'] unless response[:result].empty?
+        end
+
+        private
+
+        def route
+          "dashboard/#{dashboard_id}/embedded"
+        end
+      end
+    end
+  end
+end

data/lib/superset/dashboard/export.rb

@@ -0,0 +1,98 @@
+# Will export the zip file to /tmp/superset_dashboards with zip filename adjusted to include the dashboard_id
+# Example zipfile: dashboard_#{dashboard_id}_export_#{datestamp}.zip
+# Will then unzip and copy the files into the destination_path with the dashboard_id as a subfolder
+#
+# Usage
+# Superset::Dashboard::Export.new(dashboard_id: 15, destination_path: '/tmp/superset_dashboard_backups/').perform
+#
+
+require 'superset/file_utilities'
+
+module Superset
+  module Dashboard
+    class Export < Request
+      include FileUtilities
+
+      TMP_SUPERSET_DASHBOARD_PATH = '/tmp/superset_dashboards'
+
+      attr_reader :dashboard_id, :destination_path
+
+      def initialize(dashboard_id: , destination_path: )
+        @dashboard_id = dashboard_id
+        @destination_path = destination_path.chomp('/')
+      end
+
+      def perform
+        create_tmp_dir
+        save_exported_zip_file
+        unzip_files
+        copy_export_files_to_destination_path if destination_path
+      end
+
+      def response
+        @response ||= client.call(
+          :get,
+          client.url(route),
+          client.param_check(params)
+        )
+      end
+
+      private
+
+      def params
+        { "q": "!(#{dashboard_id})" }   # pulled off chrome dev tools doing a GUI export.  Swagger interface not helpfull with this endpoint.
+      end
+
+      def save_exported_zip_file
+        File.open(zip_file_name, 'wb') { |fp| fp.write(response.body) }
+      end
+
+      def unzip_files
+        @extracted_files = unzip_file(zip_file_name, tmp_uniq_dashboard_path)
+      end
+
+      def download_folder
+        File.dirname(extracted_files[0])
+      end
+
+      def copy_export_files_to_destination_path
+        path_with_dash_id = File.join(destination_path, dashboard_id.to_s)
+        FileUtils.mkdir_p(path_with_dash_id) unless File.directory?(path_with_dash_id)
+
+        Dir.glob("#{download_folder}/*").each do |item|
+          FileUtils.cp_r(item, path_with_dash_id)
+        end
+      end
+
+      def zip_file_name
+        @zip_file_name ||= "#{tmp_uniq_dashboard_path}/dashboard_#{dashboard_id}_export_#{datestamp}.zip"
+      end
+
+      def create_tmp_dir
+        FileUtils.mkdir_p(tmp_uniq_dashboard_path) unless File.directory?(tmp_uniq_dashboard_path)
+      end
+
+      # uniq random tmp folder name for each export
+      # this will allow us to do a wildcard glop on the folder to get the files 
+      def tmp_uniq_dashboard_path
+        @tmp_uniq_dashboard_path ||= File.join(TMP_SUPERSET_DASHBOARD_PATH, uuid)
+      end
+
+      def uuid
+        SecureRandom.uuid
+      end
+
+      def extracted_files
+        @extracted_files ||= []
+      end
+
+      def route
+        "dashboard/export/"
+      end
+
+      def datestamp
+        @datestamp ||= Time.now.strftime('%Y%m%d')
+      end
+    end
+  end
+end

data/lib/superset/dashboard/get.rb

@@ -0,0 +1,51 @@
+module Superset
+  module Dashboard
+    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 title
+        "#{result['dashboard_title']}"
+      end
+
+      def json_metadata
+        JSON.parse(result['json_metadata'])
+      end
+
+      def positions
+        JSON.parse(result['position_json'])
+      end
+
+      def url
+        "#{superset_host}#{result['url']}"
+      end
+
+      private
+
+      def route
+        "dashboard/#{id}"
+      end
+
+      def rows
+        result['charts'].map {|c| [c]}
+      end
+
+      def headings
+        ['Charts']
+      end
+    end
+  end
+end

data/lib/superset/dashboard/info.rb

@@ -0,0 +1,17 @@
+module Superset
+  module Dashboard
+    class Info < Superset::Request
+      alias result response
+
+      def filters
+        result['filters']
+      end
+
+      private
+
+      def route
+        "dashboard/_info"
+      end
+    end
+  end
+end