Merge pull request #6367 from martinpovolny/report_cleanup3

More report cleanup

Author: mzazrivec

app/controllers/application_controller/report_downloads.rb

@@ -3,69 +3,71 @@ module ApplicationController::ReportDownloads
 
   # Send the current report in text format
   def render_txt
-    @report = report_for_rendering
-    filename = filename_timestamp(@report.title)
+    report = report_for_rendering
+    filename = filename_timestamp(report.title)
     disable_client_cache
-    send_data(@report.to_text,
-              :filename => "#{filename}.txt")
+    send_data(report.to_text, :filename => "#{filename}.txt")
   end
 
   # Send the current report in csv format
   def render_csv
-    @report = report_for_rendering
+    report = report_for_rendering
     filename = filename_timestamp(@report.title)
     disable_client_cache
-    send_data(@report.to_csv,
-              :filename => "#{filename}.csv")
+    send_data(report.to_csv, :filename => "#{filename}.csv")
   end
 
-  # Send the current report in pdf format
-  def render_pdf(report = nil)
-    @report = report || report_for_rendering
+  def render_pdf_internal(report)
     userid = "#{session[:userid]}|#{request.session_options[:id]}|adhoc"
-    @result = @report.build_create_results(:userid => userid)
+    result = report.build_create_results(:userid => userid)
 
-    # Use @result frorm paging, if present
-    @result ||= MiqReportResult.for_user(current_user).find(@sb[:pages][:rr_id]) if @sb[:pages]
+    # Use result from paging, if present
+    result ||= MiqReportResult.for_user(current_user).find(@sb[:pages][:rr_id]) if @sb[:pages]
     # Use report_result_id in session, if present
-    @result ||= MiqReportResult.for_user(current_user).find(session[:report_result_id]) if session[:report_result_id]
+    result ||= MiqReportResult.for_user(current_user).find(session[:report_result_id]) if session[:report_result_id]
 
     disable_client_cache
 
-    @options = {
+    @options = { # used by the layouts/print
       :page_layout => 'landscape',
-      :page_size   => @report.page_size || 'a4',
-      :run_date    => format_timezone(@report.report_run_time, @result.user_timezone, "gtl"),
-      :title       => @result.name
+      :page_size   => report.page_size || 'a4',
+      :run_date    => format_timezone(report.report_run_time, result.user_timezone, "gtl"),
+      :title       => result.name
     }
 
-    @data = @result.html_rows.join
+    render(
+      :template => '/layouts/print/report',
+      :layout   => '/layouts/print',
+      :locals   => {
+        :report => report,
+        :data   => result.html_rows.join
+      }
+    )
+  end
 
-    render :template => '/layouts/print/report', :layout => '/layouts/print'
+  # Send the current report in pdf format
+  def render_pdf
+    render_pdf_internal(report_for_rendering)
   end
 
   # Show the current widget report in pdf format
   def widget_to_pdf
     session[:report_result_id] = params[:rr_id]
-    render_pdf
+    render_pdf_internal(report_from_report_results(params[:rr_id]))
   end
 
-  # Render report in csv/txt/pdf format asynchronously
-  def render_report_data
-    render_type = RENDER_TYPES[params[:render_type]]
-    assert_privileges("render_report_#{render_type}")
-    unless params[:task_id] # First time thru, kick off the report generate task
-      if render_type
-        @sb[:render_type] = render_type
-        rr = MiqReportResult.for_user(current_user).find(session[:report_result_id]) # Get report task id from the session
-        task_id = rr.async_generate_result(@sb[:render_type], :userid     => session[:userid],
-                                                              :session_id => request.session_options[:id])
-        initiate_wait_for_task(:task_id => task_id)
-      end
-      return
+  def render_report_data_init(render_type)
+    if render_type
+      @sb[:render_type] = render_type
+      rr = MiqReportResult.for_user(current_user).find(session[:report_result_id]) # Get report task id from the session
+      task_id = rr.async_generate_result(@sb[:render_type], :userid     => session[:userid],
+                                                            :session_id => request.session_options[:id])
+      initiate_wait_for_task(:task_id => task_id)
     end
+  end
 
-    miq_task = MiqTask.find(params[:task_id])
+  def render_report_data_continue(task_id)
+    miq_task = MiqTask.find(task_id)
     if !miq_task.results_ready?
       add_flash(_("Report generation returned: Status [%{status}] Message [%{message}]") % {:status => miq_task.status, :message => miq_task.message}, :error)
       javascript_flash(:spinner_off => true)
@@ -82,86 +84,112 @@ def render_report_data
       end
     end
   end
+
+  # Render report in csv/txt/pdf format asynchronously
+  def render_report_data
+    render_type = RENDER_TYPES[params[:render_type]]
+    assert_privileges("render_report_#{render_type}")
+
+    if params[:task_id]
+      # We are waiting for a task to finish.
+      render_report_data_continue(params[:task_id])
+    else
+      # First time thru, kick off the report generate task.
+      render_report_data_init(render_type)
+    end
+  end
   alias_method :render_report_txt, :render_report_data
   alias_method :render_report_csv, :render_report_data
   alias_method :render_report_pdf, :render_report_data
 
   # Send rendered report data
   def send_report_data
-    if @sb[:render_rr_id]
-      disable_client_cache
-      @result = MiqReportResult.find(@sb[:render_rr_id])
-      @report = @result.report
-      @data = @result.get_generated_result(@sb[:render_type])
-      # We need the last_run_on time from the original result
-      last_run_on = MiqReportResult.select(:last_run_on).find(session[:report_result_id]).last_run_on
-      @result.destroy
+    return unless @sb[:render_rr_id]
 
-      if @sb[:render_type] == :pdf
-        @options = {
-          :page_layout => 'landscape',
-          :page_size   => @report.page_size || 'a4',
-          :run_date    => format_timezone(last_run_on, @result.user_timezone, "gtl"),
-          :title       => @result.name
+    disable_client_cache
+    result = MiqReportResult.find(@sb[:render_rr_id])
+    report = result.report
+
+    ## THIS IS STRANGE
+    # We need the last_run_on time from the original result
+    last_run_on = MiqReportResult.select(:last_run_on).find(session[:report_result_id]).last_run_on
+
+    if @sb[:render_type] == :pdf
+      @options = { # needed by the /layouts/print
+        :page_layout => 'landscape',
+        :page_size   => report.page_size || 'a4',
+        :run_date    => format_timezone(last_run_on, result.user_timezone, "gtl"),
+        :title       => result.name
+      }
+      render(
+        :template => '/layouts/print/report',
+        :layout   => '/layouts/print',
+        :locals   => {
+          :report => report,
+          :data   => result.html_rows.join
         }
-        render :template => '/layouts/print/report', :layout => '/layouts/print'
-      else
-        filename = filename_timestamp(@result.report.title, 'export_filename')
-        send_data(@data,
-                  :filename => "#{filename}.#{@sb[:render_type]}",
-                  :type     => "application/#{@sb[:render_type]}")
-      end
+      )
+    else
+      filename = filename_timestamp(result.report.title, 'export_filename')
+      send_data(result.get_generated_result(@sb[:render_type]),
+                :filename => "#{filename}.#{@sb[:render_type]}",
+                :type     => "application/#{@sb[:render_type]}")
     end
+
+    result.destroy
   end
 
   # Download currently displayed view
   def download_data
-    @view = session[:view].dup if session[:view] # Copy session view, if it exists
+    view = session[:view].dup if session[:view] # Copy session view, if it exists
     options = session[:paged_view_search_options].merge(:page => nil, :per_page => nil) # Get all pages
-    @view.table, _attrs = @view.paged_view_search(options) # Get the records
+    view.table, _attrs = view.paged_view_search(options) # Get the records
 
-    @view.title = _(@view.title.pluralize)
-    @view.headers.map! { |header| _(header) }
+    view.title = _(view.title.pluralize)
+    view.headers.map! { |header| _(header) }
 
-    @filename = filename_timestamp(@view.title)
     case params[:download_type]
-    when "pdf"
-      download_pdf(@view)
-    when "text"
-      download_txt(@view)
-    when "csv"
-      download_csv(@view)
+    when 'pdf'  then download_pdf(view)
+    when 'text' then download_txt(view, filename_timestamp(view.title))
+    when 'csv'  then download_csv(view, filename_timestamp(view.title))
     end
   end
 
   private
 
   RENDER_TYPES = {'txt' => :txt, 'csv' => :csv, 'pdf' => :pdf}.freeze
 
-  def download_txt(view)
+  def download_txt(view, filename)
     disable_client_cache
-    send_data(view.to_text, :filename => "#{@filename}.txt")
+    send_data(view.to_text, :filename => "#{filename}.txt")
   end
 
-  def download_csv(view)
+  def download_csv(view, filename)
     disable_client_cache
-    send_data(view.to_csv, :filename => "#{@filename}.csv")
+    send_data(view.to_csv, :filename => "#{filename}.csv")
   end
 
   # Send the current report in pdf format
   def download_pdf(view)
-    render_pdf(view)
+    render_pdf_internal(view)
+  end
+
+  def report_from_task_id(task_id)
+    MiqTask.find(task_id).task_results
+  end
+
+  def report_from_report_results(report_result_id)
+    rr = MiqReportResult.for_user(current_user).find(report_result_id)
+    report = rr.report_results
+    report.report_run_time = rr.last_run_on
+    report
   end
 
   def report_for_rendering
     if session[:rpt_task_id]
-      miq_task = MiqTask.find(session[:rpt_task_id])
-      miq_task.task_results
+      report_from_task_id(session[:rpt_task_id])
     elsif session[:report_result_id]
-      rr = MiqReportResult.for_user(current_user).find(session[:report_result_id])
-      report = rr.report_results
-      report.report_run_time = rr.last_run_on
-      report
+      report_from_report_results(session[:report_result_id])
     end
   end
 

app/views/layouts/print/report.html.haml

@@ -1,9 +1,9 @@
 %table.table.table-striped.table-bordered.breakable
   %thead
     %tr
-      - @report.headers.each_with_index do |header, i|
-        - unless @report.column_is_hidden?(@report.col_order[i])
+      - report.headers.each_with_index do |header, i|
+        - unless report.column_is_hidden?(report.col_order[i])
           %th
             = h(_(header))
   %tbody
-    = @data.html_safe
+    = data.html_safe