mountain-goat 0.0.1

data/lib/mountain_goat/controllers/mountain_goat/mountain_goat_metrics_controller.rb

@@ -0,0 +1,108 @@
+class MountainGoatMetricsController < MountainGoatController
+  
+  # GET /metrics
+  # GET /metrics.xml
+  def index
+    @metrics = Metric.all
+
+    respond_to do |format|
+      format.html # index.html.erb
+      format.xml  { render :xml => @metrics }
+    end
+  end
+
+  # GET /metrics/1
+  # GET /metrics/1.xml
+  def show
+    @metric = Metric.find(params[:id])
+
+    @rates = {}
+    @rates[:served] = []
+    @rates[:conversions] = []
+    @rates[:conversion_rates] = []
+    @rates[:titles] = {}
+    i = 0
+    @metric.metric_variants.each do |mv|
+      @rates[:served].push( { :variant_type => i, :value => mv.served } )
+      @rates[:conversions].push( { :variant_type => i, :value => mv.conversions } )
+      @rates[:conversion_rates].push( { :variant_type => i, :value => mv.conversion_rate } )
+      @rates[:titles].merge!({i => mv.name})
+      i += 1
+    end
+    
+    logger.warn @rates[:titles].inspect
+    
+    respond_to do |format|
+      format.html # show.html.erb
+      format.xml  { render :xml => @metric }
+    end
+  end
+
+  # GET /metrics/new
+  # GET /metrics/new.xml
+  def new
+    @convert = Convert.find(params[:mountain_goat_convert_id])
+    @metric = Metric.new(:convert_id => @convert.id)
+
+    respond_to do |format|
+      format.html # new.html.erb
+      format.xml  { render :xml => @metric }
+    end
+  end
+
+  # GET /metrics/1/edit
+  def edit
+    @metric = Metric.find(params[:id])
+  end
+
+  # POST /metrics
+  # POST /metrics.xml
+  def create
+    @metric = Metric.new(params[:metric])
+
+    if @metric.save
+      flash[:notice] = 'Metric was successfully created.'
+      redirect_to mountain_goat_metric_url :id => @metric.id
+    else
+      render :action => "new"
+    end
+  end
+
+  # PUT /metrics/1
+  # PUT /metrics/1.xml
+  def update
+    @metric = Metric.find(params[:id])
+
+    if @metric.update_attributes(params[:metric])
+      flash[:notice] = 'Metric was successfully updated.'
+      redirect_to mountain_goat_metric_url :id => @metric.id
+    else
+      render :action => "edit"
+    end
+  end
+
+  # DELETE /metrics/1
+  # DELETE /metrics/1.xml
+  def destroy
+    @metric = Metric.find(params[:id])
+    @metric.destroy
+
+    respond_to do |format|
+      format.html { redirect_to(mountain_goat_metrics_url) }
+      format.xml  { head :ok }
+    end
+  end
+  
+  def fresh_metrics
+    #clear metrics
+    #logger.warn "Headerish #{response.headers['cookie']}"
+    cookies.each do |cookie|
+      if cookie[0] =~ /metric_([a-z0-9_]+)/
+        logger.warn "Deleting cookie #{cookie[0]}"
+        cookies.delete cookie[0], :domain => WILD_DOMAIN
+      end
+    end
+    flash[:notice] = "Your metrics have been cleared from cookies."
+    redirect_to :back
+  end
+end

data/lib/mountain_goat/controllers/mountain_goat/mountain_goat_rallies_controller.rb

@@ -0,0 +1,3 @@
+class MountainGoatRalliesController < MountainGoatController
+  
+end

data/lib/mountain_goat/metric_tracking.rb

@@ -0,0 +1,241 @@
+require File.join([File.dirname(__FILE__), 'switch_variant'])
+
+module MetricTracking
+  
+  #Metric Tracking routes
+  class << ActionController::Routing::Routes;self;end.class_eval do
+    define_method :clear!, lambda {}
+  end
+  
+  #TODO: Namespace?
+  ActionController::Routing::Routes.draw do |map|
+    map.mg '/mg', :controller => :mountain_goat_converts, :action => :index
+    map.resources :mountain_goat_metric_variants
+    map.resources :mountain_goat_converts, :has_many => :mountain_goat_metrics
+    map.resources :mountain_goat_metrics, :has_many => :mountain_goat_metric_variants
+    map.resources :mountain_goat_upgrade_orders
+    map.fresh_metrics '/fresh-metrics', :controller => :mountain_goat_metrics, :action => :fresh_metrics  
+  end
+  
+  module Controller
+  
+    ######################
+    #   Metric Tracking  #
+    ######################
+  
+    def sv(metric_type, convert_type, &block)
+      raise ArgumentError, "Switch variant needs block" if !block_given?
+      metric, convert = get_metric_convert( metric_type, convert_type, true )
+      block.call(SwitchVariant.new( logger, metric, convert, nil ) )
+      
+      var = get_switch_metric_variant(metric_type, convert_type)
+      block.call(SwitchVariant.new( logger, metric, convert, var ) )
+    end
+    
+    def mv(metric_type, convert_type, default)
+      return get_metric_variant(metric_type, convert_type, default)
+    end
+  
+    #shorthand
+    def rc(convert_type, options = {})
+      self.record_conversion(convert_type, options)
+    end
+    
+    def record_conversion(convert_type, options = {})
+      
+      #We want some system for easy default parameter setting
+      if options.include?(:refs) && options[:refs]
+        options = options.merge( :ref_domain => session[:ref_domain], :ref_flyer => session[:ref_flyer], :ref_user => session[:ref_user] )
+        options.delete(:refs)
+      end
+      
+      if options.include?(:user) && options[:user]
+        options = options.merge( :user_id => current_user.id ) if signed_in?
+        options.delete(:user)
+      end
+      
+      if options.include?(:invitees) && options[:invitees]
+        invitee_meta = {}
+        if session[:invitee_id]
+          invitee = Invitee.find_by_id(session[:invitee_id])
+          if invitee.mailer.clique == @clique
+            options.merge!( { :mailer_id => invitee.mailer.id } )
+          end
+        end
+        options.delete(:invitees)
+      end
+      
+      logger.warn "Recording conversion #{convert_type.to_s} with options #{options.inspect}"
+      
+      convert = Convert.first( :conditions => { :convert_type => convert_type.to_s } )
+      
+      #now, we just create the convert if we don't have one
+      convert = Convert.create!( :convert_type => convert_type.to_s, :name => convert_type.to_s ) if convert.nil?
+      
+      #first, let's tally for the conversion itself
+      #we need to see what meta information we should fill based on the conversion type
+      Rally.create!( { :convert_id => convert.id } ).set_meta_data(options)
+      
+      #we just converted, let's tally each of our metrics (from cookies)
+      convert.metrics.each do |metric|
+        metric_sym = "metric_#{metric.metric_type}".to_sym
+        metric_variant_sym = "metric_#{metric.metric_type}_variant".to_sym
+        
+        value = cookies[metric_sym]
+        variant_id = cookies[metric_variant_sym]
+        
+        #logger.warn "Value: #{metric_sym} - #{value}"
+        #logger.warn "Value: #{metric_variant_sym} - #{variant_id}"
+        
+        if variant_id.blank? #the user just doesn't have this set
+          next
+        end
+        
+        variant = MetricVariant.first(:conditions => { :id => variant_id.to_i } )
+        
+        if variant.nil?
+          logger.error "Variant #{variant_id} not in metric variants for #{metric.title}"
+          next
+        end
+        
+        if variant.value != value
+          logger.warn "Variant #{variant.name} values differ for metric #{metric.title}.  '#{variant.value}' != '#{value}'!"
+        end
+        
+        logger.warn "Tallying conversion #{convert.name} for #{metric.title} - #{variant.name} (#{variant.value} - #{variant.id})"
+        variant.tally_convert
+      end
+    end
+    
+    private
+    
+    def get_metric_variant(metric_type, convert_type, default)
+      metric_sym = "metric_#{metric_type}".to_sym
+      metric_variant_sym = "metric_#{metric_type}_variant".to_sym
+      
+      #first, we'll check for a cookie value
+      if cookies[metric_sym] && !cookies[metric_sym].blank?
+        #we have the cookie
+        
+        variant_id = cookies[metric_variant_sym]
+        variant = MetricVariant.first(:conditions => { :id => variant_id.to_i } )
+        if !variant.nil?
+          if variant.metric.tally_each_serve
+            variant.tally_serve
+          end
+        else
+          logger.warn "Serving metric #{metric_type} without finding / tallying variant."
+        end
+        
+        return cookies[metric_sym] #it's the best we can do
+      else
+        #we don't have the cookie, let's find a value to set
+        metric, convert = get_metric_convert( metric_type, convert_type, false )
+        
+        #to use RAND(), let's not use metrics.metric_variants
+        sum_priority = MetricVariant.first(:select => "SUM(priority) as sum_priority", :conditions => { :metric_id => metric.id } ).sum_priority.to_f
+        
+        if sum_priority > 0.0
+          metric_variant = MetricVariant.first(:order => "RAND() * ( priority / #{sum_priority.to_f} ) DESC", :conditions => { :metric_id => metric.id } )
+        end
+        
+        if metric_variant.nil?
+          logger.warn "Missing metric variants for #{metric_type}"
+          metric_variant = MetricVariant.create!( :metric_id => metric.id, :value => default, :name => default )
+        end
+        
+        metric_variant.tally_serve #donate we served this to a user
+        logger.debug "Serving #{metric_variant.name} (#{metric_variant.value}) for #{metric_sym}"
+        #good, we have a variant, let's store it in session
+        cookies[metric_sym] = { :value => metric_variant.value } #, :domain => WILD_DOMAIN
+        cookies[metric_variant_sym] = { :value => metric_variant.id } #, :domain => WILD_DOMAIN
+        
+        return metric_variant.value
+      end
+    end
+    
+    def get_switch_metric_variant(metric_type, convert_type)
+      metric_variant_sym = "metric_#{metric_type}_variant".to_sym
+      
+      #first, we'll check for a cookie selection
+      if cookies[metric_variant_sym] && !cookies[metric_variant_sym].blank?
+        #we have the cookie
+        
+        variant_id = cookies[metric_variant_sym]
+        variant = MetricVariant.first(:conditions => { :id => variant_id.to_i } )
+        if !variant.nil?
+        
+          if variant.metric.tally_each_serve
+            variant.tally_serve
+          end
+          
+          return variant
+          
+        end
+        
+        #otherwise, it's a big wtf? let's just move on
+        logger.warn "Missing metric variant for #{metric_type} (switch-type), reassigning..."
+      end
+        
+      #we don't have the cookie, let's find a value to set
+      metric, convert = get_metric_convert( metric_type, convert_type, true )
+      
+      #to use RAND(), let's not use metrics.metric_variants
+      sum_priority = MetricVariant.first(:select => "SUM(priority) as sum_priority", :conditions => { :metric_id => metric.id } ).sum_priority.to_f
+      
+      if sum_priority > 0.0
+        metric_variant = MetricVariant.first(:order => "RAND() * ( priority / #{sum_priority.to_f} ) DESC", :conditions => { :metric_id => metric.id } )
+      end
+      
+      if metric_variant.nil?
+        logger.warn "Missing metric variants for #{metric_type}"
+        raise ArgumentError, "Missing variants for switch-type #{metric_type}"
+      end
+      
+      metric_variant.tally_serve #donate we served this to a user
+      logger.debug "Serving #{metric_variant.name} (#{metric_variant.switch_type}) for #{metric.title} (switch-type)"
+      #good, we have a variant, let's store it in session (not the value, just the selection)
+      cookies[metric_variant_sym] = { :value => metric_variant.id } #, :domain => WILD_DOMAIN
+      
+      return metric_variant
+    end
+    
+    def get_metric_convert(metric_type, convert_type, is_switch = false)
+      
+      metric = Metric.first(:conditions => { :metric_type => metric_type.to_s } )
+      
+      conv = Convert.find_by_convert_type( convert_type.to_s )
+      if conv.nil?
+        logger.warn "Missing convert type #{convert_type.to_s} -- creating"  
+        conv = Convert.create( :convert_type => convert_type.to_s, :name => convert_type.to_s ) if conv.nil?
+      end
+        
+      if metric.nil? #we don't have a metric of this type
+        logger.warn "Missing metric type #{metric_type.to_s} -- creating"
+        metric = Metric.create( :metric_type => metric_type.to_s, :title => metric_type.to_s, :convert_id => conv.id, :is_switch => is_switch )
+      end
+      
+      return metric, conv
+    end
+  end
+  
+  module View
+    def mv(*args, &block)
+      @controller.send(:mv, *args, &block)
+    end
+    
+    def sv(*args, &block)
+      @controller.send(:sv, *args, &block)
+    end
+  end
+end
+
+class ActionController::Base
+  include MetricTracking::Controller
+end
+
+class ActionView::Base
+  include MetricTracking::View
+end
+
+

data/lib/mountain_goat/models/ci_meta.rb

@@ -0,0 +1,9 @@
+class CiMeta < ActiveRecord::Base
+  
+  belongs_to :convert_meta_type
+  belongs_to :rally
+  
+  validates_presence_of :convert_meta_type_id
+  validates_presence_of :rally_id
+  
+end

data/lib/mountain_goat/models/convert.rb

@@ -0,0 +1,70 @@
+class Convert < ActiveRecord::Base
+  
+  has_many :metrics
+  has_many :rallies
+  has_many :convert_meta_types
+  has_many :ci_metas, :through => :convert_meta_types
+  has_many :cs_metas, :through => :convert_meta_types
+  
+  validates_presence_of :name
+  validates_format_of :convert_type, :with => /[a-z0-9_]{3,50}/i, :message => "must be between 3 and 30 characters, alphanumeric with underscores"
+  validates_uniqueness_of :convert_type  
+  
+  accepts_nested_attributes_for :convert_meta_types, :reject_if => lambda { |a| a[:name].blank? || a[:var].blank? || a[:meta_type].blank? }, :allow_destroy => true
+  
+  def self.by_type(s)
+    Convert.find( :first, :conditions => { :convert_type => s.to_s } )
+  end
+  
+  def rallies_for_meta(var)
+    cmt = self.convert_meta_types.find_by_var( var.to_s )
+    return {} if cmt.nil?
+    cmt.meta.map { |m| { m.data => m.rally } }
+  end
+  
+  def rallies_for_meta_val(var, data)
+    cmt = self.convert_meta_types.find_by_var( var.to_s )
+    return [] if cmt.nil?
+    cmt.meta.find(:all, :conditions => { :data => data } ).map { |m| m.rally }
+  end
+  
+  def rallies_for_meta_val_pivot(var, data, pivot)
+    res = {}
+    cmt = self.convert_meta_types.find_by_var( var.to_s )
+    cmt_pivot = self.convert_meta_types.find_by_var( pivot.to_s )
+    return {} if cmt.nil? || cmt_pivot.nil?
+    cmt.meta.find(:all, :select => "`#{cmt.meta.table_name}`.created_at, cm.data AS pivot", :conditions => { :data => data }, :joins => "LEFT JOIN `#{cmt_pivot.meta.table_name}` cm ON cm.convert_meta_type_id = #{cmt_pivot.id} AND cm.rally_id = `#{cmt.meta.table_name}`.rally_id").each do |c|
+      if !res.include?(c.pivot)
+        res[c.pivot] = []
+      end
+      
+      res[c.pivot].push c.created_at
+    end
+    
+    res.each { |k,v| v.sort! }
+    res
+  end
+  
+  def rallies_for_meta_val_pivot_item(var, data, pivot, item)
+    res = {}
+    cmt = self.convert_meta_types.find_by_var( var.to_s )
+    cmt_pivot = self.convert_meta_types.find_by_var( pivot.to_s )
+    cmt_item = self.convert_meta_types.find_by_var( item.to_s )
+    return {} if cmt.nil? || cmt_pivot.nil? || cmt_item.nil?
+    cmt.meta.find(:all, :select => "`#{cmt.meta.table_name}`.created_at, cm.data AS pivot, ci.data as item", :conditions => { :data => data }, :joins => "LEFT JOIN `#{cmt_pivot.meta.table_name}` cm ON cm.convert_meta_type_id = #{cmt_pivot.id} AND cm.rally_id = `#{cmt.meta.table_name}`.rally_id LEFT JOIN `#{cmt_item.meta.table_name}` ci ON ci.convert_meta_type_id = #{cmt_item.id} AND ci.rally_id = `#{cmt.meta.table_name}`.rally_id").each do |c|
+      if !res.include?(c.pivot)
+        res[c.pivot] = []
+      end
+      
+      if cmt_item.meta_type == 'ci_meta'
+        c.item.to_i.times { res[c.pivot].push c.created_at }
+      else
+        res[c.pivot].push c.created_at if c.item == 'yes' #what else?
+      end  
+    end
+    
+    res.each { |k,v| v.sort! }
+    res.delete_if { |k,v| v.count == 0 }
+    res
+  end
+end

data/lib/mountain_goat/models/convert_meta_type.rb

@@ -0,0 +1,19 @@
+class ConvertMetaType < ActiveRecord::Base
+  
+  belongs_to :convert
+  has_many :ci_metas, :class_name => 'CiMeta', :dependent => :destroy 
+  has_many :cs_metas, :class_name => 'CsMeta', :dependent => :destroy
+  
+  validates_presence_of :name
+  validates_presence_of :var
+  validates_presence_of :meta_type
+  
+  def meta
+    case self.meta_type
+    when 'ci_meta'
+      return self.ci_metas
+    when 'cs_meta'
+      return self.cs_metas
+    end
+  end
+end