nquery 0.1.3 → 0.1.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (49) hide show
  1. checksums.yaml +4 -4
  2. data/CHANGELOG.md +17 -0
  3. data/app/assets/builds/nquery/application.css +88 -4
  4. data/app/assets/builds/nquery/application.js +353 -3
  5. data/app/controllers/concerns/nquery/chart_actions.rb +1 -1
  6. data/app/controllers/concerns/nquery/chart_results.rb +54 -7
  7. data/app/controllers/nquery/dashboard/cards_controller.rb +28 -0
  8. data/app/controllers/nquery/dashboards_controller.rb +49 -9
  9. data/app/controllers/nquery/embed/dashboards_controller.rb +17 -1
  10. data/app/controllers/nquery/public/dashboards_controller.rb +14 -1
  11. data/app/controllers/nquery/queries_controller.rb +23 -2
  12. data/app/models/nquery/chart.rb +4 -0
  13. data/app/models/nquery/dashboard.rb +129 -0
  14. data/app/models/nquery/query.rb +68 -0
  15. data/app/services/nquery/application_service.rb +9 -0
  16. data/app/services/nquery/dashboards/card_parameters.rb +37 -0
  17. data/app/services/nquery/dashboards/filters.rb +75 -0
  18. data/app/services/nquery/dashboards/parameter_charts.rb +31 -0
  19. data/app/services/nquery/dashboards/parameter_rows.rb +60 -0
  20. data/app/views/layouts/nquery/application.html.erb +8 -0
  21. data/app/views/nquery/charts/_builder_form.html.erb +12 -0
  22. data/app/views/nquery/charts/_variable_row.html.erb +10 -0
  23. data/app/views/nquery/charts/_variables.html.erb +28 -0
  24. data/app/views/nquery/charts/update.turbo_stream.erb +3 -0
  25. data/app/views/nquery/dashboards/_chart_card.html.erb +27 -1
  26. data/app/views/nquery/dashboards/_parameter_chart_ids.html.erb +6 -0
  27. data/app/views/nquery/dashboards/_parameters.html.erb +159 -0
  28. data/app/views/nquery/dashboards/edit.html.erb +10 -0
  29. data/app/views/nquery/dashboards/show.html.erb +37 -1
  30. data/app/views/nquery/shared/_icon.html.erb +4 -0
  31. data/app/views/nquery/shared/_sidebar.html.erb +1 -1
  32. data/app/views/nquery/shared/_topbar.html.erb +3 -0
  33. data/config/routes.rb +4 -0
  34. data/db/migrate/20261005145000_add_parameters_to_nquery_dashboards.rb +7 -0
  35. data/db/migrate/20261005190000_add_parameters_to_nquery_queries.rb +7 -0
  36. data/lib/nquery/dashboard_parameters.rb +56 -0
  37. data/lib/nquery/data_sources/adapter.rb +10 -1
  38. data/lib/nquery/data_sources/mysql_adapter.rb +2 -2
  39. data/lib/nquery/data_sources/postgresql_adapter.rb +2 -2
  40. data/lib/nquery/data_sources/rails_adapter.rb +2 -7
  41. data/lib/nquery/data_sources/row_limit.rb +211 -0
  42. data/lib/nquery/parameter_value.rb +97 -0
  43. data/lib/nquery/query_runner.rb +37 -4
  44. data/lib/nquery/seeder.rb +9 -1
  45. data/lib/nquery/statement_binds.rb +112 -0
  46. data/lib/nquery/version.rb +1 -1
  47. data/lib/nquery.rb +4 -0
  48. data/nquery.gemspec +2 -2
  49. metadata +22 -6
@@ -6,10 +6,16 @@ module Nquery
6
6
 
7
7
  private
8
8
 
9
- def chart_result(chart)
9
+ def chart_result(chart, parameters: nil)
10
10
  return demo_result unless chart.statement?
11
11
 
12
- chart_query_result(chart)
12
+ resolved = parameters || query_default_parameters(chart)
13
+ chart_query_result(chart, parameters: resolved)
14
+ rescue QueryRunner::ParameterError => error
15
+ { error: parameter_load_error(chart.statement, resolved, error) }
16
+ rescue QueryRunner::Error => error
17
+ Rails.logger.error("[nquery] chart #{chart.id} failed: #{error.class}: #{error.message}")
18
+ { error: shared_chart_load_error }
13
19
  rescue StandardError
14
20
  demo_result
15
21
  end
@@ -17,29 +23,38 @@ module Nquery
17
23
  def chart_builder_result(chart)
18
24
  return nil unless chart.statement?
19
25
 
20
- chart_query_result(chart, audit: false)
26
+ chart_query_result(chart, audit: false, parameters: query_default_parameters(chart))
21
27
  rescue QueryRunner::PermissionError, QueryRunner::Error => e
22
28
  { error: e.message }
23
29
  rescue StandardError => e
24
30
  { error: e.message }
25
31
  end
26
32
 
27
- def shared_chart_result(chart)
33
+ def shared_chart_result(chart, parameters: nil)
28
34
  return { error: "This chart has no query." } unless chart.statement?
29
35
  return { error: shared_chart_load_error } unless chart.data_source
30
36
 
31
- chart_query_result(chart, audit: false)
37
+ chart_query_result(chart, audit: false, parameters: parameters)
38
+ rescue QueryRunner::ParameterError => error
39
+ { error: parameter_load_error(chart.statement, parameters, error) }
32
40
  rescue StandardError => e
33
41
  Rails.logger.error("[nquery] shared chart #{chart.id} failed: #{e.class}: #{e.message}")
34
42
  { error: shared_chart_load_error }
35
43
  end
36
44
 
37
- def chart_query_result(chart, audit: true)
45
+ def query_default_parameters(chart)
46
+ return unless chart.query
47
+
48
+ DashboardParameters.call(dashboard: chart.query, token_params: {}, request_params: {})
49
+ end
50
+
51
+ def chart_query_result(chart, audit: true, parameters: nil)
38
52
  QueryRunner.new(
39
53
  data_source: chart.data_source || DataSource.first,
40
54
  statement: chart.statement,
41
55
  user: current_nquery_user,
42
- query: chart.query
56
+ query: chart.query,
57
+ parameters: parameters
43
58
  ).run(audit: audit)
44
59
  end
45
60
 
@@ -54,5 +69,37 @@ module Nquery
54
69
  def shared_chart_load_error
55
70
  "This chart could not be loaded."
56
71
  end
72
+
73
+ def parameter_load_error(statement, parameters, error)
74
+ return shared_chart_load_error unless error.message.match?(/\A(?:Missing value for|Unknown parameter) /)
75
+
76
+ names = StatementBinds.missing_names(
77
+ statement: statement,
78
+ parameters: parameter_value_hash(parameters),
79
+ invalid_names: parameter_invalid_names(parameters)
80
+ )
81
+ return shared_chart_load_error if names.empty?
82
+
83
+ labels = names.map { |name| name.tr("_", " ").capitalize }
84
+ if labels.one?
85
+ "Enter a value for #{labels.first}."
86
+ else
87
+ "Enter values for #{labels.to_sentence}."
88
+ end
89
+ end
90
+
91
+ def parameter_value_hash(parameters)
92
+ case parameters
93
+ when DashboardParameters::Result then parameters.values
94
+ when Hash then parameters
95
+ else {}
96
+ end
97
+ end
98
+
99
+ def parameter_invalid_names(parameters)
100
+ return parameters.invalid_names if parameters.is_a?(DashboardParameters::Result)
101
+
102
+ []
103
+ end
57
104
  end
58
105
  end
@@ -0,0 +1,28 @@
1
+ # frozen_string_literal: true
2
+
3
+ module Nquery
4
+ class Dashboard::CardsController < ApplicationController
5
+ before_action :set_dashboard
6
+ before_action :authorize_dashboard_curate!
7
+
8
+ def parameters
9
+ card = @dashboard.dashboard_cards.find(params[:id])
10
+ Dashboards::CardParameters.call(
11
+ dashboard: @dashboard,
12
+ chart: card.chart,
13
+ linked_names: Array(params[:parameter_names])
14
+ )
15
+ redirect_to dashboard_path(@dashboard), notice: "Chart filters updated."
16
+ end
17
+
18
+ private
19
+
20
+ def set_dashboard
21
+ @dashboard = Dashboard.find(params[:dashboard_id])
22
+ end
23
+
24
+ def authorize_dashboard_curate!
25
+ authorize_collection_access!(@dashboard.collection, required: :curate)
26
+ end
27
+ end
28
+ end
@@ -6,9 +6,9 @@ module Nquery
6
6
  include Browsable
7
7
  include SharingPage
8
8
 
9
- before_action :set_dashboard, only: %i[show edit update destroy archive unarchive update_layout embed]
9
+ before_action :set_dashboard, only: %i[show edit update destroy archive unarchive update_layout embed connect_parameter]
10
10
  before_action :authorize_dashboard_view!, only: %i[show embed]
11
- before_action :authorize_dashboard_curate!, only: %i[edit update destroy archive unarchive update_layout]
11
+ before_action :authorize_dashboard_curate!, only: %i[edit update destroy archive unarchive update_layout connect_parameter]
12
12
 
13
13
  def index
14
14
  @dashboards = filter_viewable_dashboards(Dashboard.active.includes(:collection).order(:name))
@@ -38,11 +38,7 @@ module Nquery
38
38
  end
39
39
 
40
40
  def show
41
- @dashboard_cards = @dashboard.dashboard_cards
42
- .joins(:chart)
43
- .merge(Chart.active)
44
- .includes(:chart)
45
- @card_results = @dashboard_cards.index_with { |card| chart_result(card.chart) }
41
+ assign_dashboard_filters
46
42
  end
47
43
 
48
44
  def embed
@@ -57,8 +53,19 @@ module Nquery
57
53
  @collections = assignable_collections
58
54
  authorize_collection_access!(Collection.find(dashboard_params[:collection_id]), required: :curate) if dashboard_params[:collection_id].present?
59
55
 
56
+ previous_names = @dashboard.parameter_names
60
57
  if @dashboard.update(dashboard_params)
61
- redirect_to dashboard_path(@dashboard), notice: "Dashboard updated."
58
+ added = @dashboard.parameter_names - previous_names
59
+ if parameter_submission? && added.one?
60
+ redirect_to dashboard_path(@dashboard, edit: "parameters", wire: added.first), notice: "Filter added."
61
+ elsif parameter_submission? && params[:edit] == "parameters"
62
+ redirect_to dashboard_path(@dashboard, **wire_query), notice: "Dashboard updated."
63
+ else
64
+ redirect_to dashboard_path(@dashboard), notice: "Dashboard updated."
65
+ end
66
+ elsif parameter_submission?
67
+ assign_dashboard_filters
68
+ render :show, status: :unprocessable_content
62
69
  else
63
70
  render :edit, status: :unprocessable_content
64
71
  end
@@ -79,6 +86,15 @@ module Nquery
79
86
  redirect_to dashboard_path(@dashboard), notice: "Dashboard unarchived."
80
87
  end
81
88
 
89
+ def connect_parameter
90
+ Dashboards::ParameterCharts.call(
91
+ dashboard: @dashboard,
92
+ name: params[:name],
93
+ chart_ids: params.permit(chart_ids: []).fetch(:chart_ids, [])
94
+ )
95
+ redirect_to dashboard_path(@dashboard, **wire_query), notice: "Filter connected."
96
+ end
97
+
82
98
  def update_layout
83
99
  card_layouts.each do |card_id, layout|
84
100
  card = @dashboard.dashboard_cards.find(card_id)
@@ -111,8 +127,32 @@ module Nquery
111
127
  end
112
128
  end
113
129
 
130
+ def assign_dashboard_filters
131
+ filters = ::Nquery::Dashboards::Filters.call(dashboard: @dashboard, request_params: params)
132
+ @filter_dashboard = filters.filter_dashboard
133
+ @invalid_parameter_names = filters.parameters.invalid_names
134
+ @dashboard_cards = @dashboard.dashboard_cards
135
+ .joins(:chart)
136
+ .merge(Chart.active)
137
+ .includes(chart: { query: :data_source })
138
+ @card_results = @dashboard_cards.index_with do |card|
139
+ chart_result(card.chart, parameters: @dashboard.parameters_for_chart(card.chart, filters.parameters))
140
+ end
141
+ end
142
+
143
+ def parameter_submission?
144
+ params[:dashboard]&.key?(:parameters)
145
+ end
146
+
147
+ def wire_query
148
+ { edit: params[:edit].presence, wire: params[:wire].presence }.compact
149
+ end
150
+
114
151
  def dashboard_params
115
- params.require(:dashboard).permit(:name, :description, :collection_id, settings: {})
152
+ permitted = params.require(:dashboard).permit(
153
+ :name, :description, :collection_id, settings: {}, parameters: [:name, :type, :default, { chart_ids: [] }]
154
+ )
155
+ Dashboards::ParameterRows.call(dashboard: @dashboard, attributes: permitted)
116
156
  end
117
157
 
118
158
  def default_dashboard_collection
@@ -18,11 +18,27 @@ module Nquery
18
18
  return render_forbidden("Embedding is disabled")
19
19
  end
20
20
 
21
+ resolved = DashboardParameters.call(
22
+ dashboard: @dashboard.with_agreed_chart_variables,
23
+ token_params: embed_parameter_params(payload[:params]),
24
+ request_params: embed_parameter_params(params)
25
+ )
21
26
  @dashboard_cards = load_dashboard_cards(@dashboard)
22
- @card_results = @dashboard_cards.index_with { |card| shared_chart_result(card.chart) }
27
+ @card_results = @dashboard_cards.index_with do |card|
28
+ shared_chart_result(card.chart, parameters: @dashboard.parameters_for_chart(card.chart, resolved))
29
+ end
23
30
  rescue EmbedTokenService::Error, ActiveRecord::RecordNotFound
24
31
  render_forbidden
25
32
  end
33
+
34
+ private
35
+
36
+ def embed_parameter_params(source)
37
+ return {} if source.blank?
38
+
39
+ hash = source.respond_to?(:to_unsafe_h) ? source.to_unsafe_h : source.to_h
40
+ hash.stringify_keys.except("token", "titled", "bordered", "theme").slice(*@dashboard.parameter_names)
41
+ end
26
42
  end
27
43
  end
28
44
  end
@@ -10,11 +10,24 @@ module Nquery
10
10
 
11
11
  @dashboard = Dashboard.active.find_by!(public_uuid: params[:uuid])
12
12
  @dashboard_cards = load_dashboard_cards(@dashboard)
13
- @card_results = @dashboard_cards.index_with { |card| shared_chart_result(card.chart) }
13
+ resolved = declared_dashboard_parameters
14
+ @card_results = @dashboard_cards.index_with do |card|
15
+ shared_chart_result(card.chart, parameters: @dashboard.parameters_for_chart(card.chart, resolved))
16
+ end
14
17
  render template: "nquery/embed/dashboards/show"
15
18
  rescue ActiveRecord::RecordNotFound
16
19
  render_unavailable(status: :not_found)
17
20
  end
21
+
22
+ private
23
+
24
+ def declared_dashboard_parameters
25
+ DashboardParameters.call(
26
+ dashboard: @dashboard.with_agreed_chart_variables,
27
+ token_params: {},
28
+ request_params: {}
29
+ )
30
+ end
18
31
  end
19
32
  end
20
33
  end
@@ -20,7 +20,8 @@ module Nquery
20
20
  result = QueryRunner.new(
21
21
  data_source: @data_source,
22
22
  statement: params[:statement],
23
- user: current_nquery_user
23
+ user: current_nquery_user,
24
+ parameters: run_parameters
24
25
  ).run
25
26
 
26
27
  render json: result
@@ -54,7 +55,27 @@ module Nquery
54
55
  end
55
56
 
56
57
  def query_params
57
- params.require(:query).permit(:name, :statement, :data_source_id, :collection_id)
58
+ params.require(:query).permit(:name, :statement, :data_source_id, :collection_id, parameters: [:name, :type, :default])
59
+ end
60
+
61
+ def run_parameters
62
+ rows = run_parameter_rows
63
+ return if rows.empty?
64
+
65
+ explicit = {}
66
+ definitions = rows.map do |row|
67
+ explicit[row["name"]] = row["value"] if row.key?("value")
68
+ row.except("value")
69
+ end
70
+ source = Query.new(statement: params[:statement], parameters: definitions)
71
+ DashboardParameters.call(dashboard: source, token_params: {}, request_params: explicit)
72
+ end
73
+
74
+ def run_parameter_rows
75
+ return [] if params[:parameters].blank?
76
+
77
+ permitted = params.permit(parameters: [:name, :type, :default, :value])
78
+ Array(permitted[:parameters]).map { |row| row.to_h.stringify_keys }
58
79
  end
59
80
  end
60
81
  end
@@ -42,6 +42,10 @@ module Nquery
42
42
  query&.statement? || false
43
43
  end
44
44
 
45
+ def uses_parameter?(name)
46
+ statement.to_s.match?(/\{\{\s*#{Regexp.escape(name)}\s*\}\}/)
47
+ end
48
+
45
49
  def data_source
46
50
  query&.data_source
47
51
  end
@@ -9,10 +9,59 @@ module Nquery
9
9
  has_many :dashboard_cards, class_name: "Nquery::DashboardCard", dependent: :destroy
10
10
  has_many :charts, through: :dashboard_cards, class_name: "Nquery::Chart"
11
11
 
12
+ PARAMETER_NAME_FORMAT = /\A[a-z][a-z0-9_]*\z/
13
+ RESERVED_PARAMETER_NAMES = %w[token titled bordered theme wire id action controller format].freeze
14
+
12
15
  scope :active, -> { where(archived_at: nil) }
13
16
  scope :archived, -> { where.not(archived_at: nil) }
14
17
 
15
18
  validates :name, presence: true
19
+ validate :parameters_are_declared
20
+
21
+ before_validation :normalize_parameters
22
+
23
+ def parameter_definitions
24
+ normalized_parameter_rows(parameters)
25
+ end
26
+
27
+ def parameter_names
28
+ parameter_definitions.map { |row| row["name"] }
29
+ end
30
+
31
+ def with_agreed_chart_variables
32
+ loaded_charts = charts.includes(:query).to_a
33
+ charts_by_id = loaded_charts.index_by(&:id)
34
+ rows = parameter_definitions.map { |row| agreed_chart_variable_row(row, loaded_charts, charts_by_id) }
35
+ return self if rows == parameter_definitions
36
+
37
+ copy = dup
38
+ copy.id = id
39
+ copy.parameters = rows
40
+ copy.readonly!
41
+ copy
42
+ end
43
+
44
+ def parameter_linked_to_chart?(row, chart)
45
+ return true unless row.key?("chart_ids")
46
+
47
+ Array(row["chart_ids"]).map(&:to_i).include?(chart.id)
48
+ end
49
+
50
+ def linked_chart_ids(row)
51
+ if row.key?("chart_ids")
52
+ Array(row["chart_ids"]).map(&:to_i)
53
+ else
54
+ charts.select { |chart| chart.uses_parameter?(row["name"]) }.map(&:id)
55
+ end
56
+ end
57
+
58
+ def parameters_for_chart(chart, resolved)
59
+ names = parameter_definitions.select { |row| parameter_linked_to_chart?(row, chart) }.map { |row| row["name"] }
60
+ DashboardParameters::Result.new(
61
+ values: resolved.values.slice(*names),
62
+ invalid_names: Array(resolved.invalid_names) & names
63
+ )
64
+ end
16
65
 
17
66
  def archived?
18
67
  archived_at.present?
@@ -25,5 +74,85 @@ module Nquery
25
74
  def unarchive!
26
75
  update!(archived_at: nil)
27
76
  end
77
+
78
+ private
79
+
80
+ def normalize_parameters
81
+ self.parameters = parameter_definitions
82
+ end
83
+
84
+ def normalized_parameter_rows(value)
85
+ Array(value).filter_map { |row| normalized_parameter_row(row) }
86
+ end
87
+
88
+ def normalized_parameter_row(row)
89
+ return unless row.respond_to?(:stringify_keys)
90
+
91
+ attrs = row.stringify_keys
92
+ name = attrs["name"].to_s.strip
93
+ return if name.blank?
94
+
95
+ row = {
96
+ "name" => name,
97
+ "type" => attrs["type"].to_s.strip,
98
+ "default" => attrs["default"].to_s.strip
99
+ }
100
+ row["chart_ids"] = chart_ids_for(attrs["chart_ids"]) if attrs.key?("chart_ids")
101
+ row
102
+ end
103
+
104
+ def chart_ids_for(value)
105
+ Array(value).filter_map { |chart_id| Integer(chart_id, exception: false) }.uniq
106
+ end
107
+
108
+ def agreed_chart_variable_row(row, loaded_charts, charts_by_id)
109
+ definitions = linked_variable_definitions(row, loaded_charts, charts_by_id)
110
+ return row if definitions.empty?
111
+
112
+ types = definitions.map { |definition| definition["type"] }.uniq
113
+ defaults = definitions.map { |definition| definition["default"] }.uniq
114
+ return row unless types.one? && defaults.one?
115
+
116
+ row.merge("type" => types.first, "default" => defaults.first)
117
+ end
118
+
119
+ def linked_variable_definitions(row, loaded_charts, charts_by_id)
120
+ chart_ids_for_row(row, loaded_charts).filter_map do |chart_id|
121
+ charts_by_id[chart_id]&.query&.stored_parameter_definitions&.find { |definition| definition["name"] == row["name"] }
122
+ end
123
+ end
124
+
125
+ def chart_ids_for_row(row, loaded_charts)
126
+ if row.key?("chart_ids")
127
+ Array(row["chart_ids"]).map(&:to_i)
128
+ else
129
+ loaded_charts.select { |chart| chart.uses_parameter?(row["name"]) }.map(&:id)
130
+ end
131
+ end
132
+
133
+ def parameters_are_declared
134
+ names = []
135
+ parameter_definitions.each do |row|
136
+ name = row["name"]
137
+ unless name.match?(PARAMETER_NAME_FORMAT)
138
+ errors.add(:parameters, "include an invalid name")
139
+ next
140
+ end
141
+
142
+ errors.add(:parameters, "cannot use #{name}") if RESERVED_PARAMETER_NAMES.include?(name)
143
+
144
+ if names.include?(name)
145
+ errors.add(:parameters, "include a duplicate name")
146
+ else
147
+ names << name
148
+ end
149
+
150
+ if ParameterValue::TYPES.exclude?(row["type"])
151
+ errors.add(:parameters, "must be string, integer, date, datetime, uuid, or boolean")
152
+ elsif !ParameterValue.valid_default?(row["type"], row["default"])
153
+ errors.add(:parameters, "include an invalid default")
154
+ end
155
+ end
156
+ end
28
157
  end
29
158
  end
@@ -8,10 +8,15 @@ module Nquery
8
8
  has_one :chart, class_name: "Nquery::Chart", dependent: :destroy
9
9
  has_many :audits, class_name: "Nquery::Audit", dependent: :nullify
10
10
 
11
+ PARAMETER_NAME_FORMAT = /\A[a-z][a-z0-9_]*\z/
12
+ RESERVED_PARAMETER_NAMES = %w[token titled bordered theme wire id action controller format].freeze
13
+
11
14
  validates :name, presence: true, on: :update
12
15
  validate :statement_must_be_readonly
16
+ validate :parameters_are_declared
13
17
 
14
18
  before_validation :set_default_name, on: :create
19
+ before_validation :normalize_parameters
15
20
 
16
21
  def set_default_name
17
22
  self.name ||= "Untitled query"
@@ -21,8 +26,71 @@ module Nquery
21
26
  statement.present?
22
27
  end
23
28
 
29
+ def statement_parameter_names
30
+ statement.to_s.scan(StatementBinds::PLACEHOLDER).flatten.uniq
31
+ end
32
+
33
+ def stored_parameter_definitions
34
+ stored = normalized_parameter_rows(parameters).index_by { |row| row["name"] }
35
+ statement_parameter_names.filter_map { |name| stored[name] }
36
+ end
37
+
38
+ def parameter_definitions
39
+ stored = stored_parameter_definitions.index_by { |row| row["name"] }
40
+ statement_parameter_names.map do |name|
41
+ stored[name] || { "name" => name, "type" => "string", "default" => "" }
42
+ end
43
+ end
44
+
24
45
  private
25
46
 
47
+ def normalize_parameters
48
+ self.parameters = stored_parameter_definitions
49
+ end
50
+
51
+ def normalized_parameter_rows(value)
52
+ Array(value).filter_map { |row| normalized_parameter_row(row) }
53
+ end
54
+
55
+ def normalized_parameter_row(row)
56
+ return unless row.respond_to?(:stringify_keys)
57
+
58
+ attrs = row.stringify_keys
59
+ name = attrs["name"].to_s.strip
60
+ return if name.blank?
61
+
62
+ {
63
+ "name" => name,
64
+ "type" => attrs["type"].to_s.strip,
65
+ "default" => attrs["default"].to_s.strip
66
+ }
67
+ end
68
+
69
+ def parameters_are_declared
70
+ names = []
71
+ parameter_definitions.each do |row|
72
+ name = row["name"]
73
+ unless name.match?(PARAMETER_NAME_FORMAT)
74
+ errors.add(:parameters, "include an invalid name")
75
+ next
76
+ end
77
+
78
+ errors.add(:parameters, "cannot use #{name}") if RESERVED_PARAMETER_NAMES.include?(name)
79
+
80
+ if names.include?(name)
81
+ errors.add(:parameters, "include a duplicate name")
82
+ else
83
+ names << name
84
+ end
85
+
86
+ if ParameterValue::TYPES.exclude?(row["type"])
87
+ errors.add(:parameters, "must be string, integer, date, datetime, uuid, or boolean")
88
+ elsif !ParameterValue.valid_default?(row["type"], row["default"])
89
+ errors.add(:parameters, "include an invalid default")
90
+ end
91
+ end
92
+ end
93
+
26
94
  def statement_must_be_readonly
27
95
  message = ReadonlySql.error_message(statement, allow_blank: true)
28
96
  errors.add(:statement, message) if message
@@ -0,0 +1,9 @@
1
+ # frozen_string_literal: true
2
+
3
+ module Nquery
4
+ class ApplicationService
5
+ def self.call(...)
6
+ new(...).call
7
+ end
8
+ end
9
+ end
@@ -0,0 +1,37 @@
1
+ # frozen_string_literal: true
2
+
3
+ module Nquery
4
+ module Dashboards
5
+ # Records which dashboard parameters apply to one chart.
6
+ class CardParameters < ApplicationService
7
+ def initialize(dashboard:, chart:, linked_names:)
8
+ @dashboard = dashboard
9
+ @chart = chart
10
+ @linked_names = Array(linked_names).map(&:to_s)
11
+ end
12
+
13
+ def call
14
+ @dashboard.update!(parameters: rewritten_parameters)
15
+ @dashboard
16
+ end
17
+
18
+ private
19
+
20
+ def rewritten_parameters
21
+ @dashboard.parameter_definitions.map do |row|
22
+ ids = current_chart_ids(row)
23
+ ids = if @linked_names.include?(row["name"])
24
+ ids | [@chart.id]
25
+ else
26
+ ids - [@chart.id]
27
+ end
28
+ row.merge("chart_ids" => ids)
29
+ end
30
+ end
31
+
32
+ def current_chart_ids(row)
33
+ @dashboard.linked_chart_ids(row)
34
+ end
35
+ end
36
+ end
37
+ end
@@ -0,0 +1,75 @@
1
+ # frozen_string_literal: true
2
+
3
+ module Nquery
4
+ module Dashboards
5
+ class Filters < ApplicationService
6
+ Result = Data.define(:filter_dashboard, :parameters)
7
+
8
+ def initialize(dashboard:, request_params:)
9
+ @dashboard = dashboard
10
+ @request_params = request_params
11
+ end
12
+
13
+ def call
14
+ source = filter_dashboard.with_agreed_chart_variables
15
+ Result.new(
16
+ filter_dashboard: source,
17
+ parameters: DashboardParameters.call(
18
+ dashboard: without_cleared_defaults(source),
19
+ token_params: {},
20
+ request_params: filter_values(source)
21
+ )
22
+ )
23
+ end
24
+
25
+ private
26
+
27
+ def filter_dashboard
28
+ return @dashboard unless @dashboard.errors.any?
29
+
30
+ Dashboard.find(@dashboard.id)
31
+ end
32
+
33
+ def without_cleared_defaults(source)
34
+ cleared = cleared_names(source)
35
+ return source if cleared.empty?
36
+
37
+ rows = source.parameter_definitions.map do |row|
38
+ cleared.include?(row["name"]) ? row.merge("default" => "") : row
39
+ end
40
+ copy = source.dup
41
+ copy.id = source.id
42
+ copy.parameters = rows
43
+ copy.readonly!
44
+ copy
45
+ end
46
+
47
+ def cleared_names(source)
48
+ submitted = permitted_params(source)
49
+ source.parameter_names.select { |name| submitted.key?(name) && submitted[name].to_s.strip.blank? }
50
+ end
51
+
52
+ def filter_values(source)
53
+ submitted = permitted_params(source)
54
+ source.parameter_definitions.each_with_object({}) do |row, values|
55
+ name = row["name"]
56
+ next if submitted.key?(name) && submitted[name].to_s.strip.blank?
57
+
58
+ text = submitted.key?(name) ? submitted[name].to_s.strip : row["default"].to_s.strip
59
+ values[name] = text if text.present?
60
+ end
61
+ end
62
+
63
+ def permitted_params(source)
64
+ return {} if source.parameter_names.empty?
65
+
66
+ raw = if @request_params.respond_to?(:permit)
67
+ @request_params.permit(*source.parameter_names)
68
+ else
69
+ @request_params.to_h
70
+ end
71
+ raw.stringify_keys
72
+ end
73
+ end
74
+ end
75
+ end