twistage_stats_reports 1.0.0

data/lib/stats/breakdown_report.rb

@@ -0,0 +1,139 @@
+require 'stats/tzinfo_extensions'
+
+class Stats::BreakdownReport < Stats::EventReport
+  set_attributes         [ :id, :date, :start_date, :end_date, :title, :label, :name, :query_time, :bytes_uploaded, :bytes_encoded, :bytes_uploaded_gb, :bytes_encoded_gb, :container ]
+  set_numeric_attributes [ :assets_uploaded, :assets_encoded, :duration_uploaded, :duration_encoded, :duration_uploaded_min, :duration_encoded_min ]
+
+  def initialize(options = {})
+    @label                  = options[:label]
+
+    @container              = options[:container]
+
+    @assets_uploaded        = options[:assets_uploaded] || 0
+    @assets_encoded         = options[:assets_encoded]  || 0
+
+    @query_time             = nil
+
+    @duration_uploaded      = options[:duration_uploaded].to_f || 0
+    @duration_uploaded_min  = ('%.2f' % (@duration_uploaded / 60.seconds.to_f)).to_f
+
+    @duration_encoded       = options[:duration_encoded].to_f || 0
+    @duration_encoded_min   = ('%.2f' % (@duration_encoded / 60.seconds.to_f)).to_f
+  end
+
+  def self.csv_keys
+    [ :container, :assets_encoded, :assets_uploaded, :duration_uploaded, :duration_encoded ]
+  end
+
+  def to_csv(options = {})
+    the_csv_keys = strip_keys_by_label(self.class.csv_keys, @label)
+    the_csv_keys.map do |k| 
+      self.class.format_csv_value(send(k))
+    end.join(',')
+  end
+
+  def to_xml options = {}
+    xml = options[:builder] ||= Builder::XmlMarkup.new(:indent => options[:indent])
+    xml.instruct! unless options[:skip_instruct]
+
+    xml.__send__(@label) do
+      xml.container         @container
+      xml.assets_encoded    @assets_encoded
+      xml.assets_uploaded   @assets_uploaded
+      xml.duration_encoded  @duration_encoded
+      xml.duration_uploaded @duration_uploaded
+    end
+  end
+
+  def to_json(options = {})
+    report                      = HashWithIndifferentAccess.new
+    report['container']         = @container
+    report['assets_encoded']    = @assets_encoded
+    report['assets_uploaded']   = @assets_uploaded
+    report['duration_encoded']  = @duration_encoded
+    report['duration_uploaded'] = @duration_uploaded
+
+    report.to_json
+  end
+
+  def self.to_amcharts(reports, show_date, show_date_range, options = {})
+    assets_encoded     = []
+    assets_uploaded    = []
+    complete_labels    = []
+    duration_encoded   = []
+    duration_uploaded  = []
+    guids              = []
+    labels             = []
+    reports            = pad_reports(reports, options) if options["pad"]
+    reports            = reports.reverse if options[:reverse]
+
+    reports.each do |report|
+      label = report.container
+      label = '&lt;blank&gt;' if 'null' == label
+
+      complete_labels    << label
+      labels             << label.previewize((options[:max_label_length] || 15).to_i)
+      assets_uploaded    << report.assets_uploaded
+      duration_uploaded  << report.duration_uploaded_min
+      assets_encoded     << report.assets_encoded
+      duration_encoded   << report.duration_encoded_min
+      guids              << report.id
+    end
+
+    show_screenshots = reports.length <= 10
+
+    max_labels = 20
+    # frequency == 1 if we can display all labels, or a number greater
+    # than 1 if we can't
+    frequency = (labels.length / max_labels.to_f).ceil
+
+    xml = options[:builder] ||= Builder::XmlMarkup.new(:indent => 2)
+    xml.instruct! :xml, :version=>"1.0", :encoding=>"UTF-8"
+    xml.chart do
+      xml.series do
+        labels.each_with_index do |value, index|
+          # only display every nth value where n depends the total
+          # number of labels and the max labels we are allowed to
+          # display, otherwise clear out the value
+          value = "" if index % frequency != 0
+          xml.value value, :xid => index
+        end
+      end
+
+      xml.graphs do
+        #the gid is used in the settings file to set different settings just for this graph
+        unless options[:show_uploads] == 'false'
+          xml.graph :gid => 'assets_uploaded' do
+            assets_uploaded.each_with_index do |value, index|
+              xml.value value, :xid => index
+            end
+          end
+        end
+
+        unless options[:show_duration_uploaded] == 'false'
+          xml.graph :gid => 'duration_uploaded' do
+            duration_uploaded.each_with_index do |value, index|
+              xml.value value, :xid => index
+            end
+          end
+        end
+
+        unless options[:show_encodes] == 'false'
+          xml.graph :gid => 'assets_encoded' do
+            assets_encoded.each_with_index do |value, index|
+              xml.value value, :xid => index
+            end
+          end
+        end
+        
+        unless options[:show_duration_encoded] == 'false'
+          xml.graph :gid => 'duration_encoded' do
+            duration_encoded.each_with_index do |value, index|
+              xml.value value, :xid => index
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/stats/disk_usage_report.rb

@@ -0,0 +1,71 @@
+require 'stats/tzinfo_extensions'
+
+class Stats::DiskUsageReport < Stats::EventReport
+  set_attributes         [ :id, :obj_id, :group, :name, :nickname, :title, :label, :name, :query_time, :start_date, :end_date ]
+  set_numeric_attributes [ :actual_bytes, :actual_average_bytes, :bytes, :average_bytes, :objects, :average_objects ]
+
+  def initialize(options = {})
+    @label                = "stats" # video unless date
+    @obj_id               = options[:obj_id    ] unless options[:obj_id    ].blank?
+    @nickname             = options[:nickname  ] unless options[:nickname  ].blank?
+    @name                 = options[:name      ] unless options[:name      ].blank?
+    @group                = options[:group     ] unless options[:group     ].blank?
+    @start_date           = options[:start_date] unless options[:start_date].blank?
+    @end_date             = options[:end_date  ] unless options[:end_date  ].blank?
+    @actual_bytes         = options[:storage_bytes].to_i
+    @actual_average_bytes = options[:average_storage_bytes].to_i
+    if options[:storage_bytes]
+      @bytes                = sprintf("%0.3f", options[:storage_bytes]         / 1.gigabyte)
+    end
+    if options[:average_storage_bytes]
+      @average_bytes        = sprintf("%0.3f", options[:average_storage_bytes] / 1.gigabyte)
+    end
+    @objects                = options[:objects].to_i
+    @average_objects        = options[:average_objects].to_i
+    @id                   = @nickname
+  end
+
+  def self.csv_keys
+    keys = @nickname.nil? ? [ :id ] : []
+    keys += [ :start_date, :end_date, :actual_bytes, :actual_average_bytes, :objects, :average_objects ]
+  end
+
+  def to_csv(options = {})
+    the_csv_keys = strip_keys_by_label(self.class.csv_keys, @label)
+    the_csv_keys.map do |k|
+      self.class.format_csv_value(send(k))
+    end.join(',')
+  end
+
+  def to_xml options = {}
+    xml = options[:builder] ||= Builder::XmlMarkup.new(:indent => options[:indent])
+    xml.instruct! unless options[:skip_instruct]
+
+    xml.__send__(@label) do
+      xml.id            @nickname                        unless @nickname.nil?
+      xml.start_date    @start_date.strftime("%Y/%m/%d") unless @start_date.nil?
+      xml.end_date      @end_date.strftime("%Y/%m/%d")   unless @end_date.nil?
+      xml.bytes         @actual_bytes
+      xml.average_bytes @actual_average_bytes if @group =~ /daily|weekly|monthly/
+      xml.objects         @objects
+      xml.average_objects @average_objects if @group =~ /daily|weekly|monthly/
+    end
+  end
+
+  def to_json(options = {})
+    report                  = HashWithIndifferentAccess.new
+    report['id']      = @nickname                        unless @nickname.nil?
+    report['start_date']    = @start_date.strftime("%Y/%m/%d") unless @start_date.nil?
+    report['end_date']      = @end_date.strftime("%Y/%m/%d")   unless @end_date.nil?
+    report['bytes']         = @actual_bytes
+    report['average_bytes'] = @actual_average_bytes if @group =~ /daily|weekly|monthly/
+    report['objects']         = @objects
+    report['average_objects'] = @average_objects if @group =~ /daily|weekly|monthly/
+
+    report.to_json
+  end
+  
+  def self.to_amcharts(reports, show_date, show_date_range, options = {})
+    UsageSample.to_amcharts(reports, options)
+  end
+end

data/lib/stats/event_report.rb

@@ -0,0 +1,351 @@
+require 'stats/tzinfo_extensions'
+
+class Stats::EventReport < Stats::Report
+  extend ActiveSupport::Inflector
+  extend ActionView::Helpers::TextHelper
+  extend ActionView::Helpers::NumberHelper
+  
+  class Pluralizer
+    include Singleton 
+    extend ActionView::Helpers::TextHelper 
+  end 
+  
+  SUPPRESSED_LABELS = { 
+    :id                => %w[domain metropolitan-area],
+    :title             => %w[country domain metropolitan-area tag browser device profile],
+    :hits              => %w[],
+    :plays             => %w[profile],
+    :downloads         => %w[domain profile],
+    :bytes_transferred => %w[profile],
+  }
+
+  set_attributes          [ :id, :date, :start_date, :end_date, :title, :label, :name, :query_time, :stats_type ]
+  set_numeric_attributes  [ :hits, :plays, :downloads, :bytes_transferred]
+
+  def set_date(time, scope = nil)
+    t = Time.parse time.to_s
+    case scope
+    when nil
+      @date = t
+    when :daily
+      @date = t.beginning_of_day
+    when :monthly
+      @start_date = t.beginning_of_month
+      @end_date = t.end_of_month
+    when :weekly
+      @start_date = t.beginning_of_week
+      @end_date = @start_date.next_week.yesterday
+    end
+  end
+
+  def get_start_date(scope)
+    case scope
+    when nil, :daily
+      @date
+    when :monthly, :weekly
+      @start_date
+    end
+  end
+
+  def to_xml options = {}
+    xml = options[:builder] ||= Builder::XmlMarkup.new(:indent => options[:indent])
+    xml.instruct! unless options[:skip_instruct]
+
+    xml.__send__(@label) do
+      xml.id @id if @id and not SUPPRESSED_LABELS[:id].include?(@label)
+      xml.name @name if @name
+      xml.title @title unless SUPPRESSED_LABELS[:title].include?(@label)
+      xml.hits @hits
+      if @stats_type != 'image'
+        [ :plays, :downloads ].each do |key|
+          xml.tag!(key, self[key]) unless SUPPRESSED_LABELS[key].include?(@label)
+        end
+      end
+      xml.date(pretty_time(@date)) if @date
+      xml.start_date(pretty_time(@start_date)) if @start_date
+      xml.end_date(pretty_time(@end_date)) if @end_date
+      unless SUPPRESSED_LABELS[:bytes_transferred].include?(@label)
+        xml.bytes_transferred @bytes_transferred.to_i
+      end
+    end
+  end
+
+  def to_csv(options = {})
+    klass_keys = options[:images] ? Stats::ImageReport.csv_keys : self.class.csv_keys 
+    the_csv_keys = strip_keys_by_label(klass_keys, @label)
+
+    the_csv_keys.map do |k|
+      self.class.format_csv_value(send(k))
+    end.join(',')
+  end
+
+  def to_json(options = {})
+    report          = HashWithIndifferentAccess.new
+    report['id']    = @id   if @id and not SUPPRESSED_LABELS[:id].include?(@label)
+    report['name']  = @name if @name
+    report['title'] = @title unless SUPPRESSED_LABELS[:title].include?(@label)
+
+    report['hits'] = @hits
+    if @stats_type != 'image'
+      [ :plays, :downloads ].each do |key|
+        report[key.to_s] = self[key.to_s] unless SUPPRESSED_LABELS[key].include?(@label)
+      end
+    end
+
+    report['date']       = pretty_time(@date)       if @date
+    report['start_date'] = pretty_time(@start_date) if @start_date
+    report['end_date']   = pretty_time(@end_date)   if @end_date
+
+    unless SUPPRESSED_LABELS[:bytes_transferred].include?(@label)
+      report['bytes_transferred'] = @bytes_transferred.to_i
+    end
+
+    report.to_json
+  end
+
+  def self.get_url(r)
+    if 'image' == r.stats_type
+      prepend = 'image_'
+      type    = 'albums'
+    elsif 'track' == r.stats_type
+      prepend = ''
+      type    = 'tracks'
+    else
+      prepend = ''
+      type    = 'videos'
+    end
+
+    url = if r.id.nil?
+            nil
+          else
+            case r.label
+            when "company" then "/companies/#{r.id}/#{prepend}statistics"
+            when "video"   then "/videos/#{r.id}/statistics"
+            when "track"   then "/tracks/#{r.id}/statistics"
+            end
+          end
+    url ||= (r.title.blank? ? nil : "/#{type}/#{r.id}/statistics")
+
+  end
+
+  def self.csv_keys
+    [ :id, :name, :title, :hits, :plays, :downloads, :bytes_transferred, :date, :start_date, :end_date ]
+  end
+
+  def self.to_amcharts(reports, show_date, show_date_range, options = {})
+    options["fields"] ||= [ :hits, :plays, :downloads ].reject { |field| SUPPRESSED_LABELS[field].include?(options["group"]) }.map(&:to_s)
+    complete_labels = []
+    labels          = []
+    hits            = []
+    plays           = []
+    downloads       = []
+    urls            = []
+    guids           = []
+    reports         = pad_reports(reports, options) if options["pad"]
+    reports         = reports.reverse if options[:reverse]
+
+    reports.each do |r|
+      if show_date and !r.date.blank?
+        label = "#{r.date.month}/#{r.date.day}"
+      elsif show_date_range and !r.start_date.blank? and !r.end_date.blank?
+        label = if r.start_date.month == r.end_date.month && r.start_date.day == r.start_date.beginning_of_month.day && r.end_date.day == r.end_date.end_of_month.day
+                  "#{r.start_date.strftime("%b \'%y")}"
+                else
+                  "#{r.start_date.month}/#{r.start_date.day}-#{r.end_date.month}/#{r.end_date.day}"
+                end
+      elsif !r.title.blank?
+        label = r.title
+      elsif !r.name.blank?
+        label = r.name
+      else
+        label = r.id.to_s
+      end
+
+      complete_labels << label
+      labels          << label.previewize((options[:max_label_length] || 15).to_i)
+      hits            << r.hits
+      if r.stats_type != 'image'
+        plays     << r.plays
+        downloads << r.downloads
+      end
+
+      guids << r.id
+      if !options.has_key?(:video_id) && !options.has_key?(:track_id)
+        urls << get_url(r)
+      else
+        urls << nil
+      end
+    end
+
+    show_screenshots = false # && reports.length <= 10
+
+    max_labels = 40
+    # frequency == 1 if we can display all labels, or a number greater
+    # than 1 if we can't
+    if show_date || show_date_range
+      frequency = 1
+    else
+      frequency = (labels.length / max_labels.to_f).ceil
+    end
+
+    xml = options[:builder] ||= Builder::XmlMarkup.new(:indent => 2)
+    xml.instruct! :xml, :version=>"1.0", :encoding=>"UTF-8"
+    xml.chart do
+      xml.series do
+        labels.each_with_index do |value, index|
+          # only display every nth value where n depends the total
+          # number of labels and the max labels we are allowed to
+          # display, otherwise clear out the value
+          value = "" if index % frequency != 0
+          xml.value value, :xid => index
+        end
+      end
+
+      xml.graphs do
+        #the gid is used in the settings file to set different settings just for this graph
+        level = "Hits"
+        if options[:fields].include?("hits")
+          xml.graph :gid => 'hits' do
+            hits.each_with_index do |value, index|
+              if value != 0 || complete_labels[index].blank? || show_date || show_date_range
+                opts = { :xid => index, :description => complete_labels[index] }
+                opts[:url] = urls[index] unless urls[index].blank?
+                xml.value value, opts
+              end
+            end
+          end
+        end
+
+        if options[:fields].include?("plays")
+          xml.graph :gid => 'plays' do
+            plays.each_with_index do |value, index|
+              if value != 0 || complete_labels[index].blank? || show_date || show_date_range
+                opts = { :xid => index, :description => complete_labels[index] }
+                opts[:url] = urls[index] unless urls[index].blank?
+                opts[:bullet] = "../videos/#{guids[index]}/screenshots/32w.jpg" if !guids[index].blank? && show_screenshots
+                xml.value value, opts
+              end
+            end
+          end
+        end
+
+        if options[:fields].include?("downloads")
+          xml.graph :gid => 'downloads' do
+            downloads.each_with_index do |value, index|
+              if value != 0 || complete_labels[index].blank? || show_date || show_date_range
+                opts = { :xid => index, :description => complete_labels[index] }
+                opts[:url] = urls[index] unless urls[index].blank?
+                xml.value value, opts
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+
+  AMMAP_COUNTRIES = [ "AF", "AX", "AL", "DZ", "AD", "AO", "AI", "AG",
+    "AR", "AM", "AW", "AU", "AT", "AZ", "BS", "BH", "BD", "BB", "BY",
+    "BE", "BZ", "BJ", "BM", "BT", "BO", "BA", "BW", "BR", "BN", "BG",
+    "BF", "BI", "KH", "CM", "CA", "CV", "CF", "TD", "CL", "CN", "CO",
+    "KM", "CG", "CD", "CR", "CI", "HR", "CU", "CY", "CZ", "DK", "DJ",
+    "DM", "DO", "EC", "EG", "SV", "GQ", "ER", "EE", "ET", "FO", "FK",
+    "FJ", "FI", "FR", "GF", "GA", "GM", "GE", "DE", "GH", "GR", "GL",
+    "GD", "GP", "GT", "GN", "GW", "GY", "HT", "HN", "HK", "HU", "IS",
+    "IN", "ID", "IR", "IQ", "IE", "IL", "IT", "JM", "JP", "JO", "KZ",
+    "KE", "KP", "KR", "KW", "KG", "LA", "LV", "LB", "LS", "LR", "LY",
+    "LI", "LT", "LU", "MK", "MG", "MW", "MY", "ML", "MT", "MQ", "MR",
+    "MU", "MX", "MD", "MN", "ME", "MS", "MA", "MZ", "MM", "NA", "NP",
+    "NL", "NC", "NZ", "NI", "NE", "NG", "NO", "OM", "PK", "PW", "PS",
+    "PA", "PG", "PY", "PE", "PH", "PL", "PT", "PR", "QA", "RE", "RO",
+    "RU", "RW", "KN", "LC", "WS", "ST", "SA", "SN", "RS", "SL", "SG",
+    "SK", "SI", "SB", "SO", "ZA", "GS", "ES", "LK", "SD", "SR", "SJ",
+    "SZ", "SE", "CH", "SY", "TW", "TJ", "TZ", "TH", "TL", "TG", "TO",
+    "TT", "TN", "TR", "TM", "TC", "UG", "UA", "AE", "GB", "US", "UY",
+    "UZ", "VU", "VE", "VN", "VG", "EH", "YE", "ZM", "ZW", ]
+
+  def self.to_ammap_country_data(reports, metric)
+    xml = Builder::XmlMarkup.new(:indent => 2)
+    zoom, zoom_x, zoom_y = zoom_levels
+    xml.map :map_file => 'maps/world.swf', :zoom_x => zoom_x, :zoom_y => zoom_y, :zoom => zoom do
+      xml.areas do
+        AMMAP_COUNTRIES.each do |country_code|
+          report      = reports.find { |report| report.id == country_code }
+          value       = report && report.send(metric) || 0
+          title_value = make_title_value(metric, value)
+
+          attributes = {
+            :title =>  "#{TZInfo::Country.code_to_name(country_code)}: #{title_value}",
+            :mc_name => country_code,
+            :value => value == 0 ? 0 : sprintf('%.8f', Math.log(value + 1))
+          }
+          xml.area attributes
+        end
+        xml.area :mc_name => "borders", :color => "#AAAAAA"
+      end
+    end
+    xml.target!
+  end
+
+  def self.zoom_levels
+    return "115%", "-0%", "-20%"
+  end
+
+  def self.to_ammap_metro_data(reports, metric)
+    xml = Builder::XmlMarkup.new(:indent => 2)
+    zoom, zoom_x, zoom_y = zoom_levels
+    color = "Graphs::#{metric.to_s.capitalize}".constantize.new.color1 rescue '85E006'
+    xml.map :map_file => 'maps/world.swf', :tl_long => "-168.49", :tl_lat => "83.63", :br_long => "190.3", :br_lat => "-55.58", :zoom_x => zoom_x, :zoom_y => zoom_y, :zoom => zoom do
+      xml.movies do
+        reports.select { |report| not report.id.blank? }.each do |report|
+          latitude, longitude = report.id.split(';')
+          bubble_size = calculate_bubble_size(report.send(metric))
+          title_value = make_title_value metric, report.send(metric)
+          xml.movie(:title      =>  "#{report.name}: #{title_value}",
+                    :lat        => latitude, 
+                    :long       => longitude,
+                    :file       => 'target',
+                    :width      => bubble_size, 
+                    :height     => bubble_size,
+                    :color      => color,
+                    :alpha      => 65,
+                    :fixed_size => true)
+        end
+      end
+
+      xml.areas do
+        AMMAP_COUNTRIES.each do |country_code|
+          xml.area :mc_name => country_code, :value => 0
+        end
+        xml.area :mc_name => "borders", :color => "#AAAAAA"
+      end
+    end
+
+    xml.target!
+  end
+
+  MinimumMapBubbleSize = 7
+
+  def self.calculate_bubble_size value
+    return 0 if value == 0
+    (MinimumMapBubbleSize + 5.0 * Math.log10(value)).to_i
+  end
+
+  def self.make_title_value metric, value
+    if [:bytes_transferred].include? metric
+      title_value = number_with_delimiter(number_to_human_size(value))  + ' transferred'
+    else
+      title_value = Pluralizer.pluralize(number_with_delimiter(value), singularize(metric))
+    end
+    title_value
+  end
+
+  private
+
+  def strip_keys_by_label(the_keys, label)
+    SUPPRESSED_LABELS.each do |key, labels|
+      the_keys = (the_keys - [ key ]) if labels.include?(label)
+    end
+    the_keys
+  end
+end

data/lib/stats/image_report.rb

@@ -0,0 +1,5 @@
+class Stats::ImageReport < Stats::EventReport
+  def self.csv_keys
+    [ :id, :name, :title, :hits, :bytes_transferred, :date, :start_date, :end_date ]
+  end
+end

data/lib/stats/latin_1_to_utf.rb

@@ -0,0 +1,10 @@
+require 'iconv'
+
+class String
+  def latin_1_to_utf
+    return '' if blank?
+    Iconv.new('UTF-8', 'ISO-8859-1').iconv self
+  end
+end
+
+

data/lib/stats/percent_watched_report.rb

@@ -0,0 +1,48 @@
+class Stats::PercentWatchedReport < Stats::Report
+  set_attributes          [ :label, :start_date, :end_date, :query_time ]
+  set_numeric_attributes  [ :percent_watched, :percent_of_watches, :fall_off, :watch_count ]
+  
+  def to_xml options = {}
+    xml = options[:builder] ||= Builder::XmlMarkup.new(:indent => options[:indent])
+    xml.instruct! unless options[:skip_instruct]
+
+    xml.__send__(@label) do
+      xml.percent_watched @percent_watched
+      xml.percent_of_watches @percent_of_watches
+      xml.fall_off @fall_off
+    end
+  end
+
+  def to_json(options = {})
+    report = HashWithIndifferentAccess.new
+    report['percent_watched'] = percent_watched
+    report['percent_of_watches'] = percent_of_watches
+    report['fall_off'] = fall_off
+    report.to_json
+  end
+  
+  def self.csv_keys
+    [ :percent_watched, :percent_of_watches, :fall_off ]
+  end
+  
+  def self.to_amcharts(reports, show_date, show_date_range, options = {})
+    xml = Builder::XmlMarkup.new
+    xml.instruct! :xml, :version => "1.0", :encoding => "UTF-8"
+    xml.chart do
+      xml.series do    
+        reports.each_with_index do |report, index|
+          xml.value "#{report.percent_watched.to_i}%", :xid => report.percent_watched
+        end
+      end
+
+      xml.graphs do
+        xml.graph :gid => 'percent_watched' do
+          reports.each_with_index do |report, index|
+            xml.value sprintf('%.1f', report.percent_of_watches), :xid => report.percent_watched
+          end
+        end
+      end
+    end
+  end
+
+end

data/lib/stats/publish_report.rb

@@ -0,0 +1,168 @@
+require 'stats/tzinfo_extensions'
+
+class Stats::PublishReport < Stats::EventReport
+  set_attributes         [ :id, :date, :start_date, :end_date, :title, :label, :name, :query_time, :bytes_uploaded, :bytes_encoded, :bytes_uploaded_gb, :bytes_encoded_gb ]
+  set_numeric_attributes [ :assets_uploaded, :assets_encoded, :duration_uploaded, :duration_encoded, :duration_uploaded_min, :duration_encoded_min ]
+
+  def initialize(options = {})
+    @start_date = options[:date]
+
+    if 'day' == options[:group]
+      @date     = options[:date]
+    else
+      @end_date = options[:date].advance(options[:advance_by] => 1).advance(:days => -1)
+    end
+
+    @label            = options[:label]
+
+    @assets_uploaded    = options[:assets_uploaded]
+    @assets_encoded   = options[:assets_encoded]
+
+    @query_time       = nil
+
+    @bytes_uploaded     = options[:bytes_uploaded]
+    @bytes_uploaded_gb  = ('%.2f' % (options[:bytes_uploaded] / 1.gigabyte.to_f)).to_f
+
+    @bytes_encoded    = options[:bytes_encoded]
+    @bytes_encoded_gb = ('%.2f' % (options[:bytes_encoded] / 1.gigabyte.to_f)).to_f
+
+    @duration_uploaded    = options[:duration_uploaded]
+    @duration_uploaded_min = ('%.2f' % (options[:duration_uploaded] / 60.seconds.to_f)).to_f
+
+    @duration_encoded    = options[:duration_encoded]
+    @duration_encoded_min = ('%.2f' % (options[:duration_encoded] / 60.seconds.to_f)).to_f
+  end
+
+  def self.csv_keys
+    [ :assets_encoded, :assets_uploaded, :bytes_encoded, :bytes_uploaded, :duration_uploaded, :duration_encoded, :date, :start_date, :end_date ]
+  end
+
+  def to_xml options = {}
+    xml = options[:builder] ||= Builder::XmlMarkup.new(:indent => options[:indent])
+    xml.instruct! unless options[:skip_instruct]
+
+    xml.__send__(@label) do
+      xml.assets_encoded @assets_encoded
+      xml.assets_uploaded @assets_uploaded
+      xml.bytes_encoded @bytes_encoded
+      xml.bytes_uploaded  @bytes_uploaded
+      xml.date(pretty_time(@date))             if @date
+      xml.duration_encoded @duration_encoded
+      xml.duration_uploaded  @duration_uploaded
+      xml.end_date(pretty_time(@end_date))     if @end_date
+      xml.start_date(pretty_time(@start_date)) if @start_date
+    end
+  end
+
+  def to_json(options = {})
+    report               = HashWithIndifferentAccess.new
+    report['assets_encoded']   = @assets_encoded
+    report['assets_uploaded']    = @assets_uploaded
+    report['bytes_encoded']    = @bytes_encoded
+    report['bytes_uploaded']     = @bytes_uploaded
+    report['date']             = pretty_time(@date)       if @date
+    report['duration_encoded'] = @duration_encoded
+    report['duration_uploaded']  = @duration_uploaded
+    report['end_date']         = pretty_time(@end_date)   if @end_date
+    report['start_date']       = pretty_time(@start_date) if @start_date
+
+    report.to_json
+  end
+
+  def self.to_amcharts(reports, show_date, show_date_range, options = {})
+    assets_encoded   = []
+    assets_uploaded    = []
+    bytes_encoded    = []
+    bytes_uploaded     = []
+    complete_labels  = []
+    duration_encoded = []
+    duration_uploaded  = []
+    guids            = []
+    labels           = []
+    urls             = []
+    reports         = reports.reverse if options[:reverse]
+
+    reports.each do |report|
+      label = case options[:group]
+              when 'daily'   ; "#{report.date.month}/#{report.date.day}"
+              when 'weekly'  ; "#{report.start_date.month}/#{report.start_date.day}-#{report.end_date.month}/#{report.end_date.day}"
+              when 'monthly' ; "#{report.start_date.strftime("%b \'%y")}"
+              else raise "invalid group: #{options[:group]}"
+              end
+
+      complete_labels  << label
+      labels           << label.previewize((options[:max_label_length] || 15).to_i)
+      assets_uploaded    << report.assets_uploaded
+      duration_uploaded  << report.duration_uploaded_min
+      bytes_uploaded     << report.bytes_uploaded_gb
+      assets_encoded   << report.assets_encoded
+      duration_encoded << report.duration_encoded_min
+      bytes_encoded    << report.bytes_encoded_gb
+      guids            << report.id
+    end
+
+    show_screenshots = reports.length <= 10
+
+    max_labels = 40
+    # frequency == 1 if we can display all labels, or a number greater
+    # than 1 if we can't
+    frequency = (show_date || show_date_range) ? 1 : (labels.length / max_labels.to_f).ceil
+
+    xml = options[:builder] ||= Builder::XmlMarkup.new(:indent => 2)
+    xml.instruct! :xml, :version=>"1.0", :encoding=>"UTF-8"
+    xml.chart do
+      xml.series do
+        labels.each_with_index do |value, index|
+          # only display every nth value where n depends the total
+          # number of labels and the max labels we are allowed to
+          # display, otherwise clear out the value
+          value = "" if index % frequency != 0
+          xml.value value, :xid => index
+        end
+      end
+
+      xml.graphs do
+        #the gid is used in the settings file to set different settings just for this graph
+        unless options[:show_uploads] == 'false'
+          xml.graph :gid => 'assets_uploaded' do
+            assets_uploaded.each_with_index do |value, index|
+              if value != 0 || show_date || show_date_range
+                xml.value value, :xid => index
+              end
+            end
+          end
+        end
+
+        unless options[:show_duration_uploaded] == 'false'
+          xml.graph :gid => 'duration_uploaded' do
+            duration_uploaded.each_with_index do |value, index|
+              if value != 0 || show_date || show_date_range
+                xml.value value, :xid => index
+              end
+            end
+          end
+        end
+
+        unless options[:show_encodes] == 'false'
+          xml.graph :gid => 'assets_encoded' do
+            assets_encoded.each_with_index do |value, index|
+              if value != 0 || show_date || show_date_range
+                xml.value value, :xid => index
+              end
+            end
+          end
+        end
+        
+        unless options[:show_duration_encoded] == 'false'
+          xml.graph :gid => 'duration_encoded' do
+            duration_encoded.each_with_index do |value, index|
+              if value != 0 || show_date || show_date_range
+                xml.value value, :xid => index
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/stats/report.rb

@@ -0,0 +1,122 @@
+class Stats::Report
+  def initialize options = {}
+    options.assert_valid_keys self.class.attributes
+
+    self.class.attributes.each { |a| instance_variable_set "@#{a}", nil }
+    options.each { |k, v| instance_variable_set "@#{k}", v }
+    self.class.numeric_attributes.each do |a|
+      attribute_name = "@#{a}"        
+      instance_variable_set(attribute_name, 0) if instance_variable_get(attribute_name).blank?
+    end
+  end
+  
+  def == other
+    self.class.attributes.all? do |e|
+      attribute_name = "@#{e}"        
+      instance_variable_get(attribute_name) == other.instance_variable_get(attribute_name)
+    end
+  end
+
+  def [] method_name
+    send method_name
+  end
+
+  def self.array_to_xml(report_array, options = {})
+    report_array.to_xml options.merge({:root => 'statistics-reports'})
+  end
+
+  def self.array_to_csv(report_array, options = {})
+    buf = ""
+
+    unless report_array.first.nil?
+      label          = report_array.first.label
+      new_options    = options.merge( { :label => label } )
+      the_csv_labels = options[:images] ? Stats::ImageReport.csv_labels : report_array[0].class.csv_labels
+      Stats::EventReport::SUPPRESSED_LABELS.each do |key, labels|
+        the_csv_labels = strip_label(key, the_csv_labels) if labels.include?(label)
+      end
+      
+
+      buf << the_csv_labels + "\n" unless report_array.empty?
+
+      report_array.each do |report|
+        buf << report.to_csv(new_options) + "\n"
+      end
+    end
+
+    buf
+  end
+
+  def self.strip_label(label_sym, labels_as_str)
+    labels = labels_as_str.split(/,/)
+    (labels - [ label_sym.to_s ]).join(',')
+  end
+  
+  def self.csv_keys
+    []
+  end
+  
+  def to_csv(options = {})
+    klass_keys = options[:images] ? Stats::ImageReport.csv_keys : self.class.csv_keys 
+    klass_keys.map { |k| self.class.format_csv_value(send(k)) }.join(',')
+  end
+  
+  def self.csv_labels
+    csv_keys.map { |k| format_csv_value(k.to_s) }.join(',')
+  end
+  
+  def self.format_csv_value(value)
+    return "\"#{value}\"" if value =~ /,/
+    value
+  end
+
+  def self.to_amcharts reports, *options
+    return reports.first.class.to_amcharts(reports, *options) unless reports.empty?
+    xml = Builder::XmlMarkup.new(:indent => 2)
+    xml.instruct! :xml, :version=>"1.0", :encoding=>"UTF-8"
+    xml.chart
+  end
+  
+  def self.pad_reports(reports, options)
+    limit = options["limit"].to_i
+    return reports if limit < 1 || reports.length < 1
+
+    # make a copy of the first report
+    clone = reports[0].clone
+    # blank out all text fields
+    clone.class.send(:attributes).each { |key| clone.send("#{key}=", "") }
+    # zero out all numeric fields
+    clone.class.send(:numeric_attributes).each { |key| clone.send("#{key}=", 0) }
+    # add empty reports at the end
+    (limit - reports.length).times { reports << clone }
+    reports
+  end
+
+  # class instance variables (@attributes and @numeric_attributes) are used to make
+  # validation, initialization, assignment, comparison, and accessor generation generic
+  def self.set_attributes attrs
+    attr_accessor *attrs
+    @attributes ||= []
+    @attributes.concat attrs
+  end
+
+  def self.set_numeric_attributes attrs
+    @numeric_attributes ||= []
+    @numeric_attributes.concat attrs
+    set_attributes attrs
+  end
+
+  private
+
+  def self.numeric_attributes
+    @numeric_attributes
+  end
+
+  def self.attributes
+    @attributes
+  end
+
+  def pretty_time(t)
+    t.strftime "%Y/%m/%d"
+  end
+end

data/lib/stats/source_report.rb

@@ -0,0 +1,106 @@
+require 'stats/tzinfo_extensions'
+
+class Stats::SourceReport < Stats::EventReport
+  set_attributes         [ :id, :date, :start_date, :end_date, :title, :label, :name, :query_time, :bytes_uploaded, :bytes_encoded, :bytes_uploaded_gb, :bytes_encoded_gb, :publish_type ]
+  set_numeric_attributes [ :publishes, :duration, :duration_min, :webcam_duration_min ]
+
+  def initialize(options = {})
+    @label           = options[:label]
+    @publish_type    = options[:publish_type]
+    @publishes       = options[:publishes] || 0
+    @query_time      = nil
+    @duration        = options[:duration].to_f || 0
+    @duration_min    = ('%.2f' % (@duration / 60.seconds.to_f)).to_f
+  end
+
+  def self.csv_keys
+    [ :publish_type, :publishes, :duration ]
+  end
+
+  def to_csv(options = {})
+    the_csv_keys = strip_keys_by_label(self.class.csv_keys, @label)
+    the_csv_keys.map do |k| 
+      self.class.format_csv_value(send(k))
+    end.join(',')
+  end
+
+  def to_xml options = {}
+    xml = options[:builder] ||= Builder::XmlMarkup.new(:indent => options[:indent])
+    xml.instruct! unless options[:skip_instruct]
+
+    xml.__send__(@label) do
+      xml.publish_type @publish_type
+      xml.publishes    @publishes
+      xml.duration     @duration
+    end
+  end
+
+  def to_json(options = {})
+    report                 = HashWithIndifferentAccess.new
+    report['publish_type'] = @publish_type
+    report['publishes']    = @publishes
+    report['duration']     = @duration
+
+    report.to_json
+  end
+
+  def self.to_amcharts(reports, show_date, show_date_range, options = {})
+    complete_labels = []
+    durations       = []
+    guids           = []
+    labels          = []
+    publishes       = []
+    reports         = pad_reports(reports, options) if options["pad"]
+    reports         = reports.reverse if options[:reverse]
+
+    reports.each do |report|
+      label = report.publish_type
+      label = '&lt;blank&gt;' if 'blank' == label
+
+      complete_labels << label
+      labels          << label.previewize((options[:max_label_length] || 15).to_i)
+      durations       << report.duration_min
+      publishes       << report.publishes
+      guids           << report.id
+    end
+
+    show_screenshots = reports.length <= 10
+
+    max_labels = 20
+    # frequency == 1 if we can display all labels, or a number greater than 1 if we can't
+    frequency = (labels.length / max_labels.to_f).ceil
+
+    xml = options[:builder] ||= Builder::XmlMarkup.new(:indent => 2)
+    xml.instruct! :xml, :version=>"1.0", :encoding=>"UTF-8"
+    xml.chart do
+      xml.series do
+        labels.each_with_index do |value, index|
+          # only display every nth value where n depends the total
+          # number of labels and the max labels we are allowed to
+          # display, otherwise clear out the value
+          value = "" if index % frequency != 0
+          xml.value value, :xid => index
+        end
+      end
+
+      xml.graphs do
+        #the gid is used in the settings file to set different settings just for this graph
+        unless options[:show_uploads] == 'false'
+          xml.graph :gid => 'uploads' do
+            publishes.each_with_index do |value, index|
+              xml.value value, :xid => index
+            end
+          end
+        end
+
+        unless options[:show_duration_uploaded] == 'false'
+          xml.graph :gid => 'duration_uploaded' do
+            durations.each_with_index do |value, index|
+              xml.value value, :xid => index
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/stats/tzinfo_extensions.rb

@@ -0,0 +1,13 @@
+require 'tzinfo'
+
+class TZInfo::Country
+  def self.code_to_name code
+    begin
+      get(code).name
+    rescue TZInfo::InvalidCountryCode
+      code
+    end
+  end
+end
+
+

data/lib/twistage_stats_reports.rb

@@ -0,0 +1,12 @@
+module Stats; end
+
+require 'stats/report'
+require 'stats/event_report'
+require 'stats/breakdown_report'
+require 'stats/disk_usage_report'
+require 'stats/image_report'
+require 'stats/latin_1_to_utf'
+require 'stats/percent_watched_report'
+require 'stats/publish_report'
+require 'stats/source_report'
+require 'stats/tzinfo_extensions'

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification 
+name: twistage_stats_reports
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- David Wegman
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-11-05 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: Shared data structures and logic for interacting with the Twistage Stats service
+email: dwegman@twistage.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/twistage_stats_reports.rb
+- lib/stats/breakdown_report.rb
+- lib/stats/disk_usage_report.rb
+- lib/stats/event_report.rb
+- lib/stats/image_report.rb
+- lib/stats/latin_1_to_utf.rb
+- lib/stats/percent_watched_report.rb
+- lib/stats/publish_report.rb
+- lib/stats/report.rb
+- lib/stats/source_report.rb
+- lib/stats/tzinfo_extensions.rb
+has_rdoc: true
+homepage: http://rubygems.org/gems/twistage_stats_reports
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Twistage Stats Reports
+test_files: []
+