bsm-openx 1.9.1

data/lib/openx/services/agency.rb

@@ -0,0 +1,34 @@
+module OpenX
+  module Services
+    class Agency < Base
+      # Translate our property names to OpenX property names
+      openx_accessor  :name          => :agencyName,
+                      :contact_name  => :contactName,
+                      :email         => :emailAddress,
+                      :username      => :username,
+                      :password      => :password,
+                      :id            => :agencyId,
+                      :account_id    => :accountId
+
+      self.create   = 'ox.addAgency'
+      self.update   = 'ox.modifyAgency'
+      self.delete   = 'ox.deleteAgency'
+      self.find_one = 'ox.getAgency'
+      self.find_all = 'ox.getAgencyList'
+
+      def create_advertiser!(params = {})
+        Advertiser.create!(params.merge({
+          :agency   => self,
+        }))
+      end
+
+      def advertisers
+        Advertiser.find(:all, self.id)
+      end
+
+      def publishers
+        Publisher.find(:all, self.id)
+      end
+    end
+  end
+end

data/lib/openx/services/banner.rb

@@ -0,0 +1,94 @@
+require 'date'
+
+module OpenX
+  module Services
+    class Banner < Base
+      LOCAL_SQL = 'sql'
+      LOCAL_WEB = 'web'
+      EXTERNAL  = 'url'
+      HTML      = 'html'
+      TEXT      = 'txt'
+
+      RUNNING = 0
+      PAUSED  = 1
+
+      class << self
+        def find(id, *args)
+          if id == :all
+            responses = remote.call(find_all, *args)
+            response  = responses.first
+            return [] unless response
+            responses = [response]
+
+            ### Annoying..  For some reason OpenX returns a linked list.
+            ### Probably a bug....
+            while response.key?('aImage')
+              response = response.delete('aImage')
+              break unless response
+              responses << response
+            end
+
+            responses.map do |response|
+              new(translate(response))
+            end
+          else
+            response  = remote.call(find_one, id)
+            new(translate(response))
+          end
+        end
+      end
+
+      # Translate our property names to OpenX property names
+      openx_accessor  :name           => :bannerName,
+                      :campaign_id    => :campaignId,
+                      :id             => :bannerId,
+                      :storage_type   => :storageType,
+                      :file_name      => :fileName,
+                      :image_url      => :imageURL,
+                      :html_template  => :htmlTemplate,
+                      :width          => :width,
+                      :height         => :height,
+                      :weight         => :weight,
+                      :target         => :target,
+                      :url            => :url,
+                      :status         => :status,
+                      :adserver       => :adserver,
+                      :transparent    => :transparent,
+                      :image          => :aImage,
+                      :backup_image   => :aBackupImage,
+                      # 'keyword' only supported by patched server
+                      # as per https://developer.openx.org/jira/browse/OX-4779
+                      # No averse effect when unsupported by server (returns nil)
+                      :keyword        => :keyword,
+                      :comments       => :comments
+
+      has_one :campaign
+
+      self.create   = 'ox.addBanner'
+      self.update   = 'ox.modifyBanner'
+      self.delete   = 'ox.deleteBanner'
+      self.find_one = 'ox.getBanner'
+      self.find_all = 'ox.getBannerListByCampaignId'
+
+      def initialize(params = {})
+        raise ArgumentError.new("Missing campaign_id") unless params[:campaign_id] || params[:campaign]
+        params[:campaign_id] ||= params[:campaign].id
+        super(params)
+      end
+
+      def statistics start_on = Date.today, end_on = Date.today
+        remote.call('ox.bannerDailyStatistics', self.id, start_on, end_on)
+      end
+
+      def targeting
+        remote.call('ox.getBannerTargeting', self.id) do |line|
+          TargetingRule.instantiate(line)
+        end
+      end
+
+      def targeting=(rules)
+        remote.call('ox.setBannerTargeting', self.id, rules)
+      end
+    end
+  end
+end

data/lib/openx/services/base.rb

@@ -0,0 +1,97 @@
+module OpenX
+  module Services
+    class Base
+      extend  Persistance::ClassMethods
+      include Persistance::InstanceMethods
+      include Comparable
+
+      class << self
+        attr_accessor :translations
+        attr_writer   :connection
+        attr_accessor :create, :update, :delete, :find_one, :find_all
+
+        # Establishes a custom connection. Example:
+        #
+        #   class MyBanner < OpenX::Services::Banner
+        #     establish_connection 'url' => 'http://custom.host/openx', 'user' => 'admin', 'password' => 'password'
+        #   end
+        def establish_connection(conn)
+          conn = OpenX::Services.establish_connection(conn) if conn.is_a?(Hash)
+          self.connection = conn
+        end
+
+        # Execute a block using a custom connection. Example:
+        #    custom_conn = OpenX::Services.establish_connection({ ... })
+        #
+        #    OpenX::Services::Agency.with_connection(custom_conn) do
+        #      OpenX::Services::Agency.find(:all)
+        #    end
+        def with_connection(temporary)
+          current = @connection
+          begin
+            establish_connection(temporary)
+            yield
+          ensure
+            establish_connection(current)
+          end
+        end
+
+        # Returns the current connection (session)
+        def connection
+          @connection = nil unless defined?(@connection)
+          @connection || OpenX::Services.default_connection
+        end
+
+        # Remote API proxy. Example:
+        #
+        #   OpenX::Services::Agency.remote.call 'ox.addAgency', ...
+        def remote
+          connection.remote
+        end
+
+        def has_one(*things)
+          things.each do |thing|
+            attr_writer :"#{thing}"
+            define_method(:"#{thing}") do
+              klass = thing.to_s.capitalize.gsub(/_[a-z]/) { |m| m[1].chr.upcase }
+              klass = OpenX::Services.const_get(:"#{klass}")
+              klass.find(send("#{thing}_id"))
+            end
+          end
+        end
+
+        def openx_accessor(accessor_map)
+          @translations ||= {}
+          @translations = accessor_map.merge(@translations)
+          accessor_map.each do |ruby,openx|
+            attr_accessor :"#{ruby}"
+          end
+        end
+      end
+
+      def initialize(params = {})
+        @id = nil
+        params.each { |k,v| send(:"#{k}=", v) }
+      end
+
+      def new_record?
+        @id.nil?
+      end
+
+      def <=>(other)
+        self.id <=> other.id
+      end
+
+      protected
+
+        def connection
+          self.class.connection
+        end
+
+        def remote
+          self.class.remote
+        end
+
+    end
+  end
+end

data/lib/openx/services/campaign.rb

@@ -0,0 +1,52 @@
+module OpenX
+  module Services
+    class Campaign < Base
+      # Translate our property names to OpenX property names
+      openx_accessor  :name               => :campaignName,
+                      :advertiser_id      => :advertiserId,
+                      :id                 => :campaignId,
+                      :start_date         => :startDate,
+                      :end_date           => :endDate,
+                      :impressions        => :impressions,
+                      :target_impressions => :targetImpressions,
+                      :target_clicks      => :targetClicks,
+                      :revenue            => :revenue,
+                      :revenue_type       => :revenueType,
+                      :impressions        => :impressions,
+                      :clicks             => :clicks,
+                      :priority           => :priority,
+                      :weight             => :weight,
+                      :campaign_type      => :campaignType,
+                      :comments           => :comments
+
+      has_one :advertiser
+
+      self.create   = 'ox.addCampaign'
+      self.update   = 'ox.modifyCampaign'
+      self.delete   = 'ox.deleteCampaign'
+      self.find_one = 'ox.getCampaign'
+      self.find_all = 'ox.getCampaignListByAdvertiserId'
+
+      # Revenue types
+      CPM             = 1
+      CPC             = 2
+      CPA             = 3
+      MONTHLY_TENANCY = 4
+
+      # Campaign types
+      REMNANT   = 1
+      HIGH      = 2
+      EXCLUSIVE = 3
+
+      def initialize(params = {})
+        raise ArgumentError.new("Missing advertiser_id") unless params[:advertiser_id] || params[:advertiser]
+        params[:advertiser_id] ||= params[:advertiser].id
+        super(params)
+      end
+
+      def banners
+        Banner.find(:all, self.id)
+      end
+    end
+  end
+end

data/lib/openx/services/channel.rb

@@ -0,0 +1,42 @@
+module OpenX
+  module Services
+    class Channel < Base
+
+      openx_accessor :name          => :channelName,
+                     :id            => :channelId,
+                     :comments      => :comments,
+                     :description   => :description,
+                     :publisher_id  => :websiteId,
+                     :agency_id     => :agencyId
+
+      has_one        :publisher
+
+      self.create   = 'ox.addChannel'
+      self.update   = 'ox.modifyChannel'
+      self.delete   = 'ox.deleteChannel'
+      self.find_one = 'ox.getChannel'
+      self.find_all = 'ox.getChannelListByWebsiteId'
+
+      def initialize(params = {})
+        raise "need publisher" unless params[:publisher_id] || params[:publisher]
+        params[:publisher_id] ||= params[:publisher].id
+        super(params)
+      end
+
+      # Retrieves targeting from channel
+      def targeting
+        raise "Channel must be saved" if new_record?
+        remote.call("ox.getChannelTargeting", self.id).map do |line|
+          TargetingRule.instantiate(line)
+        end
+      end
+
+      # Applied targeting to channel. See OpenX::Services::TargetingRules for details
+      def targeting=(rules)
+        raise "Channel must be saved" if new_record?
+        remote.call("ox.setChannelTargeting",  self.id, rules)
+      end
+
+    end
+  end
+end

data/lib/openx/services/persistance.rb

@@ -0,0 +1,64 @@
+module OpenX
+  module Services
+    module Persistance
+
+      module ClassMethods
+
+        def create!(params = {})
+          new(params).save!
+        end
+
+        def find(id, *args)
+          if id == :all
+            responses = remote.call(find_all, *args)
+            responses.map do |response|
+              new(translate(response))
+            end
+          else
+            response  = remote.call(find_one, id)
+            new(translate(response))
+          end
+        end
+
+        def destroy(id)
+          new(:id => id).destroy
+        end
+
+        private
+
+          def translate(response)
+            params    = {}
+            self.translations.each do |k,v|
+              params[k] = response[v.to_s] if response[v.to_s]
+            end
+            params
+          end
+
+      end
+
+      module InstanceMethods
+
+        def save!
+          params = {}
+          self.class.translations.keys.each do |k|
+            value = send(:"#{k}")
+            params[self.class.translations[k].to_s] = value if value
+          end
+
+          if new_record?
+            @id = remote.call(self.class.create, params)
+          else
+            remote.call(self.class.update, params)
+          end
+          self
+        end
+
+        def destroy
+          remote.call(self.class.delete, id)
+          @id = nil
+        end
+
+      end
+    end
+  end
+end

data/lib/openx/services/publisher.rb

@@ -0,0 +1,36 @@
+module OpenX
+  module Services
+    class Publisher < Base
+      openx_accessor :name          => :publisherName,
+                     :contact_name  => :contactName,
+                     :email         => :emailAddress,
+                     :username      => :username,
+                     :password      => :password,
+                     :id            => :publisherId,
+                     :agency_id     => :agencyId,
+                     :website       => :website
+
+      has_one :agency
+
+      self.create   = 'ox.addPublisher'
+      self.update   = 'ox.modifyPublisher'
+      self.delete   = 'ox.deletePublisher'
+      self.find_one = 'ox.getPublisher'
+      self.find_all = 'ox.getPublisherListByAgencyId'
+
+      def initialize(params = {})
+        raise "need agency" unless params[:agency_id] || params[:agency]
+        params[:agency_id] ||= params[:agency].id
+        super(params)
+      end
+
+      def zones
+        Zone.find(:all, self.id)
+      end
+
+      def channels
+        Channel.find(:all, self.id)
+      end
+    end
+  end
+end

data/lib/openx/services/session.rb

@@ -0,0 +1,44 @@
+module OpenX
+  module Services
+    class Session
+      attr_accessor :id, :uri, :user, :password
+
+      def initialize(url)
+        @uri    = URI.parse(url)
+        @client = XmlrpcClient.new(self.url)
+        @id     = nil
+      end
+
+      def url
+        uri.to_s
+      end
+
+      def host
+        url.sub(/#{Regexp.escape(uri.path)}$/, '')
+      end
+
+      def remote
+        @remote ||= XmlrpcSessionClient.new(self)
+      end
+
+      def create(user, password)
+        self.user     = user
+        self.password = password
+        self.id       = @client.call('ox.logon', user, password)
+        self
+      end
+
+      def recreate!
+        raise "Unable to refresh Session" unless user && password
+        self.id = @client.call('ox.logon', user, password)
+        self
+      end
+
+      def destroy
+        @client.call('ox.logoff', id)
+        self.id = nil
+        self
+      end
+    end
+  end
+end