impressionist/app/controllers/impressionist_controller.rb

155 lines
4.9 KiB
Ruby

require 'digest/sha2'
module ImpressionistController
module ClassMethods
def impressionist(opts={})
if Rails::VERSION::MAJOR >= 5
before_action { |c| c.impressionist_subapp_filter(opts) }
else
before_filter { |c| c.impressionist_subapp_filter(opts) }
end
end
end
module InstanceMethods
def self.included(base)
if Rails::VERSION::MAJOR >= 5
base.before_action :impressionist_app_filter
else
base.before_filter :impressionist_app_filter
end
end
def impressionist(obj,message=nil,opts={})
if should_count_impression?(opts)
if obj.respond_to?("impressionable?")
if unique_instance?(obj, opts[:unique])
obj.impressions.create(associative_create_statement({:message => message}))
end
else
# we could create an impression anyway. for classes, too. why not?
raise "#{obj.class.to_s} is not impressionable!"
end
end
end
def impressionist_app_filter
@impressionist_hash = Digest::SHA2.hexdigest(Time.now.to_f.to_s+rand(10000).to_s)
end
def impressionist_subapp_filter(opts = {})
if should_count_impression?(opts)
actions = opts[:actions]
actions.collect!{|a|a.to_s} unless actions.blank?
if (actions.blank? || actions.include?(action_name)) && unique?(opts[:unique])
Impression.create(direct_create_statement)
end
end
end
protected
# creates a statment hash that contains default values for creating an impression via an AR relation.
def associative_create_statement(query_params={})
query_params.reverse_merge!(
:controller_name => controller_name,
:action_name => action_name,
:user_id => user_id,
:request_hash => @impressionist_hash,
:session_hash => session_hash,
:ip_address => request.remote_ip,
:referrer => request.referer,
:params => params_hash
)
end
private
def bypass
Impressionist::Bots.bot?(request.user_agent)
end
def should_count_impression?(opts)
!bypass && condition_true?(opts[:if]) && condition_false?(opts[:unless])
end
def condition_true?(condition)
condition.present? ? conditional?(condition) : true
end
def condition_false?(condition)
condition.present? ? !conditional?(condition) : true
end
def conditional?(condition)
condition.is_a?(Symbol) ? self.send(condition) : condition.call
end
def unique_instance?(impressionable, unique_opts)
return unique_opts.blank? || !impressionable.impressions.where(unique_query(unique_opts, impressionable)).exists?
end
def unique?(unique_opts)
return unique_opts.blank? || check_impression?(unique_opts)
end
def check_impression?(unique_opts)
impressions = Impression.where(unique_query(unique_opts - [:params]))
check_unique_impression?(impressions, unique_opts)
end
def check_unique_impression?(impressions, unique_opts)
impressions_present = impressions.exists?
impressions_present && unique_opts_has_params?(unique_opts) ? check_unique_with_params?(impressions) : !impressions_present
end
def unique_opts_has_params?(unique_opts)
unique_opts.include?(:params)
end
def check_unique_with_params?(impressions)
request_param = params_hash
impressions.detect{|impression| impression.params == request_param }.nil?
end
# creates the query to check for uniqueness
def unique_query(unique_opts,impressionable=nil)
full_statement = direct_create_statement({},impressionable)
# reduce the full statement to the params we need for the specified unique options
unique_opts.reduce({}) do |query, param|
query[param] = full_statement[param]
query
end
end
# creates a statment hash that contains default values for creating an impression.
def direct_create_statement(query_params={},impressionable=nil)
query_params.reverse_merge!(
:impressionable_type => controller_name.singularize.camelize,
:impressionable_id => impressionable.present? ? impressionable.id : params[:id]
)
associative_create_statement(query_params)
end
def session_hash
# # careful: request.session_options[:id] encoding in rspec test was ASCII-8BIT
# # that broke the database query for uniqueness. not sure if this is a testing only issue.
# str = request.session_options[:id]
# logger.debug "Encoding: #{str.encoding.inspect}"
# # request.session_options[:id].encode("ISO-8859-1")
request.session_options[:id]
end
def params_hash
request.params.except(:controller, :action, :id)
end
#use both @current_user and current_user helper
def user_id
user_id = @current_user ? @current_user.id : nil rescue nil
user_id = current_user ? current_user.id : nil rescue nil if user_id.blank?
user_id
end
end
end