adzerk 0.2 → 0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: fbf807615b442c107c0adf872c51fa3d91b55044
+  data.tar.gz: c22fccc8609e2999a14f218f4a892f96eb6c98ff
+SHA512:
+  metadata.gz: 689ca16190cb2b8880252e0d5120ddfcedecd8a463c7b1260111eb9b7bf50c7cff095a29359d6aa094c123f79e0d911c8f9cd4c34cdb01ad1bf2e55f3e85458a
+  data.tar.gz: 686c57f7c0150b20f068550f07a3bc0ab0221a3e5841cd655703dab2b34946e1b0ea5495683ea013f3c5699282bc1000d3c77f76120d4eff79cd336c147ccf0a

data/lib/adzerk.rb

@@ -3,6 +3,7 @@ require "net/http"
 require "active_support/inflector"
 require "rest_client"
 require "adzerk/util"
+require "adzerk/errors"
 require "adzerk/api_endpoint"
 require "adzerk/advertiser"
 require "adzerk/flight"
@@ -12,4 +13,7 @@ require "adzerk/publisher"
 require "adzerk/invitation"
 require "adzerk/reporting"
 require "adzerk/channel_site_map"
+require "adzerk/geo_targeting"
+require "adzerk/site_zone_targeting"
+require "adzerk/category"
 require "adzerk/client"

data/lib/adzerk/category.rb

@@ -0,0 +1,34 @@
+module Adzerk
+  class Category
+
+    include Adzerk::Util
+
+    attr_reader :client
+
+    def initialize(args={})
+      @client = args[:client]
+    end
+
+    def create(flight_id, data={})
+      url = "flight/#{flight_id}/category"
+      data = { 'category' => camelize_data(data).to_json }
+      parse_response(@client.post_request(url, data))
+    end
+
+    def delete(flight_id, id)
+      url = "flight/#{flight_id}/category/#{id}/delete"
+      @client.get_request(url)
+    end
+
+    def listAll
+      response = client.get_request('categories')
+      parse_response(response)
+    end
+
+    def list(flight_id)
+      url = "flight/#{flight_id}/categories"
+      response = client.get_request(url)
+      parse_response(response)
+    end
+  end
+end

data/lib/adzerk/client.rb

@@ -3,10 +3,10 @@ module Adzerk
 
     include Adzerk::Util
 
-    attr_reader :sites, :zones, :campaigns, :channels, :priorities,
+    attr_reader :sites, :ad_types, :zones, :campaigns, :channels, :priorities,
                 :advertisers, :flights, :creatives, :creative_maps,
                 :publishers, :invitations, :reports, :channel_site_maps,
-                :logins
+                :logins, :geotargetings, :sitezonetargetings, :categories
 
     DEFAULTS = {
       :host => ENV["ADZERK_API_HOST"] || 'http://api.adzerk.net/v1/',
@@ -17,6 +17,7 @@ module Adzerk
       @api_key = key
       @config = DEFAULTS.merge!(opts)
       @sites = Adzerk::ApiEndpoint.new(:client => self, :endpoint => 'site')
+      @ad_types = Adzerk::ApiEndpoint.new(:client => self, :endpoint => 'adtypes')
       @flights = Adzerk::ApiEndpoint.new(:client => self, :endpoint => 'flight')
       @zones = Adzerk::ApiEndpoint.new(:client => self, :endpoint => 'zone')
       @campaigns = Adzerk::ApiEndpoint.new(:client => self, :endpoint => 'campaign')
@@ -30,32 +31,33 @@ module Adzerk
       @reports = Adzerk::Reporting.new(:client => self)
       @channel_site_maps = Adzerk::ChannelSiteMap.new(:client => self)
       @logins = Adzerk::ApiEndpoint.new(:client => self, :endpoint => 'login')
+      @geotargetings = Adzerk::GeoTargeting.new(:client => self, :endpoint => 'geotargeting')
+      @sitezonetargetings = Adzerk::SiteZoneTargeting.new(:client => self, :endpoint => 'sitezone')
+      @categories = Adzerk::Category.new(:client => self, :endpoint => 'category')
+
     end
 
     def get_request(url)
       uri = URI.parse(@config[:host] + url)
-      http = Net::HTTP.new(uri.host, uri.port)
       request = Net::HTTP::Get.new(uri.request_uri)
       request.add_field(@config[:header], @api_key)
-      http.request(request)
+      send_request(request, uri)
     end
 
     def post_request(url, data)
       uri = URI.parse(@config[:host] + url)
-      http = Net::HTTP.new(uri.host, uri.port)
       request = Net::HTTP::Post.new(uri.request_uri)
       request.add_field(@config[:header], @api_key)
       request.set_form_data(data)
-      http.request(request)
+      send_request(request, uri)
     end
 
     def put_request(url, data)
       uri = URI.parse(@config[:host] + url)
-      http = Net::HTTP.new(uri.host, uri.port)
       request = Net::HTTP::Put.new(uri.request_uri)
       request.add_field(@config[:header], @api_key)
       request.set_form_data(data)
-      http.request(request)
+      send_request(request, uri)
     end
 
     def create_creative(data={}, image_path='')      
@@ -76,5 +78,15 @@ module Adzerk
       :accept => :mime)
     end
 
+    def send_request(request, uri)
+      http = Net::HTTP.new(uri.host, uri.port)
+      response = http.request(request)
+      if response.kind_of? Net::HTTPClientError
+        error_response = JSON.parse(response.body)
+        raise Adzerk::ApiError.new(error_response["message"])
+      end
+      response
+    end
+
   end
 end

data/lib/adzerk/errors.rb

@@ -0,0 +1,3 @@
+module Adzerk
+  class ApiError < StandardError ; end
+end

data/lib/adzerk/geo_targeting.rb

@@ -0,0 +1,32 @@
+module Adzerk
+  class GeoTargeting
+
+    include Adzerk::Util
+
+    def initialize(args={})
+      @client = args[:client]
+    end
+
+    def create(flight_id, data={})
+      url = "flight/#{flight_id}/geotargeting"
+      data = { 'geotargeting' => camelize_data(data).to_json }
+      parse_response(@client.post_request(url, data))
+    end
+
+    def get(flight_id, id)
+      url = "flight/#{flight_id}/geotargeting/#{id}"
+      parse_response(@client.get_request(url))
+    end
+
+    def update(flight_id, id, data={})
+      url = "flight/#{flight_id}/geotargeting/#{id}"
+      data = { 'geotargeting' => camelize_data(data).to_json }
+      parse_response(@client.put_request(url, data))
+    end
+
+    def delete(flight_id, id)
+      url = "flight/#{flight_id}/geotargeting/#{id}/delete"
+      @client.get_request(url)
+    end
+  end
+end

data/lib/adzerk/site_zone_targeting.rb

@@ -0,0 +1,33 @@
+module Adzerk
+  class SiteZoneTargeting
+
+    include Adzerk::Util
+
+    def initialize(args={})
+      @client = args[:client]
+    end
+
+    def create(flight_id, data={})
+      url = "flight/#{flight_id}/sitezonetargeting"
+      data = { 'sitezone' => camelize_data(data).to_json }
+      parse_response(@client.post_request(url, data))
+    end
+
+    def get(flight_id, id)
+      url = "flight/#{flight_id}/sitezonetargeting/#{id}"
+      parse_response(@client.get_request(url))
+    end
+
+    def update(flight_id, id, data={})
+      url = "flight/#{flight_id}/sitezonetargeting/#{id}"
+      data = { 'sitezone' => camelize_data(data).to_json }
+      parse_response(@client.put_request(url, data))
+    end
+
+    def delete(flight_id, id)
+      url = "flight/#{flight_id}/sitezonetargeting/#{id}/delete"
+      @client.get_request(url)
+    end
+
+  end
+end

data/lib/adzerk/util.rb

@@ -1,15 +1,16 @@
 module Adzerk
   module Util
-    extend self
+    extend self 
 
     def camelize_data(data)
       return data unless data.respond_to?(:reduce)
       data.reduce({}) do |acc, (sym, val)|
-        acc[sym.to_s.camelize] = case val
-                                   when Hash then camelize_data(val)
-                                   when Array then val.map { |elem| camelize_data(elem) }
-                                   else val
-                                 end
+        sym = sym.to_s.camelize if sym.class == Symbol
+        acc[sym] = case val
+                     when Hash then camelize_data(val)
+                     when Array then val.map { |elem| camelize_data(elem) }
+                     else val
+                   end
         acc
       end
     end
@@ -28,10 +29,7 @@ module Adzerk
     end
 
     def parse_response(response)
-      if response.code == "200" or response.code == "400"
-        uncamelize_data(JSON.parse(response.body))
-      else
-      end
+      uncamelize_data(JSON.parse(response.body))
     end
   end
 end

data/lib/adzerk/version.rb

@@ -1,3 +1,3 @@
 module Adzerk
-  VERSION = "0.2"
+  VERSION = "0.3"
 end

data/test/adtype_api_spec.rb

@@ -0,0 +1,16 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Ad Type API" do
+
+  before(:each) do
+    @client = Adzerk::Client.new(API_KEY)
+  end
+
+  it "should list all ad_types" do
+    result = @client.ad_types.list
+    expect(result.length).to be > 0
+    expect(result[:items].last[:id].to_s).to_not eq(nil)
+    expect(result[:items].last[:width]).to_not eq(nil)
+    expect(result[:items].last[:height]).to_not eq(nil)
+  end
+end

data/test/advertiser_api_spec.rb

@@ -15,67 +15,63 @@ describe "Advertiser API" do
                                      :is_active => $is_active,
                                      :is_deleted => $is_deleted)
     $advertiser_id = advertiser[:id].to_s
-    $title.should == advertiser[:title]
-    $is_active.should == advertiser[:is_active]
-    $is_deleted.should == advertiser[:is_deleted]
+    expect($title).to eq(advertiser[:title])
+    expect($is_active).to eq(advertiser[:is_active])
+    expect($is_deleted).to eq(advertiser[:is_deleted])
   end
 
   it "should list a specific advertiser" do
     advertiser = @advertisers.get($advertiser_id)
-    $title.should == advertiser[:title]
-    $is_active.should == advertiser[:is_active]
-    $is_deleted.should == advertiser[:is_deleted]
+    expect($title).to eq(advertiser[:title])
+    expect($is_active).to eq(advertiser[:is_active])
+    expect($is_deleted).to eq(advertiser[:is_deleted])
   end
 
   it "should list all advertisers" do
     result = @advertisers.list
-    result.length.should > 0
+    expect(result.length).to be > 0
     advertiser = result[:items].last
-    $title.should == advertiser[:title]
-    $is_active.should == advertiser[:is_active]
-    $is_deleted.should == advertiser[:is_deleted]
-    $advertiser_id.should == advertiser[:id].to_s
+    expect($title).to eq(advertiser[:title])
+    expect($is_active).to eq(advertiser[:is_active])
+    expect($is_deleted).to eq(advertiser[:is_deleted])
+    expect($advertiser_id).to eq(advertiser[:id].to_s)
   end
 
   it "should update a advertiser" do
     advertiser = @advertisers.update(:id => $advertiser_id,
                                      :title => "Cocacola",
                                      :is_active => false)
-    advertiser[:title].should eq("Cocacola")
-    advertiser[:is_active].should eq(false)
+    expect(advertiser[:title]).to eq("Cocacola")
+    expect(advertiser[:is_active]).to eq(false)
   end
 
   it "should search advertiser based on name" do
     advertiser = @advertisers.search("Cocacola")
-    advertiser[:total_items].should > 0
+    expect(advertiser[:total_items]).to be > 0
   end
 
   it "should delete a new advertiser" do
     response = @advertisers.delete($advertiser_id)
-    response.body.should == '"Successfully deleted."'
+    expect(response.body).to eq('"Successfully deleted."')
   end
 
   it "should not list deleted advertisers" do
     response = @advertisers.list
     response[:items].each do |r|
-      r["Id"].should_not == $advertiser_id
+      expect(r["Id"]).not_to eq($advertiser_id)
     end
   end
 
   it "should not get individual deleted advertiser" do
-    response = @advertisers.get $advertiser_id
-    response[:message].should eq("This advertiser is deleted.")
+    expect { @advertisers.get $advertiser_id }.to raise_error("This advertiser is deleted.")
   end
 
   it "should not update a deleted advertiser" do
-    advertiser = @advertisers.update(:id => $advertiser_id,
-                                     :title => "Cocacola")
-    advertiser[:message].should eq("This advertiser is deleted.")
+    expect { @advertisers.update(:id => $advertiser_id, :title => "Cocacola") }.to raise_error("This advertiser is deleted.")
   end
 
   it "should require a title" do
-    response = @advertisers.create()
-    response[:message].should eq("A title is required.")
+    expect{ @advertisers.create() }.to raise_error("A title is required.")
   end
 
 end

data/test/campaign_api_spec.rb

@@ -48,14 +48,14 @@ describe "Campaign API" do
                                  :is_deleted => false)
 
     $campaign_id = campaign[:id].to_s
-    $campaign_name.should == campaign[:name]
+    expect($campaign_name).to eq(campaign[:name])
     # JSON.parse(response.body)["StartDate"].should == "/Date(1293858000000-0500)/"
     # JSON.parse(response.body)["EndDate"].should == "/Date(1325307600000-0500)/"
-    $campaign_is_active.should == campaign[:is_active]
-    $campaign_price.to_f.should == campaign[:price]
-    $campaign_advertiser_id.should == campaign[:advertiser_id]
-    campaign[:is_deleted].should == false
-    campaign[:flights].should eq([])
+    expect($campaign_is_active).to eq(campaign[:is_active])
+    expect($campaign_price.to_f).to eq(campaign[:price])
+    expect($campaign_advertiser_id).to eq(campaign[:advertiser_id])
+    expect(campaign[:is_deleted]).to eq(false)
+    expect(campaign[:flights]).to eq([])
   end
 
   it "should create a new campaign with one flight" do
@@ -82,22 +82,22 @@ describe "Campaign API" do
     }
     campaign = @campaigns.create(new1_campaign)
     $campaign_id_1 = campaign[:id].to_s
-    $campaign_name.should == campaign[:name]
+    expect($campaign_name).to eq(campaign[:name])
     # JSON.parse(response.body)["StartDate"].should == "/Date(1293858000000-0500)/"
     # JSON.parse(response.body)["EndDate"].should == "/Date(1325307600000-0500)/"
-    $campaign_is_active.should == campaign[:is_active]
-    campaign[:is_deleted].should == false
-    $campaign_price.to_f.should == campaign[:price]
-    $campaign_advertiser_id.should == campaign[:advertiser_id]
-    campaign[:flights].first[:id].should_not == nil
+    expect($campaign_is_active).to eq(campaign[:is_active])
+    expect(campaign[:is_deleted]).to eq(false)
+    expect($campaign_price.to_f).to eq(campaign[:price])
+    expect($campaign_advertiser_id).to eq(campaign[:advertiser_id])
+    expect(campaign[:flights].first[:id]).not_to eq(nil)
   end
 
 
   it "should list a specific campaign" do
     campaign = @campaigns.get($campaign_id_1)
-    campaign[:id].should eq($campaign_id_1.to_i)
-    campaign[:flights].should_not be_empty
-    campaign[:name].should eq($campaign_name)
+    expect(campaign[:id]).to eq($campaign_id_1.to_i)
+    expect(campaign[:flights]).not_to be_empty
+    expect(campaign[:name]).to eq($campaign_name)
   end
 
   it "should update a campaign" do
@@ -121,34 +121,19 @@ describe "Campaign API" do
     }
 
     campaign = @campaigns.update(campaign_to_update)
-    campaign[:name].should eq($campaign_name)
+    expect(campaign[:name]).to eq($campaign_name)
     # JSON.parse(response.body)["StartDate"].should == "/Date(1293858000000-0500)/"
     # JSON.parse(response.body)["EndDate"].should == "/Date(1325307600000-0500)/"
-    campaign[:is_active].should eq($campaign_is_active)
-    campaign[:price].should eq($campaign_price.to_f)
-    campaign[:advertiser_id].should eq($campaign_advertiser_id)
-    campaign[:is_deleted].should eq(false)
-    campaign[:flights].should eq($campaign_flights)
+    expect(campaign[:is_active]).to eq($campaign_is_active)
+    expect(campaign[:price]).to eq($campaign_price.to_f)
+    expect(campaign[:advertiser_id]).to eq($campaign_advertiser_id)
+    expect(campaign[:is_deleted]).to eq(false)
+    expect(campaign[:flights]).to eq($campaign_flights)
   end
 
   it "should list all campaigns" do
     campaigns = @campaigns.list
-    campaigns.length.should > 0
-  end
-
-  it "should delete a new campaign" do
-    response = @campaigns.delete($campaign_id)
-    response.body.should == '"Successfully deleted."'
-  end
-
-  it "should not update a deleted campaign" do
-    campaign_to_update = {
-      :id => $campaign_id,
-      :name => "test"
-    }
-
-    campaign = @campaigns.update(campaign_to_update)
-    campaign[:message].should eq("This advertiser is not part of your network")
+    expect(campaigns.length).to be > 0
   end
 
   it "should not create/update a campaign with a advertiserId that doesn't belong to it" do
@@ -163,8 +148,7 @@ describe "Campaign API" do
       :is_deleted => false
     }
 
-    campaign = @campaigns.create(new_campaign)
-    campaign[:message].should eq("This advertiser is not part of your network")
+    expect{ @campaigns.create(new_campaign) }.to raise_error("This advertiser is not part of your network")
 
     updated_campaign = {
       :id => $campaign_id,
@@ -178,13 +162,25 @@ describe "Campaign API" do
       :is_deleted => false
     }
 
-    campaign = @campaigns.update(updated_campaign)
-    campaign[:message].should eq("This advertiser is not part of your network")
+    expect{ @campaigns.update(updated_campaign) }.to raise_error("This advertiser is not part of your network")
   end
 
   it "should not retrieve a campaign with a advertiserId that doesn't belong to it" do
-    response = @campaigns.get('123')
-    response[:message].should eq("This campaign is not part of your network")
+    expect { @campaigns.get('123') }.to raise_error("This campaign is not part of your network")
+  end
+
+    it "should delete a new campaign" do
+    response = @campaigns.delete($campaign_id)
+    expect(response.body).to eq('"Successfully deleted."')
+  end
+
+  it "should not update a deleted campaign" do
+    campaign_to_update = {
+      :id => $campaign_id,
+      :name => "test"
+    }
+
+    expect { @campaigns.update(campaign_to_update) }.to raise_error("This campaign has been deleted")
   end
 
 end