adparlor-facebook 0.5.9

data/lib/adparlor/facebook/graph_api/ad_targeting_types/ad_work_employer.rb

@@ -0,0 +1,11 @@
+module Adparlor
+  module Facebook
+    module GraphApi
+      module AdTargetingTypes
+        class AdWorkEmployer
+          attr_accessor :id, :name, :coverage, :subtext
+        end
+      end
+    end
+  end
+end

data/lib/adparlor/facebook/graph_api/ad_targeting_types/ad_work_position.rb

@@ -0,0 +1,11 @@
+module Adparlor
+  module Facebook
+    module GraphApi
+      module AdTargetingTypes
+        class AdWorkPosition
+          attr_accessor :id, :name, :coverage
+        end
+      end
+    end
+  end
+end

data/lib/adparlor/facebook/graph_api/ad_video.rb

@@ -0,0 +1,124 @@
+require 'mime/types'
+require 'open-uri'
+
+module Adparlor
+  module Facebook
+    module GraphApi
+      class AdVideo < GraphObject
+        include Fields::AdVideo
+        include Traits::Methods
+        field_attrs FIELDS
+        allow_local_method :create, :destroy, :update
+
+        def base_uri
+          'https://graph-video.facebook.com'
+        end
+
+        def thumbnails
+          @thumbnails ||= CollectionProxy.new VideoThumbnail, "/#{id}/thumbnails", access_token
+        end
+
+        def path
+          raise FbError.new('missing one of account_id, user_id, event_id, page_id or group_id required for video creation', 500) unless @account_id || @user_id || @event_id || @page_id || @group_id
+          if @account_id
+            "/act_#{@account_id}/advideos"
+          else
+            "/#{@user_id || @event_id || @page_id || @group_id}/videos"
+          end
+        end
+
+        def post(path, options, _method = nil)
+          if @slideshow_spec
+            super(path, options)
+          else
+            response = start_video_request(options)
+            raise response['error']['message'] if response.key?('error')
+            upload_session_id = response['upload_session_id']
+            video_id = response['video_id']
+            loop do
+              response = upload_chunk(response['start_offset'], response['end_offset'], upload_session_id, options)
+              break if response['start_offset'] == response['end_offset']
+              sleep 5
+            end
+            response = finish_video_request(options, upload_session_id)
+            if response['success']
+              { id: video_id }
+            else
+              response
+            end
+          end
+        end
+
+        private
+
+        def create_file_from_offset(offset)
+          file = Tempfile.new('image_slice')
+          file.binmode
+          file.write(video.read(offset))
+          file.rewind
+          file
+        end
+
+        def finish_video_request(options, upload_session_id)
+          options[:upload_phase] = 'finish'
+          options[:upload_session_id] = upload_session_id
+
+          conn.post full_url(path, options) do |request|
+            request.headers['Content-Type'] = 'application/json'
+            request.params = options
+          end.body
+        end
+
+        # Remove any query string parameters before getting the mime type
+        # should probably be done in mime types gem
+        def normalized_file_name
+          @source.split('?').first
+        end
+
+        def start_video_request(options)
+          options[:upload_phase] = 'start'
+          options[:file_size] = video_size
+
+          conn.post full_url(path, options) do |request|
+            request.headers['Content-Type'] = 'application/json'
+            request.params = options
+          end.body
+        end
+
+        def upload_chunk(start_offset, end_offset, upload_session_id, options)
+          read_length = end_offset.to_i - start_offset.to_i unless end_offset == video_size
+          temp_file = create_file_from_offset(read_length)
+          response = conn.post full_url(path, options) do |request|
+            request.headers['Content-Type'] = 'multipart/form-data'
+            request.params = options
+            request.body = {
+              upload_phase: 'transfer', upload_session_id: upload_session_id,
+              start_offset: start_offset, video_file_chunk: Faraday::UploadIO.new(temp_file.path, MIME::Types.type_for(normalized_file_name))
+            }
+          end.body
+          if response.key?('error') && response['error']['error_subcode'] == 1487742
+            raise FbError.new('There have been too many calls from this ad-account. Wait a bit and try again.', 500)
+          else
+            response
+          end
+        end
+
+        def video
+          @video ||= if %r{https?} =~ URI.parse(@source).scheme
+                       tmp_file = Tempfile.new([File.basename(normalized_file_name), File.extname(normalized_file_name)])
+                       tmp_file.binmode
+                       open(@source) { |file| tmp_file.write(file.read) }
+                       tmp_file.rewind
+                       tmp_file
+                     else
+                       File.open(normalized_file_name, 'r')
+                     end
+        end
+
+        def video_size
+          File.size(video.path)
+        end
+      end
+    end
+  end
+end

data/lib/adparlor/facebook/graph_api/ads_pixel.rb

@@ -0,0 +1,22 @@
+module Adparlor
+  module Facebook
+    module GraphApi
+      class AdsPixel < GraphObject
+        include Fields::AdsPixel
+        include Traits::Methods
+        field_attrs FIELDS
+        allow_method :create, :update
+        allow_local_method :update
+
+        def update_path
+          raise FbError.new('required parameter id missing', 500) unless id
+          "/#{id}"
+        end
+
+        def stats
+          @stats ||= CollectionProxy.new AdsPixelStat, "#{id}/stats", access_token
+        end
+      end
+    end
+  end
+end

data/lib/adparlor/facebook/graph_api/ads_pixel_stat.rb

@@ -0,0 +1,25 @@
+module Adparlor
+  module Facebook
+    module GraphApi
+      class AdsPixelStat < GraphObject
+        include Fields::AdsPixelStat
+        include Traits::Methods
+        field_attrs FIELDS
+
+        def get(path, options)
+          validate_options(options)
+          super(path, options)
+        end
+
+        private
+
+        def validate_options(options)
+          options.delete(:fields) # just not required for this request so ignore them if they are passed
+          raise FbError.new('invalid parameters passed', 500) if
+            (options.keys.map(&:to_s) - %w(access_token aggregation end_time event start_time id)).any?
+          raise FbError.new('required parameter aggregation missing', 500) if options[:aggregation].nil?
+        end
+      end
+    end
+  end
+end

data/lib/adparlor/facebook/graph_api/advertisable_application.rb

@@ -0,0 +1,11 @@
+module Adparlor
+  module Facebook
+    module GraphApi
+      class AdvertisableApplication < GraphObject
+        include Fields::AdvertisableApplication
+        include Traits::Methods
+        field_attrs FIELDS
+      end
+    end
+  end
+end

data/lib/adparlor/facebook/graph_api/app_event_type.rb

@@ -0,0 +1,11 @@
+module Adparlor
+  module Facebook
+    module GraphApi
+      class AppEventType < GraphObject
+        include Fields::AppEventType
+        include Traits::Methods
+        field_attrs FIELDS
+      end
+    end
+  end
+end

data/lib/adparlor/facebook/graph_api/application.rb

@@ -0,0 +1,15 @@
+module Adparlor
+  module Facebook
+    module GraphApi
+      class Application < GraphObject
+        include Fields::Application
+        include Traits::Methods
+        field_attrs FIELDS
+
+        def app_event_types
+          @app_event_types ||= CollectionProxy.new AppEventType, "/#{id}/app_event_types", access_token
+        end
+      end
+    end
+  end
+end

data/lib/adparlor/facebook/graph_api/batch_object.rb

@@ -0,0 +1,147 @@
+require 'mime/types'
+
+module Adparlor
+  module Facebook
+    module GraphApi
+      class BatchObject < GraphObject
+        attr_accessor :batch_calls
+
+        def initialize(graph_object)
+          @access_token = graph_object.access_token
+          @batch_calls = { batch: [] }
+          @batch_types = []
+          @files = {}
+        end
+
+        def delete(id, klass = nil, options = {})
+          top_level_access_token(options)
+          relative_url = relative_url(id, klass, options)
+          @batch_types << klass
+          @batch_calls[:batch] << { method: 'DELETE', relative_url: relative_url }
+          nil
+        end
+
+        def execute
+          content_type_header = @files.any? ? 'multipart/form-data' : 'application/json'
+          response = conn.post full_url('/', {}) do |request|
+            request.headers['Content-Type'] = content_type_header
+            request.params = { access_token: access_token }
+            request.body = @files.any? ? @files.merge(batch: @batch_calls[:batch].to_json) : @batch_calls.to_json
+          end
+          initialize_response(response)
+        end
+
+        def get(id, klass = nil, options = {})
+          top_level_access_token(options)
+          relative_url = relative_url(id, klass, options)
+          @batch_types << klass
+          @batch_calls[:batch] << { method: 'GET', relative_url: relative_url }
+          nil
+        end
+
+        def post(id, klass, attributes = {}, options = {})
+          top_level_access_token(options)
+          attached_file = attach_file(attributes)
+          name = options.delete(:name)
+          relative_url = relative_url(id, klass, options)
+          body = query_string attributes
+          @batch_types << klass
+          @batch_calls[:batch] << { method: 'POST', relative_url: relative_url, attached_files: attached_file, name: name, body: body }.delete_if { |_, v| v.nil? }
+          nil
+        end
+
+        private
+
+        def edge_endpoint(klass)
+          "#{klass.name.split('::').last.downcase}s"
+        end
+
+        def initialize_response(response)
+          data = []
+          response.body.each_with_index.map do |result, index|
+            if result.nil?
+              data[index] = nil
+              next
+            end
+            if result.include?('error')
+              data[index] = result.last
+              next
+            end
+            if result['code'] == 200
+              data[index] = []
+              body = JSON.parse(result['body'])
+              case
+              when body.key?('data')
+                if body['data'].is_a? Hash
+                  data[index] << @batch_types[index].new(body['data'])                  
+                else
+                  body['data'].each { |object| data[index] << @batch_types[index].new(object) }
+                  if body['paging'] && body['paging']['next']
+                    data[index] += @batch_types[index].get(body['paging']['next'].delete('\\'))
+                  end
+                end
+              when body.key?('images')
+                body['images'].keys.each do |key|
+                  data[index] << Adparlor::Facebook::GraphApi::AdImage.new(body['images'][key])
+                end
+                if body['paging'] && body['paging']['next']
+                  data[index] += Adparlor::Facebook::GraphApi::AdImage.get(body['paging']['next'].delete('\\'))
+                end
+              when body.key?('id')
+                data[index] = @batch_types[index].new(body)
+              else
+                data[index] = body
+              end
+            else
+              data[index] = result
+            end
+          end
+          data
+        end
+
+        def path(id)
+          return nil unless id
+          id.to_s.include?('act_') ? id : "act_#{id}/"
+        end
+
+        def relative_url(id, klass, options)
+          api_version = api_version(options)
+          if %r{\A(act_)?\d+\z}.match(id.to_s)
+            path = path(id)
+            edge = edge_endpoint(klass)
+          elsif id.nil?
+            path = "#{options[:id]}"
+            options.delete(:id)
+            edge = ''
+          else
+            path = id
+            edge = ''
+          end
+          query = query_string(options)
+          "#{File.join(api_version, path, edge)}#{query.empty? ? nil : "?#{query}"}"
+        end
+
+        def top_level_access_token(options)
+          @access_token = options[:access_token] unless @access_token || !options.key?(:access_token)
+        end
+
+        def query_string(options, depth = nil)
+          depth = 0 unless depth
+          options[:fields] = options[:fields].is_a?(Array) ? options[:fields].map(&:to_s).join(',') : options[:fields] if options.has_key?(:fields)
+          mapped_data = options.map do |k, v|
+            if depth == 0
+              v.respond_to?(:keys) ? "#{k}={#{query_string(v, depth + 1)}}" : "#{k}=#{v}"
+            else
+              "#{k}:#{v.to_json}"
+            end
+          end
+          if depth == 0
+            mapped_data.join('&')
+          else
+            mapped_data.join(',')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/adparlor/facebook/graph_api/broad_targeting_category.rb

@@ -0,0 +1,11 @@
+module Adparlor
+  module Facebook
+    module GraphApi
+      class BroadTargetingCategory < GraphObject
+        include Fields::BroadTargetingCategory
+        include Traits::Methods
+        field_attrs FIELDS
+      end
+    end
+  end
+end

data/lib/adparlor/facebook/graph_api/business.rb

@@ -0,0 +1,18 @@
+module Adparlor
+  module Facebook
+    module GraphApi
+      class Business < GraphObject
+        include Fields::Business
+        field_attrs FIELDS
+
+        def path
+          "/#{id}"
+        end
+
+        def product_catalogs
+          @product_catalogs ||= CollectionProxy.new ProductCatalog, "#{id}/product_catalogs", access_token
+        end
+      end
+    end
+  end
+end

data/lib/adparlor/facebook/graph_api/campaign.rb

@@ -0,0 +1,43 @@
+module Adparlor
+  module Facebook
+    module GraphApi
+      class Campaign < GraphObject
+        include Fields::Campaign
+        include Traits::Methods
+        
+        field_attrs FIELDS
+        allow_method :create
+        allow_local_method :create, :destroy, :update
+
+        class << self
+          def destroy(attributes = {}, options = {})
+            obj = new(attributes.merge(status: 'DELETED'))
+            obj.post(obj.update_path, options, 'DELETE')
+          end
+        end
+
+        def path
+          raise FbError.new('required parameter account_id missing', 500) unless account_id
+          "/act_#{account_id}/campaigns"
+        end
+
+        def update_path
+          raise FbError.new('required parameter id missing', 500) unless id
+          "/#{id}"
+        end
+
+        def delete
+          raise FbError.new('delete not available, use soft delete update', 500)
+        end
+
+        def ads
+          @ads ||= CollectionProxy.new(Ad, "/#{id}/ads", access_token)
+        end
+
+        def adsets
+          @adsets ||= CollectionProxy.new(AdSet, "/#{id}/adsets", access_token)
+        end
+      end
+    end
+  end
+end

data/lib/adparlor/facebook/graph_api/collection_proxy.rb

@@ -0,0 +1,36 @@
+module Adparlor
+  module Facebook
+    module GraphApi
+      class CollectionProxy
+        def initialize(klass, path, access_token, data = nil, options = {})
+          @klass = klass
+          @path = path
+          @access_token = access_token
+          @options = options
+          @all = Array(data).collect { |attributes| @klass.new(attributes) } if data
+        end
+
+        def all(options = {})
+          options.merge!(access_token: @access_token) unless options[:access_token]
+          options.merge!(@options) if @options.any?
+          @all ||= @klass.get(@path, options)
+        end
+
+        def create(attributes = {}, options = {})
+          options.merge!(access_token: @access_token) unless options[:access_token]
+          @klass.new(attributes).create(@path, options)
+        end
+
+        def destroy(attributes = {}, options = {})
+          options.merge!(access_token: @access_token) unless options[:access_token]
+          @klass.new(attributes).destroy(@path, options)
+        end
+
+        def update(attributes = {}, options = {})
+          options.merge!(access_token: @access_token) unless options[:access_token]
+          @klass.new(attributes).update(@path, options)
+        end
+      end
+    end
+  end
+end

data/lib/adparlor/facebook/graph_api/connection_object.rb

@@ -0,0 +1,11 @@
+module Adparlor
+  module Facebook
+    module GraphApi
+      class ConnectionObject < GraphObject
+        include Fields::ConnectionObject
+        include Traits::Methods
+        field_attrs FIELDS
+      end
+    end
+  end
+end

data/lib/adparlor/facebook/graph_api/custom_audience.rb

@@ -0,0 +1,31 @@
+module Adparlor
+  module Facebook
+    module GraphApi
+      class CustomAudience < GraphObject
+        include Fields::CustomAudience
+        include Traits::Methods
+        field_attrs FIELDS
+        allow_method :create, :destroy
+        allow_local_method :create, :destroy, :update
+
+        def path
+          raise FbError.new('required parameter account_id missing', 500) unless account_id
+          "/act_#{account_id}/customaudiences"
+        end
+
+        def update_path
+          raise FbError.new('required parameter id missing', 500) unless id
+          "/#{id}"
+        end
+
+        def adaccounts
+          @adaccounts ||= CollectionProxy.new(AdAccount, "/#{id}/adaccounts", access_token)
+        end
+
+        def users
+          @users ||= CollectionProxy.new CustomAudienceUser, "#{id}/users", access_token
+        end
+      end
+    end
+  end
+end

data/lib/adparlor/facebook/graph_api/custom_audience_tos.rb

@@ -0,0 +1,11 @@
+module Adparlor
+  module Facebook
+    module GraphApi
+      class CustomAudienceTos < GraphObject
+        include Fields::CustomAudienceTos
+        include Traits::Methods
+        field_attrs FIELDS
+      end
+    end
+  end
+end

data/lib/adparlor/facebook/graph_api/custom_audience_user.rb

@@ -0,0 +1,85 @@
+module Adparlor
+  module Facebook
+    module GraphApi
+      class CustomAudienceUser < GraphObject
+        include Fields::CustomAudienceUser
+        include Traits::Methods
+        field_attrs FIELDS
+        allow_method :destroy, :update
+
+        FIELD_KEYS = {
+          emails: 'EMAIL_SHA256',
+          phone_numbers: 'PHONE_SHA256',
+          facebook_uids: 'UID',
+          mobile_adversiter_ids: 'MOBILE_ADVERTISER_ID',
+          genders: ['GEN'],
+          first_names: ['FN'],
+          last_name: ['LN'],
+          cities: ['CT'],
+          states: ['ST'],
+          zip_codes: ['ZIP'],
+          mobile_device_ids: ['MADID']
+        }
+
+        def destroy(path, options = {})
+          if @custom_audience_id
+            destroy_path = "/#{custom_audience_id}/users"
+          else
+            raise FbError.new('required parameter account_id missing', 500) unless @account_id
+            account_id = remove_instance_variable(:@account_id)
+            destroy_path = "act_#{account_id}/usersofanyaudience"
+          end
+          ready_payload
+          super(destroy_path, options)
+        end
+
+        def path
+          raise FbError.new('required parameter custom_audience_id missing', 500) unless custom_audience_id
+          "/#{custom_audience_id}/users"
+        end
+
+        def update(path, options = {})
+          ready_payload
+          super(path, options)
+        end
+
+        private
+
+        def ready_payload
+          schema, data = [], []
+          instance_variables.each do |iv|
+            schema_key = FIELD_KEYS[iv.to_s.delete('@').to_sym]
+            schema << schema_key
+            data << instance_variable_get(iv).map { |obj| normalize_object(obj, schema_key) }
+            remove_instance_variable iv
+          end
+          schema = schema.first if schema.length == 1
+          data = data.first if data.length == 1
+          @payload = { schema: schema, data: data }
+        end
+
+        def normalize_object(obj, type)
+          audience_type = type.is_a?(Array) ? type.first : type
+          case audience_type
+            when 'EMAIL_SHA256'
+              Digest::SHA256.hexdigest(obj.downcase.strip)
+            when 'PHONE_SHA256'
+              Digest::SHA256.hexdigest(obj.gsub(/\D/, ''))
+            when 'GEN'
+              if obj.downcase.include?('fe')
+                [Digest::SHA256.hexdigest('f')]
+              else
+                [Digest::SHA256.hexdigest('m')]
+              end
+            when 'LN', 'FN', 'CT'
+              [Digest::SHA256.hexdigest(obj.gsub(/(\W+|[0-9 ]+)/, ''))]
+            when 'ST', 'ZIP', 'MADID'
+              [Digest::SHA256.hexdigest(obj.downcase)]
+            else
+              Digest::SHA256.hexdigest(obj)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/adparlor/facebook/graph_api/custom_conversion.rb

@@ -0,0 +1,22 @@
+module Adparlor
+  module Facebook
+    module GraphApi
+      class CustomConversion < GraphObject
+        include Fields::CustomConversion
+        include Traits::Methods
+        field_attrs FIELDS
+        allow_method :create, :update
+        allow_local_method :destroy, :update
+
+        def update_path
+          raise FbError.new('required parameter id missing', 500) unless id
+          "/#{id}"
+        end
+
+        def stats
+          @stats ||= CollectionProxy.new AdsPixelStat, "#{id}/stats", access_token
+        end
+      end
+    end
+  end
+end

data/lib/adparlor/facebook/graph_api/delivery_estimate.rb

@@ -0,0 +1,11 @@
+module Adparlor
+  module Facebook
+    module GraphApi
+      class DeliveryEstimate < GraphObject
+        include Fields::DeliveryEstimate
+        include Traits::Methods
+        field_attrs FIELDS
+      end
+    end
+  end
+end