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.
- checksums.yaml +4 -4
- data/CHANGELOG.md +17 -0
- data/app/assets/builds/nquery/application.css +88 -4
- data/app/assets/builds/nquery/application.js +353 -3
- data/app/controllers/concerns/nquery/chart_actions.rb +1 -1
- data/app/controllers/concerns/nquery/chart_results.rb +54 -7
- data/app/controllers/nquery/dashboard/cards_controller.rb +28 -0
- data/app/controllers/nquery/dashboards_controller.rb +49 -9
- data/app/controllers/nquery/embed/dashboards_controller.rb +17 -1
- data/app/controllers/nquery/public/dashboards_controller.rb +14 -1
- data/app/controllers/nquery/queries_controller.rb +23 -2
- data/app/models/nquery/chart.rb +4 -0
- data/app/models/nquery/dashboard.rb +129 -0
- data/app/models/nquery/query.rb +68 -0
- data/app/services/nquery/application_service.rb +9 -0
- data/app/services/nquery/dashboards/card_parameters.rb +37 -0
- data/app/services/nquery/dashboards/filters.rb +75 -0
- data/app/services/nquery/dashboards/parameter_charts.rb +31 -0
- data/app/services/nquery/dashboards/parameter_rows.rb +60 -0
- data/app/views/layouts/nquery/application.html.erb +8 -0
- data/app/views/nquery/charts/_builder_form.html.erb +12 -0
- data/app/views/nquery/charts/_variable_row.html.erb +10 -0
- data/app/views/nquery/charts/_variables.html.erb +28 -0
- data/app/views/nquery/charts/update.turbo_stream.erb +3 -0
- data/app/views/nquery/dashboards/_chart_card.html.erb +27 -1
- data/app/views/nquery/dashboards/_parameter_chart_ids.html.erb +6 -0
- data/app/views/nquery/dashboards/_parameters.html.erb +159 -0
- data/app/views/nquery/dashboards/edit.html.erb +10 -0
- data/app/views/nquery/dashboards/show.html.erb +37 -1
- data/app/views/nquery/shared/_icon.html.erb +4 -0
- data/app/views/nquery/shared/_sidebar.html.erb +1 -1
- data/app/views/nquery/shared/_topbar.html.erb +3 -0
- data/config/routes.rb +4 -0
- data/db/migrate/20261005145000_add_parameters_to_nquery_dashboards.rb +7 -0
- data/db/migrate/20261005190000_add_parameters_to_nquery_queries.rb +7 -0
- data/lib/nquery/dashboard_parameters.rb +56 -0
- data/lib/nquery/data_sources/adapter.rb +10 -1
- data/lib/nquery/data_sources/mysql_adapter.rb +2 -2
- data/lib/nquery/data_sources/postgresql_adapter.rb +2 -2
- data/lib/nquery/data_sources/rails_adapter.rb +2 -7
- data/lib/nquery/data_sources/row_limit.rb +211 -0
- data/lib/nquery/parameter_value.rb +97 -0
- data/lib/nquery/query_runner.rb +37 -4
- data/lib/nquery/seeder.rb +9 -1
- data/lib/nquery/statement_binds.rb +112 -0
- data/lib/nquery/version.rb +1 -1
- data/lib/nquery.rb +4 -0
- data/nquery.gemspec +2 -2
- 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
|
-
|
|
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
|
|
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
|
-
|
|
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
|
-
|
|
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(
|
|
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
|
|
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
|
-
|
|
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
|
data/app/models/nquery/chart.rb
CHANGED
|
@@ -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
|
data/app/models/nquery/query.rb
CHANGED
|
@@ -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,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
|