bing_ads_ruby_sdk 0.0.0 → 1.0.0

data/lib/bing_ads_ruby_sdk/configuration.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module BingAdsRubySdk
+  class Configuration
+    attr_accessor :pretty_print_xml, :filters, :log
+    attr_writer :logger
+
+    def initialize
+      @log = false
+      @pretty_print_xml = false
+      @filters = []
+    end
+
+    def logger
+      @logger ||= default_logger
+    end
+
+    private
+
+    def default_logger
+      Logger.new(File.join(BingAdsRubySdk::ROOT_PATH, "log", "bing-sdk.log")).tap do |l|
+        l.level = Logger::INFO
+      end
+    end
+  end
+end

data/lib/bing_ads_ruby_sdk/errors/error_handler.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module BingAdsRubySdk
+  module Errors
+    # Parses the response from the API to raise errors if they are returned
+    class ErrorHandler
+      def initialize(response)
+        @response = response
+      end
+
+      def call
+        # Some operations don't return a response, for example:
+        # https://msdn.microsoft.com/en-us/library/bing-ads-customer-management-deleteaccount.aspx
+        return unless response.is_a? Hash
+        raise fault_class.new(response) if contains_error?
+      end
+
+      private
+
+      attr_reader :response
+
+      def contains_error?
+        partial_error_keys.any? || contains_fault?
+      end
+
+      def contains_fault?
+        (ERROR_KEYS & response.keys).any?
+      end
+
+      def fault_class
+        ERRORS_MAPPING.fetch(hash_with_error.keys.first, BASE_FAULT)
+      end
+
+      def hash_with_error
+        response[:detail] || partial_errors || {}
+      end
+
+      def partial_errors
+        response.select {|key| partial_error_keys.include?(key)}
+      end
+
+      # Gets populated partial error keys from the response
+      # @return [Array] array of symbols for keys in the response
+      #   that are populated with errors
+      def partial_error_keys
+        @partial_error_keys ||= (PARTIAL_ERROR_KEYS & response.keys).reject do |key|
+          response[key].nil? || response[key].is_a?(String)
+        end
+      end
+
+      BASE_FAULT = BingAdsRubySdk::Errors::GeneralError
+      PARTIAL_ERROR_KEYS = %i[partial_errors nested_partial_errors].freeze
+      ERROR_KEYS = %i[faultcode error_code]
+      ERRORS_MAPPING = {
+        api_fault_detail: BingAdsRubySdk::Errors::ApiFaultDetail,
+        ad_api_fault_detail: BingAdsRubySdk::Errors::AdApiFaultDetail,
+        editorial_api_fault_detail: BingAdsRubySdk::Errors::EditorialApiFaultDetail,
+        api_batch_fault: BingAdsRubySdk::Errors::ApiBatchFault,
+        api_fault: BingAdsRubySdk::Errors::ApiFault,
+        nested_partial_errors: BingAdsRubySdk::Errors::NestedPartialError,
+        partial_errors: BingAdsRubySdk::Errors::PartialError
+      }
+    end
+  end
+end

data/lib/bing_ads_ruby_sdk/errors/errors.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+module BingAdsRubySdk
+  module Errors
+    # Base exception class for reporting API errors
+    class GeneralError < ::StandardError
+      attr_accessor :raw_response, :message
+
+      def initialize(response)
+        @raw_response = response
+
+        code = response[:error_code] || 'Bing Ads API error'
+
+        message = response[:message] ||
+                    response[:faultstring] ||
+                      'See exception details for more information.'
+
+        @message = format_message(code, message)
+      end
+
+      private
+
+      # Format the message separated by hyphen if
+      # there is a code and a message
+      def format_message(code, message)
+        [code, message].compact.join(' - ')
+      end
+    end
+
+    class ServerError < GeneralError
+      def initialize(server_error)
+        super "Server raised error #{server_error}"
+      end
+    end
+
+    # Base exception class for handling errors where the detail is supplied
+    class ApplicationFault < GeneralError
+      def initialize(response)
+        super
+
+        populate_error_lists
+      end
+
+      def message
+        error_list = all_errors
+        return @message if error_list.empty?
+
+        first_message = first_error_message(error_list)
+        if error_list.count > 1
+          "API raised #{ error_list.count } errors, including: #{first_message}"
+        else
+          first_message
+        end
+      end
+
+      private
+
+      def populate_error_lists
+        self.class.error_lists.each do |key|
+          instance_variable_set("@#{key}", array_wrap(fault_hash[key]))
+        end
+      end
+
+      def all_errors
+        self.class.error_lists.flat_map do |list_name|
+          list = send(list_name)
+
+          # Call sometimes returns an empty string instead of
+          # nil for empty lists
+          list.nil? || list.empty? ? nil : list
+        end.compact
+      end
+
+      # The fault hash from the API response detail element
+      # @return [Hash] containing the fault information if provided
+      # @return [Hash] empty hash if no fault information
+      def fault_hash
+        raw_response[:detail][fault_key] || {}
+      end
+
+      # The fault key that corresponds to the inherited class
+      # @return [Symbol] the fault key
+      def fault_key
+        class_name = self.class.name.split('::').last
+        BingAdsRubySdk::StringUtils.snakize(class_name).to_sym
+      end
+
+      def first_error_message(error_list)
+        error = error_list.first.values.first
+        format_message(error[:error_code], error[:message])
+      end
+
+      def array_wrap(value)
+        case value
+        when Array then value
+        when nil, "" then []
+        else
+          [value]
+        end
+      end
+
+      class << self
+        def error_lists=(value)
+          @error_lists = value
+        end
+
+        def error_lists
+          @error_lists ||= []
+        end
+
+        def define_error_lists(*error_list_array)
+          self.error_lists += error_list_array
+
+          error_list_array.each { |attr| attr_accessor attr }
+        end
+      end
+    end
+
+    # Base class for handling partial errors
+    class PartialErrorBase < ApplicationFault
+
+      private
+
+      # The parent hash for this type of error is the root of the response
+      def fault_hash
+        raw_response[fault_key] || {}
+      end
+
+      # Gets the first error message in the list. This is
+      # overridden because partial errors are structured differently
+      # to application faults
+      # @return [Hash] containing the details of the error
+      def first_error_message(error_list)
+        error = error_list.first
+        format_message(error[:error_code], error[:message])
+      end
+    end
+
+    class PartialError < PartialErrorBase
+      define_error_lists :batch_error
+
+      private
+      def fault_key
+        :partial_errors
+      end
+    end
+
+    class NestedPartialError < PartialErrorBase
+      define_error_lists :batch_error_collection
+
+      private
+      def fault_key
+        :nested_partial_errors
+      end
+    end
+
+    # For handling API errors of the same name.
+    # Documentation:
+    # https://msdn.microsoft.com/en-gb/library/bing-ads-overview-adapifaultdetail.aspx
+    class AdApiFaultDetail < ApplicationFault
+      define_error_lists :errors
+    end
+
+    # For handling API errors of the same name.
+    # Documentation:
+    # https://msdn.microsoft.com/en-gb/library/bing-ads-overview-apifaultdetail.aspx
+    class ApiFaultDetail < ApplicationFault
+      define_error_lists :batch_errors, :operation_errors
+    end
+
+    # For handling API errors of the same name.
+    # Documentation:
+    # https://msdn.microsoft.com/en-gb/library/bing-ads-overview-editorialapifaultdetail.aspx
+    class EditorialApiFaultDetail < ApplicationFault
+      define_error_lists :batch_errors, :editorial_errors, :operation_errors
+    end
+
+    # For handling API errors of the same name.
+    # Documentation:
+    # https://msdn.microsoft.com/en-gb/library/bing-ads-apibatchfault-customer-billing.aspx
+    class ApiBatchFault < ApplicationFault
+      define_error_lists :batch_errors, :operation_errors
+    end
+
+    # For handling API errors of the same name.
+    # Documentation:
+    # https://msdn.microsoft.com/en-gb/library/bing-ads-apifault-customer-billing.aspx
+    class ApiFault < ApplicationFault
+      define_error_lists :operation_errors
+    end
+  end
+end

data/lib/bing_ads_ruby_sdk/header.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module BingAdsRubySdk
+  # Contains the SOAP Request header informations
+  class Header
+    # @param developer_token
+    # @param client_id
+    # @param store instance of a store
+    def initialize(developer_token:, client_id:, store:)
+      @developer_token = developer_token
+      @client_id = client_id
+      @oauth_store = store
+      @customer = {}
+    end
+
+    # @return [Hash] Authorization and identification data that will be added to the SOAP header
+    def content
+      {
+        "AuthenticationToken" => auth_handler.fetch_or_refresh,
+        "DeveloperToken" =>      developer_token,
+        "CustomerId" =>          customer[:customer_id],
+        "CustomerAccountId" =>   customer[:account_id]
+      }
+    end
+
+    def set_customer(account_id:, customer_id:)
+      customer[:account_id] = account_id
+      customer[:customer_id] = customer_id
+      self
+    end
+
+    private
+
+    attr_reader :oauth_store, :developer_token, :client_id, :customer
+
+    def auth_handler
+      @auth_handler ||= ::BingAdsRubySdk::OAuth2::AuthorizationHandler.new(
+        developer_token: developer_token,
+        client_id: client_id,
+        store: oauth_store
+      )
+    end
+  end
+end

data/lib/bing_ads_ruby_sdk/http_client.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "excon"
+
+module BingAdsRubySdk
+  class HttpClient
+    @http_connections = {}
+    HTTP_OPEN_TIMEOUT = 10
+    HTTP_READ_TIMEOUT = 20
+    HTTP_RETRY_COUNT_ON_TIMEOUT = 2
+    HTTP_INTERVAL_RETRY_COUNT_ON_TIMEOUT = 1
+    HTTP_ERRORS = [ Net::HTTPServerError, Net::HTTPClientError ]
+
+    class << self
+      def post(request)
+        uri = URI(request.url)
+        conn = self.connection(request.url)
+        raw_response = conn.post(
+          path: uri.path,
+          body: request.content,
+          headers: request.headers,
+        )
+
+        if contains_error?(raw_response)
+          BingAdsRubySdk.log(:warn) { BingAdsRubySdk::LogMessage.new(raw_response.body).to_s }
+          raise BingAdsRubySdk::Errors::ServerError, raw_response.body
+        else
+          BingAdsRubySdk.log(:debug) { BingAdsRubySdk::LogMessage.new(raw_response.body).to_s }
+        end
+
+        raw_response.body
+      end
+
+      def close_http_connections
+        self.http_connections.values.each do |connection|
+          connection.reset
+        end
+      end
+
+      protected
+
+      attr_reader :http_connections
+
+      def contains_error?(response)
+        HTTP_ERRORS.any? { |http_error_class| response.class <= http_error_class }
+      end
+
+      def connection(host)
+        self.http_connections[host] ||= Excon.new(
+          host,
+          persistent: true,
+          tcp_nodelay: true,
+          retry_limit: HTTP_RETRY_COUNT_ON_TIMEOUT,
+          idempotent: true,
+          retry_interval: HTTP_INTERVAL_RETRY_COUNT_ON_TIMEOUT,
+          connect_timeout: HTTP_OPEN_TIMEOUT,
+          read_timeout: HTTP_READ_TIMEOUT,
+          ssl_version: :TLSv1_2,
+          ciphers: "TLSv1.2:!aNULL:!eNULL",
+        )
+      end
+    end
+  end
+end

data/lib/bing_ads_ruby_sdk/log_message.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module BingAdsRubySdk
+  class LogMessage
+
+    def initialize(message)
+      @message = message
+    end
+
+    def to_s
+      return message unless message_is_xml
+      return message unless filters.any? || pretty_print
+
+      document = Nokogiri::XML(message)
+      document = apply_filter(document) if filters.any?
+      document.to_xml(nokogiri_options)
+    end
+
+    FILTERED = "***FILTERED***"
+
+    private
+
+    attr_reader :message
+
+    def message_is_xml
+      message =~ /^</
+    end
+
+    def apply_filter(document)
+      return document unless document.errors.empty?
+
+      filters.each do |filter|
+        apply_filter! document, filter
+      end
+
+      document
+    end
+
+    def apply_filter!(document, filter)
+      document.xpath("//*[local-name()='#{filter}']").each do |node|
+        node.content = FILTERED
+      end
+    end
+
+    def nokogiri_options
+      pretty_print ? { indent: 2 } : { save_with: Nokogiri::XML::Node::SaveOptions::AS_XML }
+    end
+
+    def pretty_print
+      BingAdsRubySdk.config.pretty_print_xml
+    end
+
+    def filters
+      BingAdsRubySdk.config.filters
+    end
+  end
+end