clark_kent 0.0.1

data/app/models/clark_kent/report.rb

@@ -0,0 +1,272 @@
+module ClarkKent
+  # load the builders
+  Dir.glob(Rails.root.join('app/models/reporting/*.rb')) { |file| load file }
+  class Report < ActiveRecord::Base
+
+    include Cloneable
+
+    SortDirections = {'A->Z' => 'asc', 'Z->A' => 'desc'}
+
+    attr_accessible :resource_type, :name, :sharing_scope_id, :sharing_scope_type
+    attr_accessor :summary_row_storage
+
+    belongs_to :sharing_scope, polymorphic: true
+    has_many :report_filters, as: :filterable, dependent: :destroy
+    has_many :report_columns, -> {order("clark_kent_report_columns.column_order").references(:report_columns)}, dependent: :destroy
+    has_many :report_emails, dependent: :destroy
+    has_many :report_email_filters, through: :report_emails, source: :report_filters
+
+    scope :for, ->(resource_type) { where(resource_type: resource_type) }
+    scope :shared, -> { where(sharing_scope_id: nil) }
+
+    validates :sharing_scope_id, presence: true, if: ->(r) { r.sharing_scope_type.present? }
+
+    def self.send_report_to_s3(report_id, params)
+      params = params
+      report_class = params['report_class'].constantize if params['report_class']
+      report_class ||= ::ClarkKent::Report
+      reportable = report_class.find(report_id)
+      report = ('ClarkKent::ReportEmail' == report_class.name) ? reportable.report : reportable
+      query = reportable.get_query(params)
+      row_count = reportable.get_query(params, true)
+      bucket = AWS::S3::Bucket.new(ClarkKent::ReportUploaderBucketName)
+      report_destination = bucket.objects[params['report_result_name']]
+      byte_count = 0
+      temp_buffer = report.headers.to_csv
+      offset = 0
+      summary_rows = []
+      some_left = true
+      report_destination.write(estimated_content_length: row_count * 1000) do |buffer, bytes|
+        while temp_buffer.length < bytes and some_left
+          this_batch = query.offset(offset).limit(100)
+          some_left = this_batch.each do |row|
+            temp_buffer << report.report_columns.map{ |column| row[column.column_name] }.to_csv
+          end.any?
+          summary_rows.push report.summary_row(this_batch) if report.summary_row? and some_left
+          offset += 100
+        end
+        if report.summary_row_storage.blank? and (!some_left)
+          if report.summary_row? and summary_rows.any?
+            summary_row_map = report.summary_row(summary_rows)
+            report.summary_row_storage = report.report_columns.map do |col|
+              summary_row_map.send col.column_name
+            end
+            temp_buffer << report.summary_row_storage.to_csv
+          end
+        end
+        if temp_buffer.present?
+          chunk = temp_buffer.slice!(0...bytes)
+          buffer << chunk
+        end
+      end
+      report_result_url = report_destination.url_for(
+        :read,
+        secure: true,
+        response_content_type: 'text/csv',
+        response_content_encoding: 'binary',
+        expires: 60*60*24*30 #good for 30 days
+      )
+      if 'ClarkKent::Report' == report_class.name
+        ForeignOffice.publish(channel: params['report_result_name'], object: {report_result_url: report_result_url.to_s} )
+      end
+      report_result_url.to_s
+    end
+
+    def get_query(params, count = false)
+      self.resource_class.report(params,self, count)
+    end
+
+    def resource_class
+      @resource_class ||= self.resource_type.constantize
+    end
+
+    def sort_column
+      @sort_column ||= self.report_columns.where("clark_kent_report_columns.report_sort is not NULL and clark_kent_report_columns.report_sort != ''").first
+    end
+
+    def sorter
+      if self.sort_column
+        sort_column_name = self.sort_column.column_name
+        sort_direction = Report::SortDirections[sort_column.report_sort]
+        Map.new(order_column: sort_column_name, order_direction: sort_direction)
+      end
+    end
+
+    def arel_includes
+      self.report_columns.map{|column|
+        column_info = self.column_options_for(column.column_name)
+        column_info.includes if column_info.respond_to? :includes
+        }.compact
+    end
+
+    def arel_joins
+      self.report_columns.map{|column|
+        column_info = self.column_options_for(column.column_name)
+        column_info.joins if column_info.respond_to? :joins
+        }.compact
+    end
+
+    def extra_scopes
+      self.report_columns.map{|column|
+        column_info = self.column_options_for(column.column_name)
+        column_info.extra_scopes if column_info.respond_to? :extra_scopes
+        }.flatten.compact
+    end
+
+    def extra_filters
+      self.report_columns.map{|column|
+        column_info = self.column_options_for(column.column_name)
+        column_info.where if column_info.respond_to? :where
+        }.flatten.compact
+    end
+
+    def groups
+      self.report_columns.map{|column|
+        column_info = self.column_options_for(column.column_name)
+        column_info.group if column_info.respond_to? :group
+        }.flatten.compact
+    end
+
+    def report_filter_params
+      Hash[*self.report_filters.map{|filter| filter.filter_match_params}.flatten].
+        merge(order: self.sorter)
+    end
+
+    def select_clauses
+      @selects = []
+      self.report_columns.each do |report_column|
+        column_option = self.column_options_for(report_column.column_name)
+        @selects.push column_option.custom_select if column_option.respond_to? :custom_select
+      end
+      self.report_filters.each do |report_filter|
+        column_option = self.column_options_for(report_filter.filter_name)
+        @selects.push column_option.custom_select if column_option.respond_to? :custom_select
+      end
+      @selects
+    end
+
+
+    def filter_options_for(filter_name)
+      self.resource_class::REPORT_FILTER_OPTIONS.detect{|filter| filter.param == filter_name}
+    end
+
+    def column_options_for(column_name)
+      if self.resource_class::REPORT_COLUMN_OPTIONS.has_key? column_name.to_sym
+        self.resource_class::REPORT_COLUMN_OPTIONS[column_name.to_sym]
+      else
+        column_name = column_name.to_s.split('_')[0..-2].join('_')
+        if self.resource_class::REPORT_COLUMN_OPTIONS.has_key? column_name.to_sym
+          self.resource_class::REPORT_COLUMN_OPTIONS[column_name.to_sym]
+        end
+      end
+    end
+
+    def filter_kind(filter_name)
+      self.filter_options_for(filter_name).kind
+    end
+
+    def date_filter_names
+      self.resource_class::REPORT_FILTER_OPTIONS.select{|filter| 'date_filter' == filter.kind}.map{|filter| filter.param}
+    end
+
+    def available_filters
+      self.available_email_filters.reject{|name| self.date_filter_names.include? name}
+    end
+
+    def available_filter_options
+      self.available_filters.map{|id| [self.filter_options_for(id).label,id]}
+    end
+
+    def available_email_filters
+      self.resource_class::REPORT_DEFINITION_OPTIONS.reject{|name| (self.report_filters.pluck(:filter_name)).include? name}
+    end
+
+    def collection_for(filter_name)
+      self.resource_class::REPORT_FILTER_OPTIONS.detect{|filter| filter.param == filter_name}.collection
+    end
+
+    def custom_filters
+      self.resource_class::REPORT_FILTER_OPTIONS.select{|filter| self.report_filters.pluck(:filter_name).exclude? filter.param}
+    end
+
+    def available_columns
+      self.resource_class::REPORT_COLUMN_OPTIONS.keys.reject{|column| self.report_columns.pluck(:column_name).include? column.to_s}
+    end
+
+    def sortable?(column)
+      !!(self.column_options_for(column.column_name).respond_to? :order_sql)
+    end
+
+    def sharing_scope_pretty
+      (self.sharing_scope.try :name ) || 'Everyone'
+    end
+
+    def resource_type_pretty
+      self.resource_class.prettify_name.pluralize
+    end
+
+    def get_filter_class(params)
+      filter_option = self.resource_class::REPORT_FILTER_OPTIONS.detect{|filter| filter.param == params[:filter_name]}
+      "ClarkKent::Report#{filter_option.kind.camelcase}".constantize
+    end
+
+    def summary_row_values(rows)
+      self.report_columns.each_with_index.map do |report_column,index|
+        report_column.calculate_summary(rows.map{|row| row[index]})
+      end
+    end
+
+    def summary_row(rows)
+      row_array = self.report_columns.map do |report_column|
+        [report_column.column_name,report_column.calculate_summary(rows.map{|row| row.send(report_column.column_name)})]
+      end
+      Map.new(row_array.to_h)
+    end
+
+    def summary_row?
+      @summary_row_presence ||= self.report_columns.to_a.any?{|c| c.summary_method.present? }
+    end
+
+    def headers
+      the_headers = self.report_columns.sorted.pluck(:column_name)
+
+      unless name =~ /net\s?promoter/i
+        the_headers.map(&:humanize)
+      else
+        the_headers
+      end
+    end
+
+    def deep_clone
+      Report.transaction do
+        new_report = dup.reset_timestamps
+        new_report.name << " CLONED: #{Date.today.to_s(:db)}"
+        new_report.save!
+
+        report_filters.each do |report_filter|
+          new_report.report_filters << report_filter.dup.reset_timestamps
+        end
+
+        report_columns.each do |report_column|
+          new_report.report_columns << report_column.dup.reset_timestamps
+        end
+
+        report_emails.each do |report_email|
+          new_report_email = report_email.dup.reset_timestamps
+          new_report.report_emails << new_report_email
+
+          report_email.report_filters.each do |report_filter|
+            new_report_email.report_filters << report_filter.dup.reset_timestamps
+          end
+
+          report_email.user_report_emails.each do |user_report_email|
+            new_report_email.user_report_emails << user_report_email.dup.reset_timestamps
+          end
+        end
+
+        new_report
+      end
+    end
+
+  end
+end

data/app/models/clark_kent/report_column.rb

@@ -0,0 +1,24 @@
+module ClarkKent
+	class ReportColumn < ActiveRecord::Base
+	  include Cloneable
+
+		SummaryMethods = ['total','average']
+		attr_accessible :report_id, :column_name, :column_order, :report_sort, :summary_method
+		belongs_to :report
+
+		scope :sorted, -> { order("clark_kent_report_columns.column_order") }
+
+		def report_sort_pretty
+			{'ascending' => 'A->Z','descending' => 'Z->A'}[self.report_sort]
+		end
+
+		def calculate_summary(values)
+			return nil unless self.summary_method.present?
+			values.send self.summary_method
+		end
+
+		def summarizable?
+			report.column_options_for(self.column_name).respond_to? :summarizable
+		end
+	end
+end

data/app/models/clark_kent/report_date_filter.rb

@@ -0,0 +1,81 @@
+module ClarkKent
+  class ReportDateFilter < ReportFilter
+    WeekDayOptions = ['Monday','Tuesday','Wednesday','Thursday','Friday','Saturday','Sunday']
+    MonthDayOptions = ['beginning of month']
+    DayOptions = WeekDayOptions + MonthDayOptions
+    WeekPeriodOptions = {
+      'previous week' => 'last_week',
+      'same week' => 'this_week',
+      'following week' => 'next_week'
+    }
+    MonthPeriodOptions = {
+      'previous month' => 'last_month',
+      'same month' => 'this_month',
+      'following month' => 'next_month'
+    }
+
+    PeriodOptions = WeekPeriodOptions.merge MonthPeriodOptions
+
+    Durations = ['day','week','two weeks','month']
+
+    before_save :handle_filter_value
+
+    attr_accessible :kind_of_day, :offset, :duration
+
+    def filter_match_params
+      [[self.begin_param_name,self.begin_date],[self.end_param_name,self.end_date]]
+    end
+
+    def begin_param_name
+      "#{self.filter_name}_from"
+    end
+
+    def end_param_name
+      "#{self.filter_name}_until"
+    end
+
+    def begin_date
+      @begin_date = Date.ih_today
+      direction, period = self.period_offset
+      @begin_date = @begin_date.send(direction, 1.send(period)) if direction
+      @begin_date = @begin_date.find_day(self.day_offset) if self.day_offset
+      @begin_date
+    end
+
+    def day_offset
+      return false if 'today' == self.kind_of_day
+      self.kind_of_day.gsub(/ /,'_')
+    end
+
+    def period_offset
+      direction, period = self.offset.split('_')
+      direction = {'last' => '-', 'next' => '+', 'this' => false, '' => false}[direction.to_s]
+      return [direction, period]
+    end
+
+    def end_date
+      return self.begin_date if 'day' == self.duration
+      return self.begin_date + 6.days if 'week' == self.duration
+      return self.begin_date + 13.days if 'two weeks' == self.duration
+      if Date::DAYNAMES.include? self.kind_of_day.capitalize
+        return self.begin_date + 1.month
+      else
+        return self.begin_date.end_of_month
+      end
+    end
+
+    def handle_filter_value
+      if self.filter_value_1.present? and self.filter_value_2.present?
+        self.filter_value = [filter_value_1, self.filter_value_2].join(' ')
+      end
+    end
+
+    def offset_pretty
+      self.class::PeriodOptions.rassoc(self.offset).first
+    end
+
+    def date_display
+      "starts on #{self.kind_of_day} #{self.offset_pretty} for 1 #{self.duration}"
+    end
+  end
+end

data/app/models/clark_kent/report_email.rb

@@ -0,0 +1,105 @@
+module ClarkKent
+  class ReportEmail < ActiveRecord::Base
+    include Cloneable
+
+    SEND_TIMES = {
+      'Mondays' => 'Monday',
+      'Tuesdays' => 'Tuesday',
+      'Wednesdays' => 'Wednesday',
+      'Thursdays' => 'Thursday',
+      'Fridays' => 'Friday',
+      'Saturdays' => 'Saturday',
+      'Sundays' => 'Sunday',
+      '1st of the month' => 'beginning_of_month',
+      'End of the month' => 'end_of_month'
+    }
+    belongs_to :report
+    has_many :report_filters, as: :filterable, dependent: :destroy
+    has_many :report_date_filters, as: :filterable, dependent: :destroy
+    has_many :user_report_emails, dependent: :destroy
+    has_many :users, through: :user_report_emails
+
+    attr_accessible :report_id, :when_to_send, :name
+
+    def self.send_emails_for_today
+      today = Date.ih_today
+      todays_filters = []
+      ['beginning_of_month','end_of_month'].each do |month_bookend|
+        todays_filters.push month_bookend if today.send(month_bookend) == today
+      end
+      todays_filters.push  Date::DAYNAMES[today.wday]
+      self.where(when_to_send: todays_filters).each do |report_email|
+        report_email.send_emails
+      end
+    end
+
+    def send_emails
+      self.user_report_emails.each do |user_report_email|
+        ConeyIsland.submit(ClarkKent::ReportEmail, :send_email, instance_id: self.id, args: [user_report_email.user_id], timeout: 300, work_queue: 'boardwalk')
+      end
+    end
+
+    def send_email(user_id)
+      user = ClarkKent.user_class.find(user_id)
+      params = {'report_result_name' => "report-#{self.id}-user-#{user_id}-#{Time.now.to_formatted_s(:number)}", 'report_class' => 'ClarkKent::ReportEmail'}
+      SharingScopeKind.custom.each do |sharing_scope_kind|
+        unless report.report_filters.map(&:filter_name).include? sharing_scope_kind.basic_association_id_collection_name.to_s
+          associations = sharing_scope_kind.associated_containers_for(user)
+          params[sharing_scope_kind.basic_association_id_collection_name] = associations.map(&:id)
+        end
+      end
+      report_download_url = ClarkKent::Report.send_report_to_s3(self.id, params)
+      ClarkKent::ReportMailer.report_run(self.report_id, user_id, report_download_url).deliver
+    end
+
+    def report_filter_params
+      Hash[*self.report_filters.map{|filter| filter.filter_match_params}.flatten].
+        merge(order: self.report.sorter).merge(self.report.report_filter_params)
+    end
+
+    def filter_kind(filter_name)
+      self.report.filter_kind(filter_name)
+    end
+
+    def resource_class
+      self.report.resource_class
+    end
+
+    def filter_options_for(filter_name)
+      self.report.filter_options_for(filter_name)
+    end
+
+    def collection_for(filter_name)
+      self.report.collection_for(filter_name)
+    end
+
+    def get_filter_class(params)
+      self.report.get_filter_class(params)
+    end
+
+    def available_email_filters
+      self.resource_class::REPORT_DEFINITION_OPTIONS.reject{|name, label| (self.report_filters.pluck(:filter_name) + self.report.report_filters.pluck(:filter_name)).include? name}
+    end
+
+    def available_filters
+      self.available_email_filters
+    end
+
+    def available_filter_options
+      self.available_filters.map{|id| [self.filter_options_for(id).label,id]}
+    end
+
+    def get_query(params, count = false)
+      self.report.resource_class.report(params,self, count)
+    end
+
+    def period_pretty
+      self.report_date_filters.map{|filter| [filter.filter_name,filter.date_display].join(' ')}.join('<br>').html_safe
+    end
+
+    def emails
+      self.users.map(&:email)
+    end
+
+  end
+end

data/app/models/clark_kent/report_filter.rb

@@ -0,0 +1,26 @@
+module ClarkKent
+	class ReportFilter < ActiveRecord::Base
+	  include Cloneable
+
+	  attr_accessor :filter_value_1, :filter_value_2
+		attr_accessible :filter_value_1, :filter_value_2, :report_id, :filter_name, :filter_value, :filterable_id, :filterable_type, :type
+		belongs_to :filterable, polymorphic: true
+
+		def filter_match_params
+			[self.filter_match_param,self.filter_match_value]
+		end
+
+		def filter_match_param
+			self.filter_name
+		end
+
+		def filter_match_value
+			self.filter_value
+		end
+
+		def display_name
+			self.filter_name
+		end
+
+	end
+end

data/app/models/clark_kent/report_filter_option.rb

@@ -0,0 +1,18 @@
+module ClarkKent
+	class ReportFilterOption
+	  include Cloneable
+
+		attr_accessor :param, :label, :collection, :kind, :select
+		def initialize(params)
+			self.param = params[:param] if params[:param].present?
+			self.label = params[:label] if params[:label].present?
+			self.collection = params[:collection] if params[:collection].present?
+			self.kind = params[:kind] if params[:kind].present?
+			self.select = params[:select] if params[:select].present?
+		end
+
+		def label
+			@label || @param
+		end
+	end
+end

data/app/models/clark_kent/report_number_filter.rb

@@ -0,0 +1,20 @@
+module ClarkKent
+  class ReportNumberFilter < ReportFilter
+    include Cloneable
+
+  	attr_accessible :max_value, :min_value
+
+    def filter_match_params
+      [[self.min_param_name,self.min_value],[self.max_param_name,self.max_value]]
+    end
+
+    def min_param_name
+      "#{self.filter_name}_min"
+    end
+
+    def max_param_name
+      "#{self.filter_name}_max"
+    end
+
+  end
+end

data/app/models/clark_kent/report_object_filter.rb

@@ -0,0 +1,27 @@
+module ClarkKent
+	class ReportObjectFilter < ReportFilter
+	  include Cloneable
+
+		def get_display_value
+			if self.filter_value.to_i > 0
+				self.filter_class.find(self.filter_value).name
+			else
+				self.filter_value
+			end
+		end
+
+		def filter_class
+			if self.filter_name =~ /_id/
+				self.filter_name.split('_')[0..-2].join('_').camelcase.constantize
+			end
+		end
+
+		def display_name
+			if self.filter_class.present?
+				self.filter_class.name.underscore.humanize
+			else
+				self.filter_name
+			end
+		end
+	end
+end

data/app/models/clark_kent/report_result.rb

@@ -0,0 +1,55 @@
+module ClarkKent
+	class ReportResult
+		include Enumerable
+
+		def initialize(arel_query, params)
+			@arel_query = arel_query
+			@params = params
+		end
+
+		def paginated_query
+			if @params.has_key? :page and @params.has_key? :per
+				page = @params[:page] || 1
+				@arel_query.offset((page.to_i - 1) * @params[:per]).limit(@params[:per])
+			else
+				@arel_query
+			end
+		end
+
+		def current_page
+			@params[:page]
+		end
+
+		def per_page
+			@params[:per]
+		end
+
+		def query
+			@arel_query
+		end
+
+		def total_count
+			unless defined?(@total_count)
+				results = results_for(@arel_query.to_sql)
+				@total_count = results.num_tuples
+			end
+
+			@total_count
+		end
+
+		def rows
+			results_for(paginated_query.to_sql)
+		end
+
+		def each(&block)
+			rows.each(&block)
+		end
+
+		private
+
+			def results_for(sql)
+				Report.connection.raw_connection.exec(sql)
+			end
+
+	end
+end

data/app/models/clark_kent/report_string_filter.rb

@@ -0,0 +1,5 @@
+module ClarkKent
+  class ReportStringFilter < ReportFilter
+    include Cloneable
+  end
+end