daily 0.0.2

data/app/controllers/application_controller.rb

@@ -0,0 +1,14 @@
+class ApplicationController < ActionController::Base
+  protect_from_forgery
+  before_filter :set_current_user
+  
+  protected
+  
+  def set_current_user
+    Authorization.current_user = current_user
+  end
+  
+  def permission_denied
+    render :file => "public/404.html", :status => 404, :layout => false
+  end
+end

data/app/controllers/files_controller.rb

@@ -0,0 +1,5 @@
+class FilesController < ApplicationController
+  def show
+    send_file Rails.root.join("files/#{params[:path]}")
+  end
+end

data/app/controllers/main_controller.rb

@@ -0,0 +1,5 @@
+class MainController < ApplicationController
+  def home
+    redirect_to root_url unless current_user
+  end
+end

data/app/controllers/reports_controller.rb

@@ -0,0 +1,35 @@
+class ReportsController < InheritedResources::Base
+  nested_belongs_to :table, :optional => true
+  filter_resource_access :nested_in => :table, :additional_member => :generate
+  
+  def create
+    build_resource.user = current_user
+    create! do |success, failure|
+      success.all { redirect_to table_report_path(@report.table, @report)}
+      failure.all { render :new }
+    end
+  end
+  
+  def update
+    update! do |success, failure|
+      success.all { redirect_to table_report_path(@report.table, @report)}
+      failure.all { render :edit }
+    end
+  end
+  
+  def generate
+    @report.queue_now!
+    redirect_to table_report_path(@report.table, @report)
+  end
+  
+  protected
+  
+  # methods to make declarative_authorization allow optional table
+  def load_table
+    @table ||= load_parent_controller_object(:table) if params[:table_id]
+    @table  # loaded by inherited_resources if there
+  end
+  def new_report_for_collection
+    @report ||= @table ? new_controller_object_for_collection : Report.new
+  end
+end

data/app/controllers/tables_controller.rb

@@ -0,0 +1,20 @@
+class TablesController < InheritedResources::Base
+  filter_resource_access
+
+  def create
+    build_resource.user = current_user
+    build_resource.data_type = "sql"
+    create!
+  end
+  
+  def update
+    update!
+  end
+
+  def show
+    show! do
+      @test_html = @table.test if params[:test]
+    end
+  end
+
+end

data/app/controllers/users_controller.rb

@@ -0,0 +1,28 @@
+class UsersController < InheritedResources::Base
+  before_filter :user_from_current, :only => :edit
+  filter_resource_access
+  
+  def update
+    params[:user][:password] = nil if params[:user][:password].blank?
+    
+    update! do |success, failure|
+      success.all { redirect_after_update }
+      failure.all { render :edit }
+    end
+  end
+  
+  protected
+  def user_from_current
+    params[:id] ||= (current_user.try(:id) || 0)
+  end
+  def redirect_after_update
+    if @user == current_user
+      sign_in @user, :bypass => true
+      redirect_to user_root_path
+    elsif permitted_to? :show, @user
+      redirect_to user_path(@user)
+    else
+      redirect_to user_root_path
+    end
+  end
+end

data/app/formatters/html_formatter.rb

@@ -0,0 +1,65 @@
+# monkey patching HTML formatter to be safe
+
+module Ruport
+  class Formatter::HTML < Formatter    
+    
+    def safe(val)
+      out = ERB::Util.html_escape(val.to_s)
+      out.gsub("&amp;nbsp;", "&nbsp;")
+    end
+    
+    def safe_join(array, sep)
+      safe_array = array.collect{ |a| safe(a) }
+      safe_array.join(sep)
+    end
+
+    # Generates table headers based on the column names of your Data::Table.  
+    #
+    # This method does not do anything if options.show_table_headers is false
+    # or the Data::Table has no column names.
+    def build_table_header
+      output << "\t<table>\n"
+      unless data.column_names.empty? || !options.show_table_headers
+        output << "\t\t<tr>\n\t\t\t<th>" + 
+          safe_join(data.column_names, "</th>\n\t\t\t<th>") + 
+          "</th>\n\t\t</tr>\n"
+      end
+    end
+    
+    # Renders individual rows for the table.
+    def build_row(data = self.data)
+      output <<
+        "\t\t<tr>\n\t\t\t<td>" +
+        safe_join(data.to_a, "</td>\n\t\t\t<td>") +
+        "</td>\n\t\t</tr>\n"
+    end
+
+    # Renders the header for a group using the group name.
+    #
+    def build_group_header
+      output << "\t<p>#{safe(data.name)}</p>\n"
+    end
+    
+    private
+    
+    def render_justified_grouping
+      output << "\t<table>\n\t\t<tr>\n\t\t\t<th>" +
+        "#{safe(data.grouped_by)}</th>\n\t\t\t<th>" +
+        safe_join(grouping_columns, "</th>\n\t\t\t<th>") + 
+        "</th>\n\t\t</tr>\n"
+      data.each do |name, group|                     
+        group.each_with_index do |row, i|
+          output << "\t\t<tr>\n\t\t\t"
+          if i == 0
+            output << "<td class=\"groupName\">#{safe(name)}</td>\n\t\t\t<td>"
+          else
+            output << "<td>&nbsp;</td>\n\t\t\t<td>"
+          end
+          output << safe_join(row.to_a, "</td>\n\t\t\t<td>") +
+            "</td>\n\t\t</tr>\n"
+        end
+      end
+      output << "\t</table>\n"
+    end
+  end
+end

data/app/formatters/json_formatter.rb

@@ -0,0 +1,81 @@
+module Ruport
+  class Formatter::JSON < Formatter
+    renders :json, :for => [ Ruport::Controller::Row, Ruport::Controller::Table,
+                             Ruport::Controller::Group, Ruport::Controller::Grouping ]
+
+    # Hook for setting available options using a template. See the template 
+    # documentation for the available options and their format.
+    def apply_template
+      apply_table_format_template(template.table)
+      apply_grouping_format_template(template.grouping)
+    end
+
+    # Start the JSON
+    #
+    def build_table_header
+      output << "[\n"
+    end
+  
+    # Uses the Row controller to build up the table body.
+    #
+    def build_table_body
+      data.each_with_index do |row, i|
+        output << ",\n" if i > 0 
+        build_row(row)
+      end
+      output << "\n"
+    end
+
+    # End the JSON
+    def build_table_footer
+      output << "]"
+    end
+
+    # Renders individual rows for the table.
+    #
+    def build_row(data = self.data)
+      values = data.to_a
+      keys = self.data.column_names.to_a
+      hash = {}
+      values.each_with_index do |val, i|
+        key = (keys[i] || i).to_s
+        hash[key] = val
+      end
+      line = hash.to_json.to_s
+      output << "  #{line}"
+    end
+
+    # Renders the header for a group using the group name.
+    #
+    def build_group_header
+      output << "  \"#{data.name}\":"
+    end
+
+    # Creates the group body. Since group data is a table, just uses the
+    # Table controller.
+    #
+    def build_group_body
+      render_table data, options.to_hash
+    end
+
+    # Generates the body for a grouping. Iterates through the groups and
+    # renders them using the group controller.
+    #
+    def build_grouping_body
+      arr = []
+      data.each do |_,group|                     
+        arr << render_group(group, options)
+      end
+      output << arr.join(",\n")
+    end
+
+    private
+
+    def apply_table_format_template(t)
+    end
+  
+    def apply_grouping_format_template(t)
+    end
+
+  end
+end

data/app/helpers/application_helper.rb

@@ -0,0 +1,85 @@
+module ApplicationHelper
+  def title(text)
+    @title = text
+  end
+  
+  def page_title
+    @title || "Daily"
+  end
+  
+  def header_title
+    @title
+  end
+  
+  def seconds_sentence(time)
+    return "Running now..." if time < 0
+    return "Less than a second" if time == 0
+    return "1 second" if time == 1
+    "#{time} seconds"
+  end
+  
+  def display_time(time)
+    seconds = Time.now.to_i - time.to_i
+    
+    if seconds.abs < 10
+      out = "Now"
+    elsif seconds > 0
+      out = "#{time_ago_in_words(time)} ago"
+    else
+      out = "#{time_ago_in_words(time)} from now"
+    end
+    out += " (#{time.strftime("%T %Z")})"
+  end
+  
+  def report_time_run(report)
+    return "Unknown" if report.generate_started_at.nil?
+    return "Unknown" if report.generate_ended_at.nil?
+    
+    time = report.generate_ended_at.to_i - report.generate_started_at.to_i
+    seconds_sentence(time)
+  end
+  
+  def report_time_next(report)
+    job = report.next_job
+    return "Not scheduled" if job.nil?
+    return "Running now..." if job.locked_at.present?
+    display_time(job.run_at)
+  end
+  
+  def report_time_ago(report)
+    return "None" unless report.file_exists?
+    return "Unknown" if report.generate_ended_at.nil?
+    display_time(report.generate_ended_at)
+  end
+  
+  def table_time_run(table)
+    return "Unknown" if table.fetch_time_in_seconds.nil?
+    seconds_sentence(table.fetch_time_in_seconds)
+  end
+  
+  def report_error_html(report)
+    report.jobs.each do |job|
+      if job.last_error 
+        msg = job.last_error.gsub("\\n", "\n")
+        msg = msg.split("\n").first unless Rails.env.development?
+        return simple_format(msg)
+      end
+    end
+    ""
+  end
+  
+  def formatter_display(object)
+    out  = "<hr/>".html_safe 
+    out += content_tag(:p, "Formatter: " + object.formatter.to_s)
+    out += simple_format(h(JSON.pretty_generate(object.formatter_data)).gsub(" ", "&nbsp;")) unless object.formatter_data.blank?
+    out.html_safe
+  end
+  
+  def transform_display(object)
+    return "" if object.transform.blank?
+    out  = "<hr/>".html_safe 
+    out += content_tag(:p, "Transform: " + object.transform.constantize.display_name)
+    out += simple_format(h(JSON.pretty_generate(object.transform_data)).gsub(" ", "&nbsp;")) unless object.transform_data.blank?
+    out.html_safe
+  end
+end

data/app/jobs/generate_report_job.rb

@@ -0,0 +1,13 @@
+class GenerateReportJob < Struct.new(:report_id, :requeue)
+
+  def report
+    @report ||= Report.find_by_id(report_id)
+  end
+
+  def perform
+    return if report.nil?
+    report.generate!
+    report.queue_next! if requeue
+  end
+
+end

data/app/models/report.rb

@@ -0,0 +1,112 @@
+class Report < ActiveRecord::Base
+  include SharedBehaviors
+  belongs_to :user
+  belongs_to :table
+  has_many :jobs, :class_name => "::Delayed::Job"
+  
+  has_data :formatter
+  
+  generate_guid :filename
+  
+  validates_presence_of :user
+  validates_presence_of :table
+  validates_unique_presence_of :name
+  validates_stripped_presence_of :formatter
+
+  before_validation :filename_extension_update
+
+  after_save :ensure_job
+  after_save :queue_now!, :if => :filename_changed?
+  
+  def self.formatters
+    Ruport::Controller::Table.formats.keys
+  end
+  
+  def parent
+    "files/#{table.guid}"
+  end
+
+  def localdir
+    "#{Rails.root}/#{parent}"
+  end
+  
+  def localfile
+    "#{localdir}/#{filename}"
+  end
+  
+  def url(root)
+    root += "/" unless root[-1, 1] == "/"
+    "#{root}#{parent}/#{filename}"
+  end
+  
+  def file_exists?
+    File.file?(localfile)
+  end
+  
+  def generate!
+    Dir.mkdir(localdir) unless File.directory?(localdir)
+    touch(:generate_started_at)
+    data = table.result
+    data = apply_transform(data)
+    val = save_as!(data, localfile)
+    touch(:generate_ended_at)
+    val
+  end
+  
+  def save_as!(data, path)
+    tempfile = "#{Rails.root}/process/#{Time.now.to_i}_#{rand(9999999)}_#{rand(9999999)}.tmp"
+    return false unless data.as(formatter.to_sym, (formatter_data || {}).merge(:file => tempfile))
+    return false unless File.file?(tempfile)
+    File.rename(tempfile, path)
+    File.file?(path)
+  end
+  
+  def queue_next!
+    job = GenerateReportJob.new(id, true)
+    Delayed::Job.enqueue :payload_object => job, 
+                         :priority => 10,
+                         :run_at => calculate_next_gen_time,
+                         :report_id => id
+  end
+
+  def queue_now!
+    job = GenerateReportJob.new(id, false)
+    Delayed::Job.enqueue :payload_object => job, 
+                         :priority => 0,
+                         :report_id => id
+  end
+  
+  def next_job
+    jobs.by_priority.first
+  end
+
+  protected
+
+  def guid_append
+    return "" if formatter.blank?
+    ".#{formatter.strip}"
+  end
+  
+  def calculate_next_gen_time
+    Time.now + 1.hour
+  end
+  
+  protected
+  
+  def ensure_job
+    queue_next! if jobs.reload.size == 0
+    true
+  end
+  
+  def filename_extension_update
+    return true if filename_changed?
+    return true unless formatter_changed?
+    pieces = filename.split(".")
+    if pieces.size > 1
+      pieces[-1] = formatter.to_s
+      self.filename = pieces.join(".")
+    end
+    true
+  end
+
+end