neuron-client 0.2.6 → 0.3.0

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

@@ -1,37 +1,252 @@
 module Neuron
   module Client
-    module Model
-      class Base
-        instance_methods.each { |m| undef_method m unless m =~ /(^__|^send$|^object_id|^class$)/ }
+    module Base
 
-        def initialize(attrs=nil)
-          @proxied_model = self.class.class_to_proxy.new(attrs)
+      module ClassAndInstanceMethods
+
+        def find(id)
+          if connected_to_membase?
+            key = cache_key(id)
+            connection.local_cache.fetch(key) do
+              cached_json = connection.get(key)
+              if cached_json.present?
+                data = Yajl.load(cached_json)
+                validate_against_schema!(:show, data)
+                from_hash(data)
+              end
+            end
+          elsif connected_to_admin?
+            data = connection.get("#{resources_name}/#{id}")
+            validate_against_schema!(:show, data)
+            from_hash(data)
+          else
+            raise "Not configured!"
+          end
+        end
+
+        def all
+          if connected_to_membase?
+            key = cache_key(":all")
+            connection.local_cache.fetch(key) do
+              cached_json = connection.get(resources_name)
+              if cached_json.present?
+                data = Yajl.load(cached_json)
+                validate_against_schema!(:index, data)
+                data.map{ |hash| from_hash(hash) }
+              else
+                []
+              end
+            end
+          elsif connected_to_admin?
+            data = connection.get(resources_name)
+            validate_against_schema!(:index, data)
+            data.map{ |hash| from_hash(hash) }
+          else
+            raise "Not configured!"
+          end
+        end
+
+        def create(attrs={})
+          @errors = catch :errors do
+            return create!(attrs)
+          end
+          nil
+        end
+
+        def create!(attrs={})
+          data = {resource_name => attrs.stringify_keys}
+          validate_against_schema!(:create, data)
+          data = connection.post("#{resources_name}", data)
+          validate_against_schema!(:show, data)
+          from_hash(data)
         end
 
-        def method_missing(meth, *args, &block)
-          (@proxied_model.respond_to?(meth) ? @proxied_model.send(meth, *args, &block) : super)
+        def api=(api)
+          @api = api
+        end
+
+        def validate=(validate)
+          @validate = validate
+        end
+
+        protected
+
+        ID_PATTERN = /\A\d+\z/.freeze
+        def validate_id!(id)
+          if validate?
+            unless (id.is_a?(Integer) || ID_PATTERN.match(id.to_s)) && id.to_i > 0
+              raise "Invalid ID: #{id.inspect}"
+            end
+          end
+        end
+
+        UUID_PATTERN = /\A[a-z0-9]+\z/.freeze
+        def validate_uuid!(uuid)
+          if validate?
+            unless UUID_PATTERN.match(uuid) && uuid.length <= 25
+              raise "Invalid UUID: #{uuid}"
+            end
+          end
+        rescue Exception => e
+          raise "Invalid UUID: #{uuid}"
         end
 
-        class << self
-          attr_accessor :api
-          def api
+        # schema_name : one of [:index, :show, :create, update]
+        # data : the serializable object that should match the given schema
+        def validate_against_schema!(schema_name, data)
+          if validate? && data.present?
+            JSON::Validator.validate!(schema.send(schema_name), data)
+          end
+        end
+
+        def from_hash(hash)
+          if hash.present?
+            attrs = hash[resource_name]
+            klass.new(attrs) if attrs.present?
+          end
+        end
+
+        def api
+          if self.is_a?(Class)
             @api || Neuron::Client::API.default_api
+          else
+            @api || self.class.api
+          end
+        end
+
+        def validate?
+          return !!@validate unless @validate.nil?
+          if self.is_a?(Class)
+            api.validate?
+          else
+            self.class.validate?
           end
+        end
+
+        def connection
+          api.connection
+        end
+
+        def connected?
+          connection.present?
+        end
+
+        def connected_to_admin?
+          api.connection_type == :admin && connected?
+        end
+
+        def connected_to_membase?
+          api.connection_type == :membase && connected?
+        end
 
-          def connection
-            api.connection
+        def connected_to_admin!
+          raise("Not configured for admin server!") unless connected_to_admin?
+        end
+
+        def connected_to_membase!
+          raise("Not configured for membase server!") unless connected_to_membase?
+        end
+
+        def klass
+          @klass ||= (self.is_a?(Class) ? self : self.class)
+        end
+
+        def schema
+          @schema ||= "Neuron::Schema::#{klass.name.demodulize}::SCHEMA".constantize
+        end
+
+        def cache_key(id)
+          "#{klass.name.demodulize}:#{id}"
+        end
+
+        def resource_name
+          @resource_name ||= klass.name.demodulize.underscore
+        end
+
+        def resources_name
+          @resources_name ||= resource_name.pluralize
+        end
+     end
+
+      def self.included(base)
+        base.send(:attr_accessor, :errors) if base.is_a?(Class)
+        base.send(:attr_reader, :id) if base.is_a?(Class)
+        base.extend(ClassAndInstanceMethods)
+      end
+
+      include ClassAndInstanceMethods
+
+      def initialize(attrs={})
+        apply_attributes!(attrs)
+      end
+
+      def apply_attributes!(attrs)
+        if attrs.present?
+          attrs.each do |k,v|
+            self.send("#{k}=", v) if self.respond_to?("#{k}=")
           end
+        end
+      end
 
-          def class_to_proxy
-            module_to_load = api.connection_type.to_s.titleize
-            class_name_to_load = name.split('::').last
-            Neuron::Client::Model.const_get(module_to_load).const_get(class_name_to_load)
+      def to_hash(*except)
+        hash = {}
+        except = except.map(&:to_sym)
+        attributes.each do |attribute|
+          unless except.include?(attribute.to_sym)
+            value = send(attribute)
+            hash[attribute.to_s] = value
           end
+        end
+        {resource_name => hash}
+      end
+
+      def to_create_hash(*except)
+        to_hash(*([:errors, :updated_at, :created_at, :id] + except))
+      end
+
+      def to_update_hash(*except)
+        to_hash(*([:errors, :updated_at, :created_at] + except))
+      end
+
+      def new_record?
+        id.nil?
+      end
+
+      def id=(id)
+        @id = Integer(id)
+      end
+
+      def save
+        update_attributes
+      end
 
-          def method_missing(meth, *args, &block)
-            (class_to_proxy.respond_to?(meth) ? class_to_proxy.send(meth, *args, &block) : super)
+      def update_attributes(attrs={})
+        connected_to_admin!
+        @errors = catch :errors do
+          apply_attributes!(attrs) if attrs.present?
+          data = {}
+          if new_record?
+            data = to_create_hash
+            validate_against_schema!(:create, data)
+            data = connection.post(resources_name, data)
+          else
+            data = to_update_hash
+            validate_against_schema!(:update, data)
+            data = connection.put("#{resources_name}/#{id}", data)
           end
+          apply_attributes!(data[resource_name])
+          []
         end
+        @errors.empty?
+      end
+
+      def valid?
+        @errors.empty?
+      end
+
+      def destroy
+        connected_to_admin!
+        connection.delete("#{resources_name}/#{id}")
       end
     end
   end

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

@@ -0,0 +1,20 @@
+module Neuron
+  module Client
+    class BlockedReferer
+      include Base
+
+      ATTRIBUTES = [
+        :id,
+        :referer, # string, URL
+        :created_at, # string, datetime in UTC
+        :updated_at, # string, datetime in UTC
+      ]
+
+      attr_accessor *ATTRIBUTES
+      
+      def attributes
+        ATTRIBUTES
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module Neuron
+  module Client
+    class BlockedUserAgent
+      include Base
+
+      ATTRIBUTES = [
+        :id,
+        :user_agent,  # string, regex (max 2 GB length)
+        :description, # nil, or string (max 2 GB length)
+        :created_at,  # string, datetime in UTC
+        :updated_at,  # string, datetime in UTC
+      ]
+
+      attr_accessor *ATTRIBUTES
+      
+      def attributes
+        ATTRIBUTES
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+module Neuron
+  module Client
+    class GeoTarget
+      include Base
+
+      TYPES = %w(COUNTRY REGION METRO CITY) # DO NOT modify, unless you're absolutely sure of all the ramifications!
+
+      ATTRIBUTES = [
+        :id,
+        :geo_type,      # string, one of TYPES
+        :net_acuity_id, # integer
+        :abbreviation,  # string
+        :full_name,     # string
+        :name,          # string
+      ]
+
+      attr_accessor *ATTRIBUTES
+
+      def attributes
+        ATTRIBUTES
+      end
+
+      EXPECTED_QUERY_PARAMS = %w(geo_type search limit)
+      def self.query(parameters)
+        if validate?
+          unless parameters.all?{|k,v| EXPECTED_QUERY_PARAMS.include?(k.to_s)}
+            raise "Unsupported parameters: #{parameters.inspect}"
+          end
+        end
+        data = self.connection.get("geo_targets", parameters)
+        validate_against_schema!(:index, data)
+        data.map{ |hash| from_hash(hash) }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Neuron
+  module Client
+    class Pixel
+      include Base
+
+      ATTRIBUTES = [
+        :id,
+        :ad_ids,     # array of integers
+      ]
+
+      attr_accessor *ATTRIBUTES
+      
+      def attributes
+        ATTRIBUTES
+      end
+
+      def ad_ids
+        @ad_ids.nil? ? [] : @ad_ids
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+module Neuron
+  module Client
+    class Report
+      include Base
+
+      TEMPLATES = %w(ad_events delivery_metrics post_activities)
+
+      STATES =  %w(WAITING RUNNING READY FAILED CANCELLED)
+
+      ATTRIBUTES = [
+        :id,
+        :parameters, # hash, where keys are parameter names, and values are parameter values as strings.
+        :state,      # string, one of STATES
+        :template,   # string, one of TEMPLATES
+        :created_at, # string, datetime in UTC
+        :updated_at, # string, datetime in UTC
+      ]
+
+      attr_accessor *ATTRIBUTES
+      
+      def attributes
+        ATTRIBUTES
+      end
+
+      def status
+        @state
+      end
+
+      def result
+        connected_to_admin!
+        connection.get("reports/#{id}/result", :format => "")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+module Neuron
+  module Client
+    class S3File
+      include Base
+
+      PURPOSE_CHOICES = [
+        "REPORT_RESULT",
+        "RAW_EVENT_LOG",
+        "NORMALIZED_EVENT_LOG",
+        "ENRICHED_EVENT_LOG"
+      ]
+
+      ATTRIBUTES = [
+        :id,
+        :bucket,     # string, at least 3 chars
+        :filename,   # string
+        :filesize,   # nil, or integer
+        :purpose,    # string, one of PURPOSE_CHOICES
+        :created_at, # string, datetime in UTC
+        :updated_at, # string, datetime in UTC
+      ]
+
+      attr_accessor *ATTRIBUTES
+
+      def attributes
+        ATTRIBUTES
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+module Neuron
+  module Client
+    class Zone
+      include Base
+      include ZoneCalculations
+
+      ADS_BY_PRIORITY_TTL = 60 #seconds
+
+      REDIRECT = "Redirect"
+      IRIS = "Iris"
+      VAST = "Vast"
+      RESPONSE_TYPES = [REDIRECT, IRIS, VAST]
+
+      TEMPLATE_SLUGS = ["300x250", "300x600"]
+
+      ATTRIBUTES = [
+        :id,
+        :ad_links,
+        :name,
+        :response_type, # string in RESPONSE_TYPES
+        :template_slug, # nil, or string in TEMPLATE_SLUGS
+        :mute,          # nil, or "Yes" or "No"
+        :autoplay,      # nil, or "Yes" or "No"
+        :channel,       # nil, or slug
+        :expand,        # nil, or "Yes" or "No"
+        :text_overlay,  # nil, or "Yes" or "No"
+        :nami_feed_url, # nil, or string URL
+        :created_at,    # string, datetime in UTC
+        :updated_at,    # string, datetime in UTC
+      ]
+
+      attr_accessor *ATTRIBUTES
+
+      def attributes
+        ATTRIBUTES
+      end
+
+      def id=(id)
+        @id = id.to_s
+      end
+
+      def find_ad(ad_id)
+        Ad.find(ad_id)
+      end
+
+      def unlink(ad_id)
+        connected_to_admin!
+        validate_id!(ad_id)
+        validate_uuid!(id)
+        connection.delete("zones/#{id}/ads/#{ad_id}")
+      end
+
+      def ads_by_priority
+        if connected_to_membase?
+          connection.fetch("Zone:#{id}:ads_by_priority", ADS_BY_PRIORITY_TTL) do
+            calculate_ads_by_priority
+          end
+        else
+          calculate_ads_by_priority
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+module Neuron
+  module Client
+    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