constantcontact 1.3.2 → 2.0.0

data/lib/constantcontact/services/contact_tracking_service.rb

@@ -10,16 +10,15 @@ module ConstantContact
       class << self
 
         # Get bounces for a given contact
-        # @param [String] access_token - Constant Contact OAuth2 access token
         # @param [String] contact_id - Contact id
         # @param [Hash] params - query parameters to be appended to request
         # @return [ResultSet<BounceActivity>] - Containing a results array of BounceActivity
-        def get_bounces(access_token, contact_id, params = {})
+        def get_bounces(contact_id, params = {})
           url = Util::Config.get('endpoints.base_url') +
                 sprintf(Util::Config.get('endpoints.contact_tracking_bounces'), contact_id)
           url = build_url(url, params)
 
-          response = RestClient.get(url, get_headers(access_token))
+          response = RestClient.get(url, get_headers())
           body = JSON.parse(response.body)
 
           bounces = []
@@ -32,16 +31,15 @@ module ConstantContact
 
 
         # Get clicks for a given contact
-        # @param [String] access_token - Constant Contact OAuth2 access token
         # @param [String] contact_id - Contact id
         # @param [Hash] params - query parameters to be appended to request
         # @return [ResultSet<ClickActivity>] - Containing a results array of ClickActivity
-        def get_clicks(access_token, contact_id, params = {})
+        def get_clicks(contact_id, params = {})
           url = Util::Config.get('endpoints.base_url') +
                 sprintf(Util::Config.get('endpoints.contact_tracking_clicks'), contact_id)
           url = build_url(url, params)
 
-          response = RestClient.get(url, get_headers(access_token))
+          response = RestClient.get(url, get_headers())
           body = JSON.parse(response.body)
 
           clicks = []
@@ -54,16 +52,15 @@ module ConstantContact
 
 
         # Get forwards for a given contact
-        # @param [String] access_token - Constant Contact OAuth2 access token
         # @param [String] contact_id - Contact id
         # @param [Hash] params - query parameters to be appended to request
         # @return [ResultSet<ForwardActivity>] - Containing a results array of ForwardActivity
-        def get_forwards(access_token, contact_id, params = {})
+        def get_forwards(contact_id, params = {})
           url = Util::Config.get('endpoints.base_url') +
                 sprintf(Util::Config.get('endpoints.contact_tracking_forwards'), contact_id)
           url = build_url(url, params)
 
-          response = RestClient.get(url, get_headers(access_token))
+          response = RestClient.get(url, get_headers())
           body = JSON.parse(response.body)
 
           forwards = []
@@ -76,16 +73,15 @@ module ConstantContact
 
 
         # Get opens for a given contact
-        # @param [String] access_token - Constant Contact OAuth2 access token
         # @param [String] contact_id - Contact id
         # @param [Hash] params - query parameters to be appended to request
         # @return [ResultSet<OpenActivity>] - Containing a results array of OpenActivity
-        def get_opens(access_token, contact_id, params = {})
+        def get_opens(contact_id, params = {})
           url = Util::Config.get('endpoints.base_url') +
                 sprintf(Util::Config.get('endpoints.contact_tracking_opens'), contact_id)
           url = build_url(url, params)
 
-          response = RestClient.get(url, get_headers(access_token))
+          response = RestClient.get(url, get_headers())
           body = JSON.parse(response.body)
 
           opens = []
@@ -98,16 +94,15 @@ module ConstantContact
 
 
         # Get sends for a given contact
-        # @param [String] access_token - Constant Contact OAuth2 access token
         # @param [String] contact_id - Contact id
         # @param [Hash] params - query parameters to be appended to request
         # @return [ResultSet<SendActivity>] - Containing a results array of SendActivity
-        def get_sends(access_token, contact_id, params = {})
+        def get_sends(contact_id, params = {})
           url = Util::Config.get('endpoints.base_url') +
                 sprintf(Util::Config.get('endpoints.contact_tracking_sends'), contact_id)
           url = build_url(url, params)
 
-          response = RestClient.get(url, get_headers(access_token))
+          response = RestClient.get(url, get_headers())
           body = JSON.parse(response.body)
 
           sends = []
@@ -120,16 +115,15 @@ module ConstantContact
 
 
         # Get unsubscribes for a given contact
-        # @param [String] access_token - Constant Contact OAuth2 access token
         # @param [String] contact_id - Contact id
         # @param [Hash] params - query parameters to be appended to request
         # @return [ResultSet<UnsubscribeActivity>] - Containing a results array of UnsubscribeActivity
-        def get_unsubscribes(access_token, contact_id, params = {})
+        def get_unsubscribes(contact_id, params = {})
           url = Util::Config.get('endpoints.base_url') +
                 sprintf(Util::Config.get('endpoints.contact_tracking_unsubscribes'), contact_id)
           url = build_url(url, params)
 
-          response = RestClient.get(url, get_headers(access_token))
+          response = RestClient.get(url, get_headers())
           body = JSON.parse(response.body)
 
           unsubscribes = []
@@ -142,14 +136,13 @@ module ConstantContact
 
 
         # Get a summary of reporting data for a given contact
-        # @param [String] access_token - Constant Contact OAuth2 access token
         # @param [String] contact_id - Contact id
         # @return [TrackingSummary]
-        def get_summary(access_token, contact_id)
+        def get_summary(contact_id)
           url = Util::Config.get('endpoints.base_url') +
                 sprintf(Util::Config.get('endpoints.contact_tracking_summary'), contact_id)
           url = build_url(url)
-          response = RestClient.get(url, get_headers(access_token))
+          response = RestClient.get(url, get_headers())
           Components::TrackingSummary.create(JSON.parse(response.body))
         end
 

data/lib/constantcontact/services/email_marketing_service.rb

@@ -10,27 +10,25 @@ module ConstantContact
       class << self
 
         # Create a new campaign
-        # @param [String] access_token - Constant Contact OAuth2 access token
         # @param [Campaign] campaign - Campaign to be created
         # @return [Campaign]
-        def add_campaign(access_token, campaign)
+        def add_campaign(campaign)
           url = Util::Config.get('endpoints.base_url') + Util::Config.get('endpoints.campaigns')
           url = build_url(url)
           payload = campaign.to_json
-          response = RestClient.post(url, payload, get_headers(access_token))
+          response = RestClient.post(url, payload, get_headers())
           Components::Campaign.create(JSON.parse(response.body))
         end
 
 
         # Get a set of campaigns
-        # @param [String] access_token Constant Contact OAuth2 access token
         # @param [Hash] params - query parameters to be appended to the request
         # @return [ResultSet<Campaign>]
-        def get_campaigns(access_token, params = {})
+        def get_campaigns(params = {})
           url = Util::Config.get('endpoints.base_url') + Util::Config.get('endpoints.campaigns')
           url = build_url(url, params)
 
-          response = RestClient.get(url, get_headers(access_token))
+          response = RestClient.get(url, get_headers())
           body = JSON.parse(response.body)
 
           campaigns = []
@@ -43,41 +41,38 @@ module ConstantContact
 
 
         # Get campaign details for a specific campaign
-        # @param [String] access_token - Constant Contact OAuth2 access token
         # @param [Integer] campaign_id - Valid campaign id
         # @return [Campaign]
-        def get_campaign(access_token, campaign_id)
+        def get_campaign(campaign_id)
           url = Util::Config.get('endpoints.base_url') +
                 sprintf(Util::Config.get('endpoints.campaign'), campaign_id)
           url = build_url(url)
-          response = RestClient.get(url, get_headers(access_token))
+          response = RestClient.get(url, get_headers())
           Components::Campaign.create(JSON.parse(response.body))
         end
 
 
         # Delete an email campaign
-        # @param [String] access_token - Constant Contact OAuth2 access token
         # @param [Integer] campaign_id - Valid campaign id
         # @return [Boolean]
-        def delete_campaign(access_token, campaign_id)
+        def delete_campaign(campaign_id)
           url = Util::Config.get('endpoints.base_url') +
                 sprintf(Util::Config.get('endpoints.campaign'), campaign_id)
           url = build_url(url)
-          response = RestClient.delete(url, get_headers(access_token))
+          response = RestClient.delete(url, get_headers())
           response.code == 204
         end
 
 
         # Update a specific email campaign
-        # @param [String] access_token - Constant Contact OAuth2 access token
         # @param [Campaign] campaign - Campaign to be updated
         # @return [Campaign]
-        def update_campaign(access_token, campaign)
+        def update_campaign(campaign)
           url = Util::Config.get('endpoints.base_url') +
                 sprintf(Util::Config.get('endpoints.campaign'), campaign.id)
           url = build_url(url)
           payload = campaign.to_json
-          response = RestClient.put(url, payload, get_headers(access_token))
+          response = RestClient.put(url, payload, get_headers())
           Components::Campaign.create(JSON.parse(response.body))
         end
 

data/lib/constantcontact/services/event_spot_service.rb

@@ -10,30 +10,28 @@ module ConstantContact
       class << self
 
         # Create a new event
-        # @param [String] access_token - Constant Contact OAuth2 access token
         # @param [Event] event - Event to be created
         # @return [Event]
-        def add_event(access_token, event)
+        def add_event(event)
           url = Util::Config.get('endpoints.base_url') + Util::Config.get('endpoints.events')
           url = build_url(url)
           payload = event.to_json
-          response = RestClient.post(url, payload, get_headers(access_token))
+          response = RestClient.post(url, payload, get_headers())
           Components::Event.create(JSON.parse(response.body))
         end
 
 
         # Get a set of events
-        # @param [String] access_token Constant Contact OAuth2 access token
         # @param [Hash] opts query parameters to be appended to the request
         # @option opts [String] status email campaigns status of DRAFT, RUNNING, SENT, SCHEDULED.
         # @option opts [String] modified_since ISO-8601 date string to return campaigns modified since then.
         # @option opts [Integer] limit number of campaigns to return, 1 to 50.
         # @return [ResultSet<Event>]
-        def get_events(access_token, opts = {})
+        def get_events(opts = {})
           url = Util::Config.get('endpoints.base_url') + Util::Config.get('endpoints.events')
           url = build_url(url, opts)
 
-          response = RestClient.get(url, get_headers(access_token))
+          response = RestClient.get(url, get_headers())
           body = JSON.parse(response.body)
 
           events = body['results'].collect do |event|
@@ -45,91 +43,85 @@ module ConstantContact
 
 
         # Get event details for a specific event
-        # @param [String] access_token - Constant Contact OAuth2 access token
         # @param [Integer] event - Valid event id
         # @return [Event]
-        def get_event(access_token, event)
+        def get_event(event)
           event_id = get_id_for(event)
           url = Util::Config.get('endpoints.base_url') +
                 sprintf(Util::Config.get('endpoints.event'), event_id)
           url = build_url(url)
-          response = RestClient.get(url, get_headers(access_token))
+          response = RestClient.get(url, get_headers())
           Components::Event.create(JSON.parse(response.body))
         end
 
 
         # Update a specific EventSpot event
-        # @param [String] access_token - Constant Contact OAuth2 access token
         # @param [Event] event - Event to be updated
         # @return [Event]
-        def update_event(access_token, event)
+        def update_event(event)
           event_id = get_id_for(event)
           url = Util::Config.get('endpoints.base_url') +
                 sprintf(Util::Config.get('endpoints.event'), event_id)
           url = build_url(url)
           payload = event.to_json
-          response = RestClient.put(url, payload, get_headers(access_token))
+          response = RestClient.put(url, payload, get_headers())
           Components::Event.create(JSON.parse(response.body))
         end
 
 
         # Publish a specific EventSpot event
-        # @param [String] access_token - Constant Contact OAuth2 access token
         # @param [Event] event - Event to be updated
         # @return [Event]
-        def publish_event(access_token, event)
+        def publish_event(event)
           event_id = get_id_for(event)
           url = Util::Config.get('endpoints.base_url') +
                 sprintf(Util::Config.get('endpoints.event'), event_id)
           url = build_url(url)
           payload = [{:op => "REPLACE", :path => "#/status", :value => "ACTIVE"}].to_json
-          response = RestClient.patch(url, payload, get_headers(access_token))
+          response = RestClient.patch(url, payload, get_headers())
           Components::Event.create(JSON.parse(response.body))
         end
 
 
         # Cancel a specific EventSpot event
-        # @param [String] access_token - Constant Contact OAuth2 access token
         # @param [Event] event - Event to be updated
         # @return [Event]
-        def cancel_event(access_token, event)
+        def cancel_event(event)
           event_id = get_id_for(event)
           url = Util::Config.get('endpoints.base_url') +
                 sprintf(Util::Config.get('endpoints.event'), event_id)
           url = build_url(url)
           payload = [{ :op => "REPLACE", :path => "#/status", :value => "CANCELLED" }].to_json
-          response = RestClient.patch(url, payload, get_headers(access_token))
+          response = RestClient.patch(url, payload, get_headers())
           Components::Event.create(JSON.parse(response.body))
         end
 
 
         # Create a new event fee
-        # @param [String] access_token - Constant Contact OAuth2 access token
         # @param [Integer] event - Valid event id
         # @param [EventFee] fee - Event fee to be created
         # @return [EventFee]
-        def add_fee(access_token, event, fee)
+        def add_fee(event, fee)
           event_id = get_id_for(event)
           url = Util::Config.get('endpoints.base_url') +
                 sprintf(Util::Config.get('endpoints.event_fees'), event_id)
           url = build_url(url)
           payload = fee.to_json
-          response = RestClient.post(url, payload, get_headers(access_token))
+          response = RestClient.post(url, payload, get_headers())
           Components::EventFee.create(JSON.parse(response.body))
         end
 
 
         # Get an array of event fees
-        # @param [String] access_token - Constant Contact OAuth2 access token
         # @param [Integer] event - Valid event id
         # @return [Array<EventFee>]
-        def get_fees(access_token, event)
+        def get_fees(event)
           event_id = get_id_for(event)
           url = Util::Config.get('endpoints.base_url') +
                 sprintf(Util::Config.get('endpoints.event_fees'), event_id)
           url = build_url(url)
 
-          response = RestClient.get(url, get_headers(access_token))
+          response = RestClient.get(url, get_headers())
           body = JSON.parse(response.body)
           
           fees = body.collect do |fee|
@@ -139,28 +131,26 @@ module ConstantContact
 
 
         # Get an individual event fee
-        # @param [String] access_token - Constant Contact OAuth2 access token
         # @param [Integer] event - Valid event id
         # @param [Integer] fee - Valid fee id
         # @return [EventFee]
-        def get_fee(access_token, event, fee)
+        def get_fee(event, fee)
           event_id  = get_id_for(event)
           fee_id    = get_id_for(fee)
           url = Util::Config.get('endpoints.base_url') +
                 sprintf(Util::Config.get('endpoints.event_fee'), event_id, fee_id)
           url = build_url(url)
 
-          response = RestClient.get(url, get_headers(access_token))
+          response = RestClient.get(url, get_headers())
          fee = Components::EventFee.create(JSON.parse(response.body))
         end
 
 
         # Update an individual event fee
-        # @param [String] access_token - Constant Contact OAuth2 access token
         # @param [Integer] event - Valid event id
         # @param [Integer] fee - Valid fee id
         # @return [EventFee]
-        def update_fee(access_token, event, fee)
+        def update_fee(event, fee)
           event_id  = get_id_for(event)
           if fee.kind_of?(ConstantContact::Components::EventFee)
             fee_id = fee.id
@@ -175,39 +165,37 @@ module ConstantContact
           url = build_url(url)
           payload = fee.to_json
 
-          response = RestClient.put(url, payload, get_headers(access_token))
+          response = RestClient.put(url, payload, get_headers())
          fee = Components::EventFee.create(JSON.parse(response.body))
         end
 
 
         # Delete an individual event fee
-        # @param [String] access_token - Constant Contact OAuth2 access token
         # @param [Integer] event - Valid event id
         # @param [Integer] fee - Valid fee id
         # @return [Boolean]
-        def delete_fee(access_token, event, fee)
+        def delete_fee(event, fee)
           event_id  = get_id_for(event)
           fee_id    = get_id_for(fee)
           url = Util::Config.get('endpoints.base_url') +
                 sprintf(Util::Config.get('endpoints.event_fee'), event_id, fee_id)
           url = build_url(url)
 
-          response = RestClient.delete(url, get_headers(access_token))
+          response = RestClient.delete(url, get_headers())
           response.code == 204
         end
 
 
         # Get a set of event registrants
-        # @param [String] access_token - Constant Contact OAuth2 access token
         # @param [Integer] event - Valid event id
         # @return [ResultSet<Registrant>]
-        def get_registrants(access_token, event)
+        def get_registrants(event)
           event_id  = event.kind_of?(ConstantContact::Components::Event) ? event.id : event
           url = Util::Config.get('endpoints.base_url') +
                 sprintf(Util::Config.get('endpoints.event_registrants'), event_id)
           url = build_url(url)
 
-          response = RestClient.get(url, get_headers(access_token))
+          response = RestClient.get(url, get_headers())
           body = JSON.parse(response.body)
 
           registrants = body['results'].collect do |registrant|
@@ -219,31 +207,29 @@ module ConstantContact
 
 
         # Get an individual event registant
-        # @param [String] access_token - Constant Contact OAuth2 access token
         # @param [Integer] event - Valid event id
         # @param [Integer] registrant - Valid fee id
         # @return [Registrant]
-        def get_registrant(access_token, event, registrant)
+        def get_registrant(event, registrant)
           event_id      = get_id_for(event)
           registrant_id  = get_id_for(registrant)
           url = Util::Config.get('endpoints.base_url') +
                 sprintf(Util::Config.get('endpoints.event_registrant'), event_id, registrant_id)
           url = build_url(url)
 
-          response = RestClient.get(url, get_headers(access_token))
+          response = RestClient.get(url, get_headers())
           Components::Registrant.create(JSON.parse(response.body))
         end
 
 
         # Get an array of event items for an individual event
-        # @param [String] access_token - Constant Contact OAuth2 access token
         # @param [Integer] event_id - event id to retrieve items for
         # @return [Array<EventItem>]
-        def get_event_items(access_token, event_id)
+        def get_event_items(event_id)
           url = Util::Config.get('endpoints.base_url') + 
                 sprintf(Util::Config.get('endpoints.event_items'), event_id)
           url = build_url(url)
-          response = RestClient.get(url, get_headers(access_token))
+          response = RestClient.get(url, get_headers())
 
           event_items = []
           JSON.parse(response.body).each do |event_item|
@@ -255,73 +241,68 @@ module ConstantContact
 
 
         # Get an individual event item
-        # @param [String] access_token - Constant Contact OAuth2 access token
         # @param [Integer] event_id - id of event to retrieve item for
         # @param [Integer] item_id - id of item to be retrieved
         # @return [EventItem]
-        def get_event_item(access_token, event_id, item_id)
+        def get_event_item(event_id, item_id)
           url = Util::Config.get('endpoints.base_url') + 
                 sprintf(Util::Config.get('endpoints.event_item'), event_id, item_id)
           url = build_url(url)
-          response = RestClient.get(url, get_headers(access_token))
+          response = RestClient.get(url, get_headers())
           Components::EventItem.create(JSON.parse(response.body))
         end
 
 
         # Create a new event item for an event
-        # @param [String] access_token - Constant Contact OAuth2 access token
         # @param [Integer] event_id - id of event to be associated with the event item
         # @param [EventItem] event_item - event item to be created
         # @return [EventItem]
-        def add_event_item(access_token, event_id, event_item)
+        def add_event_item(event_id, event_item)
           url = Util::Config.get('endpoints.base_url') +
                 sprintf(Util::Config.get('endpoints.event_items'), event_id)
           url = build_url(url)
           payload = event_item.to_json
-          response = RestClient.post(url, payload, get_headers(access_token))
+          response = RestClient.post(url, payload, get_headers())
           Components::EventItem.create(JSON.parse(response.body))
         end
 
 
         # Delete a specific event item for an event
-        # @param [String] access_token - Constant Contact OAuth2 access token
         # @param [Integer] event_id - id of event to delete an event item for
         # @param [Integer] item_id - id of event item to be deleted
         # @return [Boolean]
-        def delete_event_item(access_token, event_id, item_id)
+        def delete_event_item(event_id, item_id)
           url = Util::Config.get('endpoints.base_url') +
                 sprintf(Util::Config.get('endpoints.event_item'), event_id, item_id)
           url = build_url(url)
-          response = RestClient.delete(url, get_headers(access_token))
+          response = RestClient.delete(url, get_headers())
           response.code == 204
         end
 
 
         # Update a specific event item for an event
-        # @param [String] access_token - Constant Contact OAuth2 access token
         # @param [Integer] event_id - id of event associated with the event item
         # @param [EventItem] event_item - event item to be updated
         # @return [EventItem]
-        def update_event_item(access_token, event_id, event_item)
+        def update_event_item(event_id, event_item)
           url = Util::Config.get('endpoints.base_url') +
                 sprintf(Util::Config.get('endpoints.event_item'), event_id, event_item.id)
           url = build_url(url)
           payload = event_item.to_json
-          response = RestClient.put(url, payload, get_headers(access_token))
+          response = RestClient.put(url, payload, get_headers())
           Components::EventItem.create(JSON.parse(response.body))
         end
 
 
         # Get an array of attributes for an individual event item
-        # @param [String] access_token - Constant Contact OAuth2 access token
         # @param [Integer] event_id - event id to retrieve item for
         # @param [Integer] item_id - event item id to retrieve attributes for
         # @return [Array<EventItemAttribute>]
-        def get_event_item_attributes(access_token, event_id, item_id)
+        def get_event_item_attributes(event_id, item_id)
           url = Util::Config.get('endpoints.base_url') + 
                 sprintf(Util::Config.get('endpoints.event_item_attributes'), event_id, item_id)
           url = build_url(url)
-          response = RestClient.get(url, get_headers(access_token))
+          response = RestClient.get(url, get_headers())
 
           event_item_attributes = []
           JSON.parse(response.body).each do |event_item_attribute|
@@ -333,76 +314,71 @@ module ConstantContact
 
 
         # Get an individual event item attribute
-        # @param [String] access_token - Constant Contact OAuth2 access token
         # @param [Integer] event_id - id of event to retrieve item for
         # @param [Integer] item_id - id of item to retrieve attribute for
         # @param [Integer] attribute_id - id of attribute to be retrieved
         # @return [EventItemAttribute]
-        def get_event_item_attribute(access_token, event_id, item_id, attribute_id)
+        def get_event_item_attribute(event_id, item_id, attribute_id)
           url = Util::Config.get('endpoints.base_url') + 
                 sprintf(Util::Config.get('endpoints.event_item_attribute'), event_id, item_id, attribute_id)
           url = build_url(url)
-          response = RestClient.get(url, get_headers(access_token))
+          response = RestClient.get(url, get_headers())
           Components::EventItemAttribute.create(JSON.parse(response.body))
         end
 
 
         # Create a new event item attribute for an event item
-        # @param [String] access_token - Constant Contact OAuth2 access token
         # @param [Integer] event_id - id of event to be associated with the event item attribute
         # @param [Integer] item_id - id of event item to be associated with the event item attribute
         # @param [EventItemAttribute] event_item_attribute - event item attribute to be created
         # @return [EventItemAttribute]
-        def add_event_item_attribute(access_token, event_id, item_id, event_item_attribute)
+        def add_event_item_attribute(event_id, item_id, event_item_attribute)
           url = Util::Config.get('endpoints.base_url') +
                 sprintf(Util::Config.get('endpoints.event_item_attributes'), event_id, item_id)
           url = build_url(url)
           payload = event_item_attribute.to_json
-          response = RestClient.post(url, payload, get_headers(access_token))
+          response = RestClient.post(url, payload, get_headers())
           Components::EventItemAttribute.create(JSON.parse(response.body))
         end
 
 
         # Delete a specific event item for an event
-        # @param [String] access_token - Constant Contact OAuth2 access token
         # @param [Integer] event_id - id of event to delete an event item attribute for
         # @param [Integer] item_id - id of event item to delete an event item attribute for
         # @param [Integer] attribute_id - id of attribute to be deleted
         # @return [Boolean]
-        def delete_event_item_attribute(access_token, event_id, item_id, attribute_id)
+        def delete_event_item_attribute(event_id, item_id, attribute_id)
           url = Util::Config.get('endpoints.base_url') +
                 sprintf(Util::Config.get('endpoints.event_item_attribute'), event_id, item_id, attribute_id)
           url = build_url(url)
-          response = RestClient.delete(url, get_headers(access_token))
+          response = RestClient.delete(url, get_headers())
           response.code == 204
         end
 
 
         # Update a specific event item attribute for an event item
-        # @param [String] access_token - Constant Contact OAuth2 access token
         # @param [Integer] event_id - id of event associated with the event item
         # @param [Integer] item_id - id of event item associated with the event item attribute
         # @param [EventItemAttribute] event_item_attribute - event item to be updated
         # @return [EventItemAttribute]
-        def update_event_item_attribute(access_token, event_id, item_id, event_item_attribute)
+        def update_event_item_attribute(event_id, item_id, event_item_attribute)
           url = Util::Config.get('endpoints.base_url') +
                 sprintf(Util::Config.get('endpoints.event_item'), event_id, item_id, event_item_attribute.id)
           url = build_url(url)
           payload = event_item_attribute.to_json
-          response = RestClient.put(url, payload, get_headers(access_token))
+          response = RestClient.put(url, payload, get_headers())
           Components::EventItemAttribute.create(JSON.parse(response.body))
         end
 
 
         # Get an array of promocodes for an individual event
-        # @param [String] access_token - Constant Contact OAuth2 access token
         # @param [Integer] event_id - event id to retrieve promocodes for
         # @return [Array<Promocode>]
-        def get_promocodes(access_token, event_id)
+        def get_promocodes(event_id)
           url = Util::Config.get('endpoints.base_url') + 
                 sprintf(Util::Config.get('endpoints.event_promocodes'), event_id)
           url = build_url(url)
-          response = RestClient.get(url, get_headers(access_token))
+          response = RestClient.get(url, get_headers())
 
           promocodes = []
           JSON.parse(response.body).each do |promocode|
@@ -414,63 +390,58 @@ module ConstantContact
 
 
         # Get an individual promocode
-        # @param [String] access_token - Constant Contact OAuth2 access token
         # @param [Integer] event_id - id of event to retrieve item for
         # @param [Integer] promocode_id - id of item to be retrieved
         # @return [Promocode]
-        def get_promocode(access_token, event_id, promocode_id)
+        def get_promocode(event_id, promocode_id)
           url = Util::Config.get('endpoints.base_url') + 
                 sprintf(Util::Config.get('endpoints.event_promocode'), event_id, promocode_id)
           url = build_url(url)
-          response = RestClient.get(url, get_headers(access_token))
+          response = RestClient.get(url, get_headers())
           Components::Promocode.create(JSON.parse(response.body))
         end
 
 
         # Create a new promocode for an event
-        # @param [String] access_token - Constant Contact OAuth2 access token
         # @param [Integer] event_id - id of event to be associated with the promocode
         # @param [Promocode] promocode - promocode to be created
         # @return [Promocode]
-        def add_promocode(access_token, event_id, promocode)
+        def add_promocode(event_id, promocode)
           url = Util::Config.get('endpoints.base_url') +
                 sprintf(Util::Config.get('endpoints.event_promocodes'), event_id)
           url = build_url(url)
           payload = promocode.to_json
-          response = RestClient.post(url, payload, get_headers(access_token))
+          response = RestClient.post(url, payload, get_headers())
           Components::Promocode.create(JSON.parse(response.body))
         end
 
 
         # Delete a specific promocode for an event
-        # @param [String] access_token - Constant Contact OAuth2 access token
         # @param [Integer] event_id - id of event to delete a promocode for
         # @param [Integer] promocode_id - id of promocode to be deleted
         # @return [Boolean]
-        def delete_promocode(access_token, event_id, promocode_id)
+        def delete_promocode(event_id, promocode_id)
           url = Util::Config.get('endpoints.base_url') +
                 sprintf(Util::Config.get('endpoints.event_promocode'), event_id, promocode_id)
           url = build_url(url)
-          response = RestClient.delete(url, get_headers(access_token))
+          response = RestClient.delete(url, get_headers())
           response.code == 204
         end
 
 
         # Update a specific promocode for an event
-        # @param [String] access_token - Constant Contact OAuth2 access token
         # @param [Integer] event_id - id of event associated with the promocode
         # @param [Promocode] promocode - promocode to be updated
         # @return [Promocode]
-        def update_promocode(access_token, event_id, promocode)
+        def update_promocode(event_id, promocode)
           url = Util::Config.get('endpoints.base_url') +
                 sprintf(Util::Config.get('endpoints.event_promocode'), event_id, promocode.id)
           url = build_url(url)
           payload = promocode.to_json
-          response = RestClient.put(url, payload, get_headers(access_token))
+          response = RestClient.put(url, payload, get_headers())
           Components::Promocode.create(JSON.parse(response.body))
         end
 
-
       end
     end
   end