referrer 1.0.0

data/app/controllers/referrer/application_controller.rb

@@ -0,0 +1,5 @@
+module Referrer
+  class ApplicationController < ActionController::Base
+    protect_from_forgery with: :exception
+  end
+end

data/app/controllers/referrer/sessions_controller.rb

@@ -0,0 +1,22 @@
+require_dependency 'referrer/application_controller'
+
+module Referrer
+  class SessionsController < ApplicationController
+    def create
+      user = Referrer::User.where(id: session_params[:user_id], token: session_params[:user_token]).first
+      if user
+        @session = user.sessions.active_at(Time.now).first
+        @session = user.sessions.create! unless @session
+        render json: {id: @session.id, active_seconds: @session.active_seconds}
+      else
+        render json: {errors: ['User token is incorrect']}, status: 401
+      end
+    end
+
+    private
+
+    def session_params
+      params.require(:session).permit(:user_id, :user_token)
+    end
+  end
+end

data/app/controllers/referrer/sources_controller.rb

@@ -0,0 +1,31 @@
+require_dependency 'referrer/application_controller'
+
+module Referrer
+  class SourcesController < ApplicationController
+    def mass_create
+      user = Referrer::User.where(id: mass_source_params[:user_id], token: mass_source_params[:user_token]).first
+      if user.present?
+        sessions = user.sessions
+        @sources = JSON.parse(mass_source_params[:values]).inject([]) do |r, pack|
+          session ||= sessions.detect{|s| s.id == pack['session_id'].to_i} ||
+              sessions.detect{|s| s.id == mass_source_params[:current_session_id].to_i}
+          if session.blank? || session.sources.exists?(client_duplicate_id: pack['client_duplicate_id'])
+            r
+          else
+            r << session.sources.create!(entry_point: pack['entry_point'], referrer: pack['referrer'],
+                                         client_duplicate_id: pack['client_duplicate_id'])
+          end
+        end
+        render json: {ids: @sources.map(&:id)}
+      else
+        render json: {errors: ['User token is incorrect']}, status: 401
+      end
+    end
+
+    private
+
+    def mass_source_params
+      params.require(:sources).permit(:user_id, :current_session_id, :user_token, :values)
+    end
+  end
+end

data/app/controllers/referrer/users_controller.rb

@@ -0,0 +1,10 @@
+require_dependency 'referrer/application_controller'
+
+module Referrer
+  class UsersController < ApplicationController
+    def create
+      @user = Referrer::User.create!
+      render json: {id: @user.id, token: @user.token}
+    end
+  end
+end

data/app/helpers/referrer/application_helper.rb

@@ -0,0 +1,4 @@
+module Referrer
+  module ApplicationHelper
+  end
+end

data/app/models/referrer/session.rb

@@ -0,0 +1,27 @@
+module Referrer
+  class Session < ActiveRecord::Base
+    belongs_to :user
+    has_many :sources
+
+    validates_presence_of :user, :active_until
+
+    before_validation :set_active_period
+
+    scope :active_at, -> (time) { where('active_from <= :time AND active_until >= :time', {time: time}) }
+
+    def active_seconds
+      (active_until - Time.now).to_i
+    end
+
+    def source_at(time)
+      sources.priority.where('created_at <= ?', time).last
+    end
+
+    private
+
+    def set_active_period
+      self.active_from = Time.now unless active_from
+      self.active_until = Time.now + Referrer.session_duration unless active_until
+    end
+  end
+end

data/app/models/referrer/source.rb

@@ -0,0 +1,46 @@
+module Referrer
+  class Source < ActiveRecord::Base
+    belongs_to :session
+
+    validates_presence_of :entry_point, :utm_source, :utm_campaign, :utm_medium, :utm_content, :utm_term, :session,
+                          :kind, :client_duplicate_id
+
+    before_validation :fill_markup_fields, on: :create
+    before_create :set_priority
+
+    scope :priority, -> {where(priority: true)}
+
+    class << self
+      def markup_generator
+        @markup_generator ||= begin
+          mg = MarkupGenerator.new
+          Referrer.markup_generator_settings.each do |k, v|
+            mg.send(:"#{k}=", v)
+          end
+          mg
+        end
+      end
+    end
+
+    def to_markup
+      attributes.slice(*%w{utm_source utm_campaign utm_medium utm_content utm_term kind})
+    end
+
+    private
+
+    def fill_markup_fields
+      markup = self.class.markup_generator.generate(referrer, entry_point)
+      %i{utm_source utm_campaign utm_medium utm_content utm_term kind}.each do |column_name|
+        self.send(:"#{column_name}=", markup[column_name])
+      end
+    end
+
+    def set_priority
+      previous_priority_source = session.sources.where(priority: true).last
+      if previous_priority_source.blank? ||
+          Referrer.sources_overwriting_schema[kind.to_sym].include?(previous_priority_source.kind)
+        self.priority = true
+      end
+    end
+  end
+end

data/app/models/referrer/sources_tracked_object.rb

@@ -0,0 +1,17 @@
+module Referrer
+  class SourcesTrackedObject < ActiveRecord::Base
+    belongs_to :trackable, polymorphic: true
+    belongs_to :user
+    belongs_to :source
+
+    validates_presence_of :trackable, :user, :linked_at
+    before_validation :set_fields, on: :create
+
+    private
+
+    def set_fields
+      self.linked_at = Time.now unless linked_at
+      self.source = user.try(:source_at, linked_at) if linked_at
+    end
+  end
+end

data/app/models/referrer/user.rb

@@ -0,0 +1,32 @@
+module Referrer
+  class User < ActiveRecord::Base
+    has_many :sessions
+    has_many :users_main_app_users
+
+    validates :token, presence: true
+
+    before_validation :generate_token, on: :create
+
+    def link_with(obj)
+      users_main_app_users.create(main_app_user: obj)
+    end
+
+    def linked_with?(obj)
+      users_main_app_users.where(main_app_user: obj).present?
+    end
+
+    def linked_objects
+      users_main_app_users.includes(:main_app_user).map{|relation| relation.main_app_user}
+    end
+
+    def source_at(time)
+      sessions.active_at(time).first.try(:source_at, time)
+    end
+
+    private
+
+    def generate_token
+      self.token = SecureRandom.hex(5)
+    end
+  end
+end

data/app/models/referrer/users_main_app_user.rb

@@ -0,0 +1,6 @@
+module Referrer
+  class UsersMainAppUser < ActiveRecord::Base
+    belongs_to :main_app_user, polymorphic: true
+    belongs_to :user
+  end
+end

data/app/views/layouts/referrer/application.html.erb

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Referrer</title>
+  <%= stylesheet_link_tag    "referrer/application", media: "all" %>
+  <%= javascript_include_tag "referrer/application" %>
+  <%= csrf_meta_tags %>
+</head>
+<body>
+
+<%= yield %>
+
+</body>
+</html>

data/config/routes.rb

@@ -0,0 +1,9 @@
+Referrer::Engine.routes.draw do
+  resources :users, only: :create
+  resources :sessions, only: :create
+  resources :sources, only: [] do
+    collection do
+      post :mass_create
+    end
+  end
+end

data/db/migrate/20160620130847_create_referrer_init_structure.rb

@@ -0,0 +1,58 @@
+class CreateReferrerInitStructure < ActiveRecord::Migration
+  def change
+    create_table :referrer_users do |t|
+      t.string :token
+
+      t.timestamps null: false
+    end
+
+    create_table :referrer_users_main_app_users do |t|
+      t.integer :user_id
+      t.integer :main_app_user_id
+      t.string  :main_app_user_type
+
+      t.timestamps null: false
+    end
+    add_index :referrer_users_main_app_users, [:main_app_user_type, :main_app_user_id], name: 'referrer_users_main_app_users_mau'
+    add_index :referrer_users_main_app_users, :user_id
+
+    create_table :referrer_sessions do |t|
+      t.integer :user_id
+      t.datetime :active_from
+      t.datetime :active_until
+
+      t.timestamps null: false
+    end
+    add_index :referrer_sessions, :user_id
+
+    create_table :referrer_sources do |t|
+      t.integer :session_id
+      t.string :referrer
+      t.string :entry_point
+      t.integer :client_duplicate_id
+      t.string :utm_source
+      t.string :utm_campaign
+      t.string :utm_medium
+      t.string :utm_content
+      t.string :utm_term
+      t.string :kind
+      t.boolean :priority, default: false
+
+      t.timestamps null: false
+    end
+    add_index :referrer_sources, :session_id
+
+    create_table :referrer_sources_tracked_objects do |t|
+      t.integer :user_id
+      t.integer :source_id
+      t.datetime :linked_at
+      t.integer :trackable_id
+      t.string  :trackable_type
+
+      t.timestamps null: false
+    end
+    add_index :referrer_sources_tracked_objects, [:trackable_type, :trackable_id], name: 'referrer_sources_tracked_objects_ta'
+    add_index :referrer_sources_tracked_objects, :user_id
+    add_index :referrer_sources_tracked_objects, :source_id
+  end
+end

data/lib/concerns/controllers/controller_additions.rb

@@ -0,0 +1,25 @@
+module Referrer
+  module ControllerAdditions
+    extend ActiveSupport::Concern
+
+    included do
+      before_action :link_referrer_user_to_app_user
+
+      def link_referrer_user_to_app_user
+        current_object = send(Referrer.current_user_method_name)
+        if current_object && referrer_user && !referrer_user.linked_with?(current_object)
+          referrer_user.link_with(current_object)
+        end
+      end
+
+      def referrer_user
+        @referrer ||= begin
+                        if cookies[:referrer_user].present?
+                          obj = JSON.parse(cookies[:referrer_user])
+                          Referrer::User.where(id: obj['id'], token: obj['token']).first
+                        end
+        end
+      end
+    end
+  end
+end

data/lib/concerns/models/owner_model_additions.rb

@@ -0,0 +1,35 @@
+module Referrer
+  module OwnerModelAdditions
+    extend ActiveSupport::Concern
+
+    included do
+      has_many :referrer_users_main_app_users, class_name: 'Referrer::UsersMainAppUser', as: :main_app_user
+
+      def referrer_users
+        referrer_users_main_app_users.includes(:user).map{|relation| relation.user}
+      end
+
+      def referrer_sources
+        Referrer::Source.where(
+            session_id: Referrer::Session.where(user_id: referrer_users_main_app_users.pluck(:user_id)).pluck(:id))
+      end
+
+      def referrer_first_source
+        referrer_sources.first
+      end
+
+      def referrer_priority_source
+        referrer_sources.priority.last
+      end
+
+      def referrer_last_source
+        referrer_sources.last
+      end
+
+      def referrer_markups
+        Hash[{first: referrer_first_source, priority: referrer_priority_source,
+         last: referrer_last_source}.map{|k, v| [k, v.try(:to_markup).try(:symbolize_keys!)]}]
+      end
+    end
+  end
+end

data/lib/concerns/models/tracked_model_additions.rb

@@ -0,0 +1,21 @@
+module Referrer
+  module TrackedModelAdditions
+    extend ActiveSupport::Concern
+
+    included do
+      has_one :tracked_relation, as: :trackable, class_name: 'Referrer::SourcesTrackedObject'
+
+      def referrer_link_with(r_user, linked_at: nil)
+        create_tracked_relation(user: r_user, linked_at: linked_at)
+      end
+
+      def referrer_link_with!(r_user, linked_at: nil)
+        create_tracked_relation!(user: r_user, linked_at: linked_at)
+      end
+
+      def referrer_markup
+        tracked_relation.try(:source).try(:to_markup).try(:symbolize_keys!)
+      end
+    end
+  end
+end

data/lib/modules/statistics.rb

@@ -0,0 +1,25 @@
+module Referrer
+  module Statistics
+    class << self
+      def sources_markup(from, to)
+        Referrer::Source.where('created_at >= ? AND created_at <= ?', from, to).group_by do |source|
+          source.to_markup.symbolize_keys!
+        end.map do |markup, matches|
+          markup.merge({count: matches.size})
+        end
+      end
+
+      def tracked_objects_markup(from, to, type: nil)
+        result = Referrer::SourcesTrackedObject.where('linked_at >= ? AND linked_at <= ?', from, to).includes(:source)
+        result = result.where(trackable_type: type) if type.present?
+        result.map{|item| item.source}.select do |source|
+          source.present?
+        end.group_by do |source|
+          source.to_markup.symbolize_keys!
+        end.map do |markup, matches|
+          markup.merge({count: matches.size})
+        end
+      end
+    end
+  end
+end

data/lib/other/markup_generator.rb

@@ -0,0 +1,112 @@
+module Referrer
+  class MarkupGenerator
+    UTM_KEYS = %w(utm_source utm_medium utm_campaign utm_content utm_term)
+    ORGANICS = [{host: 'search.daum.net', param: 'q'},
+                {host: 'search.naver.com', param: 'query'},
+                {host: 'search.yahoo.com', param: 'p'},
+                {host: /^(www\.)?google\.[a-z]+$/, param: 'q', display: 'google'},
+                {host: 'www.bing.com', param: 'q'},
+                {host: 'search.aol.com', params: 'q'},
+                {host: 'search.lycos.com', param: 'q'},
+                {host: 'edition.cnn.com', param: 'text'},
+                {host: 'index.about.com', param: 'q'},
+                {host: 'mamma.com', param: 'q'},
+                {host: 'ricerca.virgilio.it', param: 'qs'},
+                {host: 'www.baidu.com', param: 'wd'},
+                {host: /^(www\.)?yandex\.[a-z]+$/, param: 'text', display: 'yandex'},
+                {host: 'search.seznam.cz', param: 'oq'},
+                {host: 'www.search.com', param: 'q'},
+                {host: 'search.yam.com', param: 'k'},
+                {host: 'www.kvasir.no', param: 'q'},
+                {host: 'buscador.terra.com', param: 'query'},
+                {host: 'nova.rambler.ru', param: 'query'},
+                {host: 'go.mail.ru', param: 'q'},
+                {host: 'www.ask.com', param: 'q'},
+                {host: 'searches.globososo.com', param: 'q'},
+                {host: 'search.tut.by', param: 'query'}]
+
+    REFERRALS = [{host: /^(www\.)?t\.co$/, display: 'twitter.com'},
+                 {host: /^(www\.)?plus\.url\.google\.com$/, display: 'plus.google.com'}]
+
+    attr_accessor :organics, :referrals, :utm_synonyms, :array_params_joiner
+
+    def initialize
+      @organics = ORGANICS
+      @referrals = REFERRALS
+      @utm_synonyms = UTM_KEYS.inject({}){|r, key| r.merge({key => []})}
+      @array_params_joiner = ', '
+    end
+
+    def generate(referrer, entry_point)
+      referrer_uri, entry_point_uri = *[referrer, entry_point].map{|url| URI(URI::encode(url || ''))}
+      referrer_params, entry_point_params = *[referrer_uri, entry_point_uri].map{|uri| uri_params(uri)}
+      prepare_result(utm(entry_point_params) || organic(referrer_uri, referrer_params) ||
+                         referral(referrer_uri) || direct)
+    end
+
+    private
+
+    def uri_params(uri)
+      Rack::Utils.parse_query(uri.try(:query))
+    end
+
+    def base_result
+      UTM_KEYS.inject({}){|r, key| r.merge!(key => '(none)')}
+    end
+
+    def check_host(option, value)
+      case option
+        when String
+          option == value
+        when Regexp
+          option =~ value
+        else
+          false
+      end
+    end
+
+    def prepare_result(markup)
+      Hash[markup.map{|k, v| [k, v.is_a?(Array) ? v.join(array_params_joiner) : v]}].symbolize_keys
+    end
+
+    def utm(entry_point_params)
+      if (entry_point_params.keys & (UTM_KEYS + utm_synonyms.values.flatten)).present?
+        UTM_KEYS.inject(base_result) do |r, key|
+          values = if utm_synonyms[key.to_sym].present?
+                     [].push(entry_point_params[key]).push([utm_synonyms[key.to_sym]].flatten.map do |synonym_key|
+                                                             entry_point_params[synonym_key]
+                                                           end)
+                   else
+                     [entry_point_params[key]]
+                   end.flatten.compact.map{|value| URI::decode(value)}
+          values.present? ? r.merge!({key => values}) : r
+        end.merge('kind' => 'utm')
+      end
+    end
+
+    def organic(referrer_uri, referrer_params)
+      if referrer_uri.to_s.present?
+        current_organic = organics.detect{|organic| check_host(organic[:host], referrer_uri.host)}
+        base_result.merge!({'utm_source' => current_organic[:display] || current_organic[:host].split('.')[-2],
+                            'utm_medium' => 'organic',
+                            'utm_term' => referrer_params[current_organic[:param]] || '(none)',
+                            'kind' => 'organic'}) if current_organic.present?
+      end
+    end
+
+    def referral(referrer_uri)
+      if referrer_uri.to_s.present?
+        custom_referral = referrals.detect{|referral| check_host(referral[:host], referrer_uri.host)}
+        base_result.merge!(
+            'utm_source' => custom_referral ? custom_referral[:display] : referrer_uri.host.gsub('www.', ''),
+            'utm_medium' => 'referral',
+            'utm_content' => URI::decode(referrer_uri.request_uri) || '(none)',
+            'kind' => 'referral')
+      end
+    end
+
+    def direct
+      base_result.merge!('utm_source' => '(direct)', 'kind' => 'direct')
+    end
+  end
+end