app/controllers/report_controller/widgets.rb
module ReportController::Widgets
extend ActiveSupport::Concern
RIGHT_CELL_TEXTS = {
"r" => [N_('Report Widgets'), N_('Report Widget "%{name}"')],
"c" => [N_('Chart Widgets'), N_('Chart Widget "%{name}"')],
"m" => [N_('Menu Widgets'), N_('Menu Widget "%{name}"')]
}.freeze
# Need this for mapping with MiqWidget record content_type field
WIDGET_CONTENT_TYPE = {
"r" => "report",
"c" => "chart",
"m" => "menu"
}.freeze
def widget_refresh
assert_privileges("widget_refresh")
replace_right_cell
end
def widget_copy
assert_privileges("widget_copy")
@widget = MiqWidget.new
@in_a_form = true
unless params[:id]
obj = find_checked_items
@_params[:id] = obj[0] unless obj.empty?
end
widget = find_record_with_rbac(MiqWidget, params[:id])
@widget.title = widget.title
@widget.description = widget.description
@widget.resource = widget.resource
@widget.miq_schedule = widget.miq_schedule # Need original sched to get options for copy
@widget.options = widget.options
@widget.visibility = widget.visibility
@widget.enabled = widget.enabled
@widget.content_type = widget.content_type
widget.miq_widget_shortcuts.each do |ws| # Need to make new widget_shortcuts to leave the originals alone
new_ws = MiqWidgetShortcut.new(:sequence => ws.sequence, :description => ws.description, :miq_shortcut_id => ws.miq_shortcut_id)
@widget.miq_widget_shortcuts.push(new_ws)
end
widget_set_form_vars
session[:changed] = false
replace_right_cell
end
def widget_new
assert_privileges("widget_new")
widget_edit
end
def widget_edit
assert_privileges("widget_edit")
case params[:button]
when "cancel"
@widget = MiqWidget.find(session[:edit][:widget_id]) if session[:edit] && session[:edit][:widget_id]
if !@widget || @widget.id.blank?
add_flash(_("Add of new Widget was cancelled by the user"))
else
add_flash(_("Edit of Widget \"%{title}\" was cancelled by the user") % {:title => @widget.title})
end
get_node_info
@widget = nil
@edit = session[:edit] = nil # clean out the saved info
replace_right_cell
when "add", "save"
assert_privileges("widget_#{params[:id] ? "edit" : "new"}")
id = params[:id] ? params[:id] : "new"
return unless load_edit("widget_edit__#{id}", "replace_cell__explorer")
widget_get_form_vars # get current record(@widget) of MiqWidget
widget_set_record_vars(@widget)
if widget_validate_entries && @widget.save_with_shortcuts(@edit[:new][:shortcuts].to_a)
AuditEvent.success(build_saved_audit(@widget, @edit))
add_flash(_("Widget \"%{title}\" was saved") % {:title => @widget.title})
params[:id] = @widget.id.to_s # reset id in params for show
# Build the filter expression and attach widget to schedule filter
exp = {}
exp["="] = {"field" => "MiqWidget-id", "value" => @widget.id}
@edit[:schedule].filter = MiqExpression.new(exp)
@edit[:schedule].save
@edit = session[:edit] = nil # clean out the saved info
# @schedule = nil
replace_right_cell(:replace_trees => [:widgets])
else
@widget.errors.each do |error|
add_flash("#{_(error.attribute.to_s.capitalize)} #{error.message}", :error)
end
@changed = session[:changed] = (@edit[:new] != @edit[:current])
javascript_flash
end
else
add_flash(_("All changes have been reset"), :warning) if params[:button] == "reset"
# Get existing or new record
@widget = params[:id] && params[:id] != "new" ? MiqWidget.find(params[:id]) : MiqWidget.new
widget_set_form_vars
session[:changed] = false
@in_a_form = true
replace_right_cell
end
end
# Delete all selected or single displayed action(s)
def widget_delete
assert_privileges("widget_delete")
widget = find_record_with_rbac(MiqWidget, params[:id])
process_elements(widget.id, MiqWidget, "destroy")
nodes = x_node.split('-')
self.x_node = "#{nodes[0]}-#{WIDGET_CONTENT_TYPE.invert[widget.content_type]}"
replace_right_cell(:replace_trees => [:widgets])
end
def widget_generate_content
assert_privileges("widget_generate_content")
w = MiqWidget.find(params[:id])
begin
w.queue_generate_content
rescue => bang
add_flash(_("Widget content generation error: %{message}") % {:message => bang.message}, :error)
else
add_flash(_("Content generation for this Widget has been initiated"))
end
# refresh widget show to update buttons
widget_refresh
end
def feature_for_widget_action
@edit && @edit[:widget_id] ? "widget_edit" : "widget_new"
end
# AJAX driven routine to check for changes in ANY field on the form
def widget_form_field_changed
assert_privileges(feature_for_widget_action)
return unless load_edit("widget_edit__#{params[:id]}", "replace_cell__explorer")
widget_get_form_vars
render :update do |page|
page << javascript_prologue
if params[:filter_typ]
@edit[:new][:subfilter] = nil
@edit[:new][:repfilter] = @reps = nil
@replace_filter_div = true
elsif params[:subfilter_typ]
@edit[:new][:repfilter] = nil
@replace_filter_div = true
elsif params[:repfilter_typ] || params[:chosen_pivot1] || params[:chosen_pivot2] || params[:chosen_pivot3] ||
params[:feed_type]
@replace_filter_div = true
end
if @replace_filter_div
page.replace("form_filter_div", :partial => "widget_form_filter")
page << "miqInitDashboardCols();"
end
if params[:visibility_typ]
page.replace("form_role_visibility", :partial => "layouts/role_visibility", :locals => {:rec_id => (@widget.id || "new").to_s, :action => "widget_form_field_changed"})
end
javascript_for_timer_type(params[:timer_typ]).each { |js| page << js }
if params[:time_zone]
page << "ManageIQ.calendar.calDateFrom = new Date(#{(Time.zone.now - 1.month).in_time_zone(@edit[:tz]).strftime("%Y, %m, %d")});"
page << "miqBuildCalendar();"
page << "$('#miq_date_1').val('#{@edit[:new][:timer].start_date}');"
page << "$('#start_hour').val('#{@edit[:new][:timer].start_hour.to_i}');"
page << "$('#start_min').val('#{@edit[:new][:timer].start_min.to_i}');"
page.replace_html("tz_span", @timezone_abbr)
end
changed = (@edit[:new] != @edit[:current])
page << javascript_for_miq_button_visibility(changed)
page << "miqSparkle(false);"
end
end
# Shortcut was dropped, reorder the :shortcuts hash
def widget_shortcut_dd_done
assert_privileges(feature_for_widget_action)
new_hash = {}
params[:col1].each { |sc| new_hash[sc.to_i] = @edit[:new][:shortcuts][sc.to_i] }
@edit[:new][:shortcuts] = new_hash
@edit[:new][:shortcut_keys] = @edit[:new][:shortcuts].keys # Save the keys array so we can compare the hash order
render :update do |page|
page << javascript_prologue
changed = (@edit[:new] != @edit[:current])
page << javascript_for_miq_button_visibility(changed)
end
end
# Shortcut was removed
def widget_shortcut_remove
assert_privileges(feature_for_widget_action)
return unless load_edit("widget_edit__#{params[:id]}", "replace_cell__explorer")
@widget = @edit[:widget_id] ? MiqWidget.find(@edit[:widget_id]) : MiqWidget.new
@edit[:new][:shortcuts].delete(params[:shortcut].to_i)
@edit[:new][:shortcut_keys] = @edit[:new][:shortcuts].keys # Save the keys array so we can compare the hash order
@edit[:avail_shortcuts] = widget_build_avail_shortcuts
render :update do |page|
page << javascript_prologue
page.replace("form_filter_div", :partial => "widget_form_filter")
page << "miqInitDashboardCols();"
changed = (@edit[:new] != @edit[:current])
page << javascript_for_miq_button_visibility(changed)
page << "miqSparkle(false);"
end
end
# Shortcut text reset
def widget_shortcut_reset
assert_privileges(feature_for_widget_action)
return unless load_edit("widget_edit__#{params[:id]}", "replace_cell__explorer")
@widget = @edit[:widget_id] ? MiqWidget.find(@edit[:widget_id]) : MiqWidget.new
@edit[:new][:shortcuts][params[:shortcut].to_i] = MiqShortcut.find(params[:shortcut].to_i).description
render :update do |page|
page << javascript_prologue
page.replace("form_filter_div", :partial => "widget_form_filter")
page << "miqInitDashboardCols();"
changed = (@edit[:new] != @edit[:current])
page << javascript_for_miq_button_visibility(changed)
page << "miqSparkle(false);"
end
end
def get_all_widgets(nodeid = nil, rep_id = nil)
@force_no_grid_xml = true
@no_checkboxes = @showlinks = true if x_active_tree != "report"
# @embedded = true
if params[:ppsetting] # User selected new per page value
@items_per_page = params[:ppsetting].to_i # Set the new per page value
@settings.store_path(:perpage, :list, @items_per_page) # Set the per page setting for this gtl type
end
@sortcol = session["#{x_active_tree}_sortcol".to_sym].nil? ? 0 : session["#{x_active_tree}_sortcol".to_sym].to_i
@sortdir = session["#{x_active_tree}_sortdir".to_sym].nil? ? "DESC" : session["#{x_active_tree}_sortdir".to_sym]
if nodeid.nil? && rep_id.nil?
# show all widgets
@view, @pages = get_view(MiqWidget, :association => "all")
elsif !rep_id
# show only specific type
@view, @pages = get_view(MiqWidget, :named_scope => [[:with_content_type, nodeid]])
else
# get all widgets for passed in report id
@widget_nodes = MiqWidget.where(:content_type => "report", :resource_id => rep_id)
end
if x_active_tree == :widgets_tree
# dont need to set these for report show screen
@right_cell_div = "widget_list"
@right_cell_text ||= _("All Widgets")
end
@current_page = @pages[:current] unless @pages.nil? # save the current page number
session["#{x_active_tree}_sortcol".to_sym] = @sortcol
session["#{x_active_tree}_sortdir".to_sym] = @sortdir
end
private
def widget_get_node_info
@sb[:nodes] = x_node.split('-')
if @sb[:nodes].length == 1
get_all_widgets
@right_cell_text = _("All Widgets")
@right_cell_div = "widget_list"
elsif @sb[:nodes].length == 2
# If a folder node is selected
get_all_widgets(WIDGET_CONTENT_TYPE[@sb[:nodes][1]])
@right_cell_div = "widget_list"
@right_cell_text = _(RIGHT_CELL_TEXTS[@sb[:nodes][1]].first)
else
@record = @widget = MiqWidget.find(@sb[:nodes].last)
params[:text] = @widget.name unless params[:text].present?
@widget_running = true if %w[running queued].include?(@widget.status.downcase)
@right_cell_text = _(RIGHT_CELL_TEXTS[WIDGET_CONTENT_TYPE.invert[@widget.content_type]].second) % {:name => @widget.title}
@right_cell_div = "widget_list"
@sb[:wtype] = WIDGET_CONTENT_TYPE.invert[@widget.content_type]
@sb[:col_order] = []
rep = @widget.resource
if rep && @widget.options && @widget.options[:col_order]
@widget.options[:col_order].each do |c|
rep.col_order.each_with_index do |col, idx|
if col == c
@sb[:col_order].push(rep.headers[idx]) unless @sb[:col_order].include?(rep.headers[idx])
end
end
end
end
if @widget.visibility && @widget.visibility[:roles]
@sb[:user_roles] = []
if @widget.visibility[:roles][0] != "_ALL_"
Rbac.filtered(MiqUserRole).sort_by(&:name).each do |r|
@sb[:user_roles].push(r.name) if @widget.visibility[:roles].include?(r.name)
end
end
elsif @widget.visibility && @widget.visibility[:groups]
@sb[:groups] = []
Rbac.filtered(MiqGroup.non_tenant_groups_in_my_region).sort_by(&:description).each do |r|
@sb[:groups].push(r.description) if @widget.visibility[:groups].include?(r.description)
end
end
end
end
def widget_set_form_vars
@timezone_abbr = get_timezone_abbr
@edit = {}
@edit[:widget_id] = @widget.id
@edit[:read_only] = !!@widget.read_only
# Remember how this edit started
@edit[:type] = @widget.id ? "widget_edit" : "widget_new"
@sb[:wtype] = if !@edit[:widget_id] && params[:pressed] != "widget_copy"
@sb[:nodes][1]
else
WIDGET_CONTENT_TYPE.invert[@widget.content_type]
end
@edit[:key] = @widget.id ? "widget_edit__#{@widget.id}" : "widget_edit__new"
@edit[:new] = {}
@edit[:new][:title] = @widget.title
@edit[:new][:description] = @widget.description
@edit[:new][:enabled] = @widget.enabled
@edit[:new][:roles] = [] # initializing incase of new widget since visibility is not set yet.
@edit[:new][:groups] = [] # initializing incase of new widget since visibility is not set yet.
@edit[:visibility_types] = [[_("<To All Users>"), "all"], [_("<By Role>"), "role"], [_("<By Group>"), "group"]]
# Visibility Box
if @widget.visibility
if @widget.visibility[:roles]
@edit[:new][:visibility_typ] = @widget.visibility[:roles][0] == "_ALL_" ? "all" : "role"
if @widget.visibility[:roles][0] == "_ALL_"
@edit[:new][:roles] = ["_ALL_"]
else
roles = Rbac.filtered(MiqUserRole.where(:name => @widget.visibility[:roles]))
@edit[:new][:roles] = roles.collect(&:id).sort
end
elsif @widget.visibility[:groups]
@edit[:new][:visibility_typ] = "group"
groups = Rbac.filtered(MiqGroup.in_my_region.where(:description => @widget.visibility[:groups]))
@edit[:new][:groups] = groups.collect(&:id).sort
end
end
@edit[:sorted_user_roles] =
Rbac.filtered(MiqUserRole).sort_by { |r| r.name.downcase }
.collect { |r| {r.name => r.id} }
@edit[:sorted_groups] =
Rbac.filtered(MiqGroup.non_tenant_groups_in_my_region).sort_by { |g| g.description.downcase }
.collect { |g| {g.description => g.id} }
# Schedule Box - create new sched for copy/new, use existing for edit
@edit[:schedule] = if @widget.id && @widget.miq_schedule.present?
find_record_with_rbac(MiqSchedule, @widget.miq_schedule.id)
else
MiqSchedule.new
end
if @widget.resource_id && @widget.resource_type == "MiqReport"
@edit[:schedule].name = @widget.resource.name
@edit[:schedule].description = @widget.resource.title
@edit[:rpt] = MiqReport.find(@widget.resource_id)
@menu = get_reports_menu
if @sb[:wtype] == "r"
@menu.each do |m|
m[1].each do |f|
f.each do |r|
next if r.class == String
r.each do |rep|
next if rep != @edit[:rpt].name
@edit[:new][:filter] = m[0]
@edit[:new][:subfilter] = f[0]
end
end
end
end
report_selection_menus # to build sub folders
else
widget_graph_menus # to build report pulldown with only reports with graphs
end
@edit[:new][:repfilter] = @edit[:rpt].id
elsif %w[r c].include?(@sb[:wtype])
@menu = get_reports_menu
if @sb[:nodes][1] == "c"
widget_graph_menus # to build report pulldown with only reports with graphs
else
report_selection_menus # to build sub folders
end
elsif ["m"].include?(@sb[:wtype])
@edit[:new][:shortcuts] = {}
@widget.miq_widget_shortcuts.sort_by(&:sequence).each do |ws|
@edit[:new][:shortcuts][ws.miq_shortcut.id] = ws.description
end
@edit[:new][:shortcut_keys] = @edit[:new][:shortcuts].keys # Save the keys array so we can compare the hash order
@edit[:avail_shortcuts] = widget_build_avail_shortcuts
end
@edit[:new][:timer] = ReportHelper::Timer.new
if @edit[:schedule].run_at.nil? # New widget or schedule missing, default sched options
@edit[:tz] = session[:user_tz]
t = Time.now.in_time_zone(@edit[:tz]) + 1.day # Default date/time to tomorrow in selected time zone
@edit[:new][:timer].typ = 'Hourly'
@edit[:new][:timer].start_date = "#{t.month}/#{t.day}/#{t.year}"
else
sched = params[:action] == "widget_copy" ? @widget.miq_schedule : @edit[:schedule]
@edit[:tz] = sched.run_at && sched.run_at[:tz] ? sched.run_at[:tz] : session[:user_tz]
@edit[:new][:timer].update_from_miq_schedule(sched.run_at, @edit[:tz])
end
if @sb[:wtype] == "r"
@pivot = @edit[:new][:pivot] = ReportController::PivotOptions.new
rpt = @widget.resource_id && @widget.resource_type == "MiqReport" ? @widget.resource_id : nil
widget_set_column_vars(rpt)
@edit[:new][:pivot].by1 = @widget.options[:col_order][0] if @widget.options && @widget.options[:col_order] && @widget.options[:col_order][0]
@edit[:new][:pivot].by2 = @widget.options[:col_order][1] if @widget.options && @widget.options[:col_order] && @widget.options[:col_order][1]
@edit[:new][:pivot].by3 = @widget.options[:col_order][2] if @widget.options && @widget.options[:col_order] && @widget.options[:col_order][2]
@edit[:new][:pivot].by4 = @widget.options[:col_order][3] if @widget.options && @widget.options[:col_order] && @widget.options[:col_order][3]
@edit[:new][:pivot].options = @edit[:new][:fields].dup
@edit[:new][:row_count] = @widget.row_count
end
@edit[:current] = copy_hash(@edit[:new])
end
def widget_build_avail_shortcuts
as = MiqShortcut.order("sequence").collect { |s| [s.description, s.id] }
@edit[:new][:shortcuts].each_key { |ns| as.delete_if { |a| a.last == ns } }
as
end
def widget_set_column_vars(rpt)
if rpt
# Build group chooser arrays
@edit[:rpt] = MiqReport.find(rpt)
widget_build_selected_fields(@edit[:rpt])
else
@edit[:new][:fields] = []
end
end
def widget_graph_menus
@menu.each do |r|
r[1].each do |subfolder, reps|
subfolder.each_line do |s|
@reps ||= []
reps.each do |rep|
rec = MiqReport.find_by(:name => rep.strip)
next unless rec&.graph # dont need to add rpt with no graph for widget editor, chart options box
temp_arr = ["#{r[0]}/#{s}/#{rep}", rec.id]
@reps.push(temp_arr) unless @reps.include?(temp_arr)
end
end
end
end
end
# Build the fields array and headers hash from the rpt record cols and includes hashes
def widget_build_selected_fields(rpt)
fields = []
rpt.col_order.each_with_index do |col, idx|
field_key = col
field_value = rpt.headers[idx]
fields.push([field_value, field_key]) # Add to fields array
end
@edit[:new][:fields] = fields
end
# Get variables from edit form
def widget_get_form_vars
@widget = @edit[:widget_id] ? MiqWidget.find(@edit[:widget_id]) : MiqWidget.new
copy_params_if_set(@edit[:new], params, %i[title description])
@edit[:new][:filter] = params[:filter_typ] if params[:filter_typ]
@edit[:new][:enabled] = (params[:enabled] == "1") if params[:enabled]
# report/chart/menu options box
@edit[:new][:row_count] = @widget.row_count(params[:row_count]) if params[:row_count]
if @sb[:wtype] == "r"
if params[:filter_typ] || params[:subfilter_typ] || params[:repfilter_typ]
# reset columns if report has changed
@pivot = @edit[:new][:pivot] = ReportController::PivotOptions.new
end
@edit[:new][:subfilter] = params[:subfilter_typ] if params[:subfilter_typ]
if params[:repfilter_typ] && params[:repfilter_typ] != "<Choose>"
@edit[:rpt] = MiqReport.for_user(current_user).find(params[:repfilter_typ].to_i)
@edit[:new][:repfilter] = @edit[:rpt].id
elsif params[:repfilter_typ] && params[:repfilter_typ] == "<Choose>"
@edit[:new][:repfilter] = nil
end
@edit[:new][:filter] = "" if @edit[:new][:filter] == "<Choose>"
@edit[:new][:subfilter] = "" if @edit[:new][:subfilter] == "<Choose>"
elsif @sb[:wtype] == "c"
if params[:repfilter_typ] && params[:repfilter_typ] != "<Choose>"
@edit[:rpt] = MiqReport.for_user(current_user).find(params[:repfilter_typ].to_i)
@edit[:new][:repfilter] = @edit[:rpt].id
end
@edit[:new][:repfilter] = "" if params[:repfilter_typ] == "<Choose>"
elsif @sb[:wtype] == "m"
if params[:add_shortcut]
s = MiqShortcut.find(params[:add_shortcut].to_i)
@edit[:avail_shortcuts].delete_if { |as| as.last == s.id }
@edit[:new][:shortcuts][s.id] = s.description
@edit[:new][:shortcut_keys] = @edit[:new][:shortcuts].keys # Save the keys array so we can compare the hash order
@replace_filter_div = true
end
params.each do |k, v|
if k.to_s.starts_with?("shortcut_desc_")
sc_id = k.split("_").last.to_i
@edit[:new][:shortcuts][sc_id] = v
end
end
end
# Schedule settings box
@edit[:new][:timer] ||= ReportHelper::Timer.new
@edit[:new][:timer].update_from_hash(params)
if params[:time_zone]
@edit[:tz] = params[:time_zone]
@timezone_abbr = Time.now.in_time_zone(@edit[:tz]).strftime("%Z")
end
if @sb[:wtype] == "r"
# Look at the pivot group field selectors
@edit[:new][:pivot].update(params)
if @edit[:new][:filter]
@folders ||= []
report_selection_menus # to build sub folders
rpt = if @edit[:new][:repfilter]
@edit[:new][:repfilter]
elsif @widget.resource_id && @widget.resource_type == "MiqReport"
@widget.resource_id
end
widget_set_column_vars(rpt)
end
@edit[:new][:pivot].options = @edit[:new][:fields].dup
@pivot = @edit[:new][:pivot]
elsif @sb[:wtype] == "c"
widget_graph_menus # to build report pulldown with only reports with graphs
end
visibility_box_edit
end
# Set record variables to new values
def widget_set_record_vars(widget)
widget.title = @edit[:new][:title]
widget.description = @edit[:new][:description]
widget.enabled = @edit[:new][:enabled]
widget.options ||= {}
widget.options[:row_count] = widget.row_count(@edit[:new][:row_count]) if %w[r rf].include?(@sb[:wtype])
if @sb[:wtype] == "rf"
else
widget.resource = @edit[:rpt]
end
widget.options[:col_order] = [] if @edit[:new][:pivot]
@edit[:new][:pivot] ||= ReportController::PivotOptions.new
widget.options[:col_order].push(@edit[:new][:pivot].by1) if @edit[:new][:pivot].by1.present? && @edit[:new][:pivot].by1 != ReportHelper::NOTHING_STRING
widget.options[:col_order].push(@edit[:new][:pivot].by2) if @edit[:new][:pivot].by2.present? && @edit[:new][:pivot].by2 != ReportHelper::NOTHING_STRING
widget.options[:col_order].push(@edit[:new][:pivot].by3) if @edit[:new][:pivot].by3.present? && @edit[:new][:pivot].by3 != ReportHelper::NOTHING_STRING
widget.options[:col_order].push(@edit[:new][:pivot].by4) if @edit[:new][:pivot].by4.present? && @edit[:new][:pivot].by4 != ReportHelper::NOTHING_STRING
widget.content_type = WIDGET_CONTENT_TYPE[@sb[:wtype]]
widget.visibility ||= {}
if @edit[:new][:visibility_typ] == "group"
groups = []
@edit[:new][:groups].each do |g|
group = MiqGroup.find(g)
groups.push(group.description) if g == group.id.to_s
end
widget.visibility[:groups] = groups
widget.visibility.delete(:roles) if widget.visibility[:roles]
else
if @edit[:new][:visibility_typ] == "role"
roles = []
@edit[:new][:roles].each do |r|
role = MiqUserRole.find(r)
roles.push(role.name) if r == role.id.to_s
end
widget.visibility[:roles] = roles
else
widget.visibility[:roles] = ["_ALL_"]
end
widget.visibility.delete(:groups) if widget.visibility[:groups]
end
# schedule settings
@edit[:schedule].name = widget.title
@edit[:schedule].description = widget.description
@edit[:schedule].resource_type = "MiqWidget"
@edit[:schedule].sched_action = {:method => "generate_widget"}
@edit[:schedule].run_at = @edit[:new][:timer].flush_to_miq_schedule(@edit[:schedule].run_at, @edit[:tz])
widget.miq_schedule = @edit[:schedule]
end
# Validate widget entries before updating record
def widget_validate_entries
if %w[r c].include?(@sb[:wtype]) && (!@edit[:new][:repfilter] || @edit[:new][:repfilter] == "")
add_flash(_("A Report must be selected"), :error)
end
if %w[role group].include?(@edit[:new][:visibility_typ])
typ = @edit[:new][:visibility_typ]
if @edit[:new][typ.pluralize.to_sym].blank?
add_flash(_("A %{type} must be selected") % {:type => typ.titleize}, :error)
end
end
if @sb[:wtype] == "r" && @edit[:new][:pivot].by1 == ReportHelper::NOTHING_STRING
add_flash(_("At least one Column must be selected"), :error)
end
if @sb[:wtype] == "m"
if @edit[:new][:shortcuts].empty?
add_flash(_("At least one Shortcut must be selected"), :error)
else
@edit[:new][:shortcuts].each do |s|
if s.last.blank?
add_flash(_("Shortcut description is required"), :error)
end
end
end
end
if @widget.try(:read_only)
t = _('Trying to change a read-only widget')
%i[title description resource_id resource_type].each do |field|
add_flash(t, :error) if @widget.send("#{field}_changed?")
end
add_flash(t, :error) if @widget.options[:col_order] != @widget.options_was[:col_order]
end
@flash_array.nil?
end
end