neuron-client 0.2.6 → 0.3.0

data/lib/neuron-client/model/common/ad_calculations.rb

@@ -1,329 +0,0 @@
-module Neuron
-  module Client
-    module Model
-      module Common
-        module AdCalculations
-          # This module expects the following methods to be defined:
-          # start_datetime (Time, String, or nil)
-          # end_datetime (Time, String, or nil)
-          # time_zone (String)
-          # day_partitions (String, or nil, length = 7*24, matches /^[TF]+$/)
-          # daily_cap (FixNum, or nil)
-          # overall_cap (FixNum, or nil)
-          # ideal_impressions_per_hour (Number, or nil)
-          # total_impressed (Integer, >= 0)
-          # today_impressed (Integer, >= 0)
-
-          def active?
-            calculate_active?(Time.now, total_impressed, today_impressed)
-          end
-
-          def pressure
-            calculate_pressure(Time.now, total_impressed, today_impressed)
-          end
-
-          def calculate_active?(time, total, today)
-            time = time.in_time_zone(time_zone)
-            return false unless within_date_range?(time)
-            return false if partitioned? && !partitioned_hour?(time)
-            !cap_met?(total, today)
-          end
-
-          # Set the optional "active" parameter to true or false if you already know
-          def calculate_pressure(time, total, today, active=nil)
-            return nil if active == false
-            return nil unless active || calculate_active?(time,total,today)
-            time = time.in_time_zone(time_zone)
-            if daily_capped?
-              if daily_cap_precludes_overall_cap?(time,total,today)
-                calculate_overall_pressure(time, total)
-              else
-                calculate_today_pressure(time, today)
-              end
-            elsif overall_pressure_exists?
-              calculate_overall_pressure(time, total)
-            else
-              (ideal_impressions_per_hour || 1.0).to_f
-            end
-          end
-
-          private
-
-          def in_ad_time_zone(time)
-            if time.present?
-              (time.is_a?(String) ? Time.parse(time) : time).in_time_zone(time_zone)
-            end
-          rescue
-            nil
-          end
-
-          def start_in_time_zone
-            in_ad_time_zone(start_datetime)
-          end
-
-          def end_in_time_zone
-            in_ad_time_zone(end_datetime)
-          end
-
-          def daily_capped?
-            !daily_cap.nil? && daily_cap >= 0
-          end
-
-          def overall_capped?
-            !overall_cap.nil? && overall_cap >= 0
-          end
-
-          def overall_pressure_exists?
-            overall_capped? && end_datetime.present?
-          end
-
-          def partitioned?
-            !day_partitions.nil? && day_partitions.length == 24*7
-          end
-
-          def within_date_range?(time)
-            return false if start_datetime.present? && time < start_in_time_zone
-            return false if end_datetime.present? && time >= end_in_time_zone
-            true
-          end
-
-          # Assume time is in the time zone of the ad.
-          # Doesn't worry about whether or not the time is in the ad's date range.
-          # Assumes ad is partitioned.
-          def partitioned_hour?(time)
-            day_partitions.at((time.wday * 24) + time.hour) == 'T'
-          end
-
-          # Assume time is in the time zone of the ad.
-          # Doesn't worry about whether or not the time is in the ad's date range.
-          # Assumes ad is partitioned.
-          # Returns true if there is any active partition the day of the given time.
-          def partitioned_day?(time)
-            day_partitions[(time.wday) * 24, 24].include?('T')
-          end
-
-          # Assumes time is in the time zone of the ad.
-          # Doesn't worry about date range or day partitions.
-          def cap_met?(total_impressed, today_impressed)
-            return true if daily_capped? && (daily_cap <= today_impressed)
-            return true if overall_capped? && (overall_cap <= total_impressed)
-            false
-          end
-
-          # Assumes time is in time_zone of the ad.
-          # Returns true if there's no way we can hit the overall cap
-          #  without busting the daily cap.
-          def daily_cap_precludes_overall_cap?(time,total_impressed,today_impressed)
-            return false unless daily_capped? && overall_capped?
-            return false unless self.end_datetime.present?
-            a = remaining_impressions_via_daily_cap(time, today_impressed)
-            b = remaining_impressions_via_overall_cap(total_impressed)
-            a < b
-          end
-
-          def remaining_impressions_via_overall_cap(total_impressed)
-            [overall_cap - total_impressed, 0].max
-          end
-
-          def remaining_impressions_today(today_impressed)
-            [daily_cap - today_impressed, 0].max
-          end
-
-          def remaining_impressions_via_daily_cap(time, today_impressed)
-            days = remaining_days(time) - 1 # exclude today
-            daily_cap * days + remaining_impressions_today(today_impressed)
-          end
-
-          # Assumes time is in time_zone of the ad.
-          # Assume daily_cap is present.
-          def calculate_today_pressure(time, today_impressed)
-            hours = remaining_hours_today(time)
-            if hours <= 0
-              0.0
-            else
-              impressions = remaining_impressions_today(today_impressed)
-              2 * impressions / hours.to_f
-            end
-          end
-
-          # Assumes time is in time_zone of the ad.
-          # Assume overall_cap is present.
-          # Assume end_datetime is present.
-          def calculate_overall_pressure(time, total_impressed)
-            hours = remaining_hours(time)
-            if hours <= 0
-              0.0
-            else
-              impressions = remaining_impressions_via_overall_cap(total_impressed)
-              impressions / hours.to_f
-            end
-          end
-
-          # remaining_days : the total integer number of days that an ad will run
-          #                  (even for part of the day) between now and the
-          #                  end_datetime.
-          # Assume all dates/times are in the time_zone of the ad.
-          # Assume end_datetime is present.
-          def remaining_days(time)
-            ending = end_in_time_zone
-            beginning = [time, start_in_time_zone].compact.max
-            return 0 unless beginning < ending
-            if partitioned?
-              end_of_beginning_week = beginning_of_week(beginning) + 7.days
-              beginning_of_end_week = beginning_of_week(ending)
-
-              if end_of_beginning_week < beginning_of_end_week
-                head_days = partitioned_days(beginning, end_of_beginning_week)
-                tail_days = partitioned_days(beginning_of_end_week, ending)
-                whole_weeks = (beginning_of_end_week-end_of_beginning_week) / 7.days
-                head_days + (whole_weeks * days_per_week) + tail_days
-              else
-                partitioned_days(beginning, ending)
-              end
-            else
-              (ending.beginning_of_day.to_datetime -
-               beginning.beginning_of_day.to_datetime) + 1
-            end
-          end
-
-          # remaining_hours : the total number of hours that an ad will run from now
-          #                   to the end_datetime, taking day parting into account.
-          # Assume all dates/times are in the time_zone of the ad.
-          def remaining_hours(time)
-            ending = end_in_time_zone
-            beginning = [time, start_in_time_zone].compact.max
-            return 0 unless beginning < ending
-            if partitioned?
-
-              end_of_beginning_week = beginning_of_week(beginning) + 7.days
-              beginning_of_end_week = beginning_of_week(ending)
-
-              if end_of_beginning_week < beginning_of_end_week
-                head_hours = partitioned_hours(beginning, end_of_beginning_week)
-                tail_hours = partitioned_hours(beginning_of_end_week, ending)
-                whole_weeks = (beginning_of_end_week-end_of_beginning_week) / 7.days
-                head_hours + (whole_weeks * hours_per_week) + tail_hours
-              else
-                partitioned_hours(beginning, ending)
-              end
-            else
-              actual_hours(beginning, ending)
-            end
-          end
-
-          # remaining_hours_today : the total number of hours that an ad will run
-          #                         between now and the end of the day, taking day
-          #                         parting into account.
-          # Assume all dates/times are in the time_zone of the ad.
-          def remaining_hours_today(time)
-            beginning = [time, start_in_time_zone].compact.max
-            ending = [time.beginning_of_day + 1.day, end_in_time_zone].compact.min
-            return 0 unless beginning < ending
-            if partitioned?
-              partitioned_hours(beginning, ending)
-            else
-              actual_hours(beginning, ending)
-            end
-          end
-
-          # Assume time is in the time_zone of the ad.
-          # Assume a week begins on Sunday.
-          def beginning_of_week(time)
-            recent_monday = time.monday
-            sunday_before_recent_monday = recent_monday - 1.day
-            if (time - sunday_before_recent_monday) < 7.days
-              sunday_before_recent_monday
-            else
-              sunday_before_recent_monday + 7.days
-            end
-          end
-
-          def beginning_of_hour(time)
-            time.change(:min => 0, :sec => 0, :usec => 0)
-          end
-
-          # Assume beginning and ending are in the ad's time_zone.
-          # Assume beginning and ending are within the ad's date range.
-          # Assume ad is partitioned.
-          def partitioned_hours(beginning, ending)
-            return 0 unless beginning < ending
-            total = 0.0
-            this_hour = beginning_of_hour(beginning)
-            last_hour = beginning_of_hour(ending)
-            if this_hour.to_i == last_hour.to_i
-              if partitioned_hour?(this_hour)
-                total = actual_hours(beginning, ending)
-              end
-            else
-              next_hour = this_hour + 1.hour
-              if partitioned_hour?(this_hour)
-                total += actual_hours(beginning, next_hour)
-              end
-              each_hour(next_hour, last_hour) do |hour|
-                total += 1 if partitioned_hour?(hour)
-              end
-              if partitioned_hour?(last_hour)
-                total += actual_hours(last_hour, ending)
-              end
-            end
-            total
-          end
-
-          # Assume beginning and ending are in the ad's time_zone.
-          # Assume beginning and ending are within the ad's date range.
-          # Assume ad is partitioned.
-          # Assume beginning and ending are within a week of each other.
-          # Computes integer number of days where any part of the day is active.
-          def partitioned_days(beginning, ending)
-            return 0 unless beginning < ending
-
-            end_of_beginning_day = beginning.beginning_of_day + 1.day
-            beginning_of_end_day = ending.beginning_of_day
-
-            if end_of_beginning_day < beginning_of_end_day
-              days = 0
-              days += 1 if partitioned_hours(beginning, end_of_beginning_day) > 0
-              days += 1 if partitioned_hours(beginning_of_end_day, ending) > 0
-              each_day(end_of_beginning_day, beginning_of_end_day) do |day|
-                days += 1 if partitioned_day?(day)
-              end
-              days
-            else
-              (partitioned_hours(beginning,ending) > 0) ? 1 : 0
-            end
-          end
-
-          def each_day(beginning, ending)
-            time = beginning.clone
-            while (time < ending)
-              yield time
-              time += 1.day
-            end
-          end
-
-          def each_hour(beginning, ending)
-            time = beginning.clone
-            while(time < ending)
-              yield time
-              time += 1.hour
-            end
-          end
-
-          def actual_hours(beginning, ending)
-            (ending.to_f - beginning.to_f) / 3600
-          end
-
-          # Assumes ad is partitioned.
-          def days_per_week
-            (0..6).map{|d| day_partitions[d*24,24].include?('T') ? 1 : 0 }.sum
-          end
-
-          # Assumes ad is partitioned.
-          def hours_per_week
-            day_partitions.count("T")
-          end
-        end
-      end
-    end
-  end
-end

data/lib/neuron-client/model/common/ad_zone.rb

@@ -1,17 +0,0 @@
-module Neuron
-  module Client
-    module Model
-      module Common
-        class AdZone
-          include Base
-
-          resource_name("ad_zone")
-          resources_name("ad_zones")
-
-          attr_accessor :ad_id, :zone_id, :priority, :weight,
-              :created_at, :updated_at
-        end
-      end
-    end
-  end
-end

data/lib/neuron-client/model/common/base.rb

@@ -1,67 +0,0 @@
-module Neuron
-  module Client
-    module Model
-      module Common
-        module Base
-          def initialize(attrs=nil)
-            (attrs || {}).each do |k,v|
-              next if k.to_s == 'id' && self.class.remote_id != 'id'
-              k = 'id' if k.to_s == self.class.remote_id
-              self.send("#{k}=", v) if self.respond_to?("#{k}=")
-            end
-          end
-
-          def self.included(base)
-            base.send(:attr_accessor, :id)
-            base.extend(ClassMethods)
-          end
-
-          module ClassMethods
-            def api
-              class_name_to_load = superclass.name.split('::').last
-              Neuron::Client::Model.const_get(class_name_to_load).api
-            end
-
-            def connection
-              api.connection
-            end
-
-            def attr_accessor(*vars)
-              @attributes ||= []
-              @attributes += vars
-              super(*vars)
-            end
-
-            def attributes
-              @attributes
-            end
-
-            def resource_name(res=nil)
-              if res
-                @resource_name = res.to_s
-              end
-              @resource_name
-            end
-
-            def resources_name(res=nil)
-              if res
-                @resources_name = res.to_s.downcase
-              end
-              if @resources_name.nil? && !@resource_name.nil?
-                @resources_name = "#{@resource_name}s"
-              end
-              @resources_name
-            end
-
-            def remote_id(remote_id=nil)
-              if remote_id
-                @remote_id = remote_id.to_s
-              end
-              @remote_id || 'id'
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/neuron-client/model/common/blocked_referer.rb

@@ -1,16 +0,0 @@
-module Neuron
-  module Client
-    module Model
-      module Common
-        class BlockedReferer
-          include Base
-
-          resource_name("blocked_referer")
-          resources_name("blocked_referers")
-
-          attr_accessor :referer, :reversed_referer, :created_at, :updated_at
-        end
-      end
-    end
-  end
-end

data/lib/neuron-client/model/common/blocked_user_agent.rb

@@ -1,16 +0,0 @@
-module Neuron
-  module Client
-    module Model
-      module Common
-        class BlockedUserAgent
-          include Base
-
-          resource_name("blocked_user_agent")
-          resources_name("blocked_user_agents")
-
-          attr_accessor :user_agent, :description, :created_at, :updated_at
-        end
-      end
-    end
-  end
-end

data/lib/neuron-client/model/common/geo_target.rb

@@ -1,16 +0,0 @@
-module Neuron
-  module Client
-    module Model
-      module Common
-        class GeoTarget
-          include Base
-
-          resource_name("geo_target")
-          resources_name("geo_targets")
-
-          attr_accessor :geo_type, :full_name, :name, :abbreviation, :updated_at
-        end
-      end
-    end
-  end
-end

data/lib/neuron-client/model/common/pixel.rb

@@ -1,18 +0,0 @@
-module Neuron
-  module Client
-    module Model
-      module Common
-        class Pixel
-          include Base
-
-          resource_name("pixel")
-          resources_name("pixels")
-
-          # time stamps
-          attr_accessor :created_at, :updated_at
-
-        end
-      end
-    end
-  end
-end

data/lib/neuron-client/model/common/report.rb

@@ -1,21 +0,0 @@
-module Neuron
-  module Client
-    module Model
-      module Common
-        class Report
-          include Base
-
-          resource_name("report")
-          resources_name("reports")
-
-          attr_accessor :errors
-          attr_accessor :template, :parameters, :state
-
-          def status
-            @state
-          end
-        end
-      end
-    end
-  end
-end

data/lib/neuron-client/model/common/s3_file.rb

@@ -1,16 +0,0 @@
-module Neuron
-  module Client
-    module Model
-      module Common
-        class S3File
-          include Base
-
-          resource_name("s3_file")
-          resources_name("s3_files")
-
-          attr_accessor :bucket, :filename, :purpose, :filesize, :created_at, :updated_at
-        end
-      end
-    end
-  end
-end

data/lib/neuron-client/model/common/zone.rb

@@ -1,22 +0,0 @@
-module Neuron
-  module Client
-    module Model
-      module Common
-        class Zone
-          include Base
-          include ZoneCalculations
-
-          resource_name("zone")
-          resources_name("zones")
-
-          attr_accessor :slug, :response_type, :template_slug, :parameters,
-              :created_at, :updated_at, :ad_links
-
-          def find_ad(ad_id)
-            Neuron::Client::Model::Ad.find(ad_id)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/neuron-client/model/common/zone_calculations.rb

@@ -1,41 +0,0 @@
-module Neuron
-  module Client
-    module Model
-      module Common
-        module ZoneCalculations
-          # This module expects the following methods to be defined:
-          #
-          # ad_links (Hash, keys are ad IDs, values are a sub-hash: {'priority' => p, 'weight' => w})
-          # find_ad(ad_id) (nil, or an object that responds to :active? and :pressure)
-
-          def ads_by_priority
-            calculate_ads_by_priority
-          end
-
-          def calculate_ads_by_priority
-            entries = {}
-            ad_links.each do |ad_id, link|
-              next unless ad = find_ad(ad_id)
-              next unless ad.active?
-              weight   = link['weight'].to_f
-              priority = link['priority'].to_f
-              entries[priority] ||= []
-              entries[priority] << [ad_id, weighted_pressure(weight, ad.pressure)]
-            end
-            entries.sort_by do |priority, entry|
-              priority
-            end.map do |priority, entry|
-              entry.sort_by(&:first)
-            end
-          end
-
-          private
-
-          def weighted_pressure(weight, pressure)
-            [( [weight, 0.0].max * [pressure, 1.0].max ), 1.0].max.to_f
-          end
-        end
-      end
-    end
-  end
-end

data/lib/neuron-client/model/membase/ad.rb

@@ -1,49 +0,0 @@
-module Neuron
-  module Client
-    module Model
-      module Membase
-        class Ad < Common::Ad
-
-          ACTIVE_TTL = 60 #seconds
-          PRESSURE_TTL = 60 #seconds
-
-          def total_impressed
-            key = "count_delivery_ad_#{self.id}"
-            self.class.connection.get(key,1).to_f
-          end
-
-          def today_impressed
-            now_adjusted_for_ad_time_zone = Time.now.in_time_zone(self.time_zone)
-            formatted_date = now_adjusted_for_ad_time_zone.strftime('%Y%m%d') # format to YYYYMMDD
-            key = "count_delivery_#{formatted_date}_ad_#{self.id}"
-            self.class.connection.get(key,1).to_f
-          end
-
-          def active?
-            self.class.connection.fetch("Ad:#{id}:active", ACTIVE_TTL) do
-              calculate_active?(Time.now, total_impressed, today_impressed)
-            end
-          end
-
-          def pressure
-            self.class.connection.fetch("Ad:#{id}:pressure", PRESSURE_TTL) do
-              calculate_pressure(Time.now, total_impressed, today_impressed)
-            end
-          end
-
-          class << self
-            def find(id)
-              self.connection.local_cache.fetch("Neuron::Client::Model::Ad:#{id}") do
-                ad = nil
-                membase_key = "Ad:#{id}"
-                cached_json = self.connection.get(membase_key)
-                ad = self.new(Yajl.load(cached_json)[superclass.resource_name]) if cached_json.present?
-                ad
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/neuron-client/model/membase/ad_zone.rb

@@ -1,11 +0,0 @@
-module Neuron
-  module Client
-    module Model
-      module Membase
-        class AdZone < Common::AdZone
-
-        end
-      end
-    end
-  end
-end

data/lib/neuron-client/model/membase/blocked_referer.rb

@@ -1,20 +0,0 @@
-module Neuron
-  module Client
-    module Model
-      module Membase
-        class BlockedReferer < Common::BlockedReferer
-          class << self
-            def all
-              self.connection.local_cache.fetch("Neuron::Client::Model::BlockedReferer:all") do
-                blocked_referers = []
-                cached_json = self.connection.get('blocked_referers')
-                blocked_referers = Yajl.load(cached_json).collect{|item| self.new(item[superclass.resource_name])} if cached_json.present?
-                blocked_referers
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/neuron-client/model/membase/blocked_user_agent.rb

@@ -1,20 +0,0 @@
-module Neuron
-  module Client
-    module Model
-      module Membase
-        class BlockedUserAgent < Common::BlockedUserAgent
-          class << self
-            def all
-              self.connection.local_cache.fetch("Neuron::Client::Model::BlockedUserAgent:all") do
-                blocked_user_agents = []
-                cached_json = self.connection.get('blocked_user_agents')
-                blocked_user_agents = Yajl.load(cached_json).collect{|item| self.new(item[superclass.resource_name])} if cached_json.present?
-                blocked_user_agents
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end