bing_ads_ruby_sdk 0.0.0 → 1.0.0

data/lib/bing_ads_ruby_sdk/oauth2/authorization_handler.rb

@@ -0,0 +1,94 @@
+require 'signet/oauth_2/client'
+require 'bing_ads_ruby_sdk/oauth2/fs_store'
+
+module BingAdsRubySdk
+  module OAuth2
+    # Adds some useful methods to Signet::OAuth2::Client
+    class AuthorizationHandler
+
+      # @param developer_token
+      # @param client_id
+      # @param store [Store]
+      def initialize(developer_token:, client_id:, store:)
+        @client = build_client(developer_token, client_id)
+        @store  = store
+        refresh_from_store
+      end
+
+      # @return [String] unless client.client_id url is nil interpolated url.
+      # @return [nil] if client.client_id is nil.
+      def code_url
+        return nil if client.client_id.nil?
+        "https://login.live.com/oauth20_authorize.srf?client_id=#{client.client_id}&scope=bingads.manage&response_type=code&redirect_uri=https://login.live.com/oauth20_desktop.srf"
+      end
+
+      # Once you have completed the oauth process in your browser using the code_url
+      # copy the url your browser has been redirected to and use it as argument here
+      def fetch_from_url(url)
+        codes = extract_codes(url)
+
+        return false if codes.none?
+        fetch_from_code(codes.last)
+      rescue Signet::AuthorizationError, URI::InvalidURIError
+        false
+      end
+
+      # Get or fetch an access token.
+      # @return [String] The access token.
+      def fetch_or_refresh
+        if client.expired?
+          client.refresh!
+          store.write(token_data)
+        end
+        client.access_token
+      end
+
+      private
+
+      attr_reader :client, :store
+
+      # Refresh existing authorization token
+      # @return [Signet::OAuth2::Client] if everything went well.
+      # @return [nil] if the token can't be read from the store.
+      def refresh_from_store
+        ext_token = store.read
+        client.update_token!(ext_token) if ext_token
+      end
+
+      # Request the Api to exchange the code for the access token.
+      # Save the access token through the store.
+      # @param [String] code authorization code from bing's ads.
+      # @return [#store.write] store's write output.
+      def fetch_from_code(code)
+        client.code = code
+        client.fetch_access_token!
+        store.write(token_data)
+      end
+
+      def extract_codes(url)
+        url = URI.parse(url)
+        query_params = URI.decode_www_form(url.query)
+        query_params.find { |arg| arg.first.casecmp("CODE").zero? }
+      end
+
+      def build_client(developer_token, client_id)
+        Signet::OAuth2::Client.new({
+          authorization_uri:    'https://login.live.com/oauth20_authorize.srf',
+          token_credential_uri: 'https://login.live.com/oauth20_token.srf',
+          redirect_uri:         'https://login.live.com/oauth20_desktop.srf',
+          developer_token: developer_token,
+          client_id: client_id
+        })
+      end
+
+      def token_data
+        {
+          access_token: client.access_token,
+          refresh_token: client.refresh_token,
+          issued_at: client.issued_at,
+          expires_in: client.expires_in
+        }
+      end
+    end
+  end
+end

data/lib/bing_ads_ruby_sdk/oauth2/fs_store.rb

@@ -0,0 +1,34 @@
+require 'json'
+
+module BingAdsRubySdk
+  module OAuth2
+    # Oauth2 token default non-encrypted File System store
+    class FsStore
+      # @param filename [String] the uniq filename to identify filename storing data.
+      def initialize(filename)
+        @filename = filename
+      end
+
+      # Writes the token to file
+      # @return [File] if the file was written (doesn't mean the token is).
+      # @return [self] if the filename don't exist.
+      def write(value)
+        return nil unless filename
+        File.open(filename, 'w') { |f| JSON.dump(value, f) }
+        self
+      end
+
+      # Reads the token from file
+      # @return [Hash] if the token information that was stored.
+      # @return [nil] if the file doesn't exist.
+      def read
+        return nil unless File.file?("./#{filename}")
+        JSON.parse(IO.read(filename))
+      end
+
+      private
+
+      attr_reader :filename
+    end
+  end
+end

data/lib/bing_ads_ruby_sdk/postprocessors/cast_long_arrays.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module BingAdsRubySdk
+  module Postprocessors
+    class CastLongArrays
+
+      def initialize(params)
+        @params = params
+      end
+
+      def call
+        process(@params)
+      end
+
+      private
+
+      def process(obj)
+        return unless obj.is_a?(Hash)
+
+        obj.each do |k, v|
+          case v
+          when Hash
+            if v[:long].is_a?(Array)
+              obj[k] = v[:long].map(&:to_i)
+            else
+              process(v)
+            end
+          when Array
+            v.each {|elt| process(elt) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bing_ads_ruby_sdk/postprocessors/snakize.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module BingAdsRubySdk
+  module Postprocessors
+    class Snakize
+
+      def initialize(params)
+        @params = params
+      end
+
+      def call
+        process(@params)
+      end
+
+      private
+
+      # NOTE: there is a potential for high memory usage here as we're using recursive method calling
+      def process(obj)
+        return obj unless obj.is_a?(Hash)
+
+        obj.each_with_object({}) do |(k, v), h|
+          case v
+          when Hash then v = process(v)
+          when Array then v = v.map {|elt| process(elt) }
+          end
+          h[snakize(k)] = v
+        end
+      end
+
+      def snakize(string)
+        BingAdsRubySdk::StringUtils.snakize(string)
+      end
+    end
+  end
+end

data/lib/bing_ads_ruby_sdk/preprocessors/camelize.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module BingAdsRubySdk
+  module Preprocessors
+    class Camelize
+
+      def initialize(params)
+        @params = params
+      end
+
+      def call
+        process(@params)
+      end
+
+      private
+
+      # NOTE: there is a potential for high memory usage here as we're using recursive method calling
+      def process(obj)
+        return obj unless obj.is_a?(Hash)
+
+        obj.each_with_object({}) do |(k, v), h|
+          case v
+          when Hash then v = process(v)
+          when Array then v = v.map {|elt| process(elt) }
+          end
+          h[transform_key(k.to_s)] = v
+        end
+      end
+
+      def transform_key(key)
+        if BLACKLIST.include?(key)
+          key
+        else
+          camelize(key)
+        end
+      end
+
+      def camelize(string)
+        BingAdsRubySdk::StringUtils.camelize(string)
+      end
+
+      BLACKLIST = %w(long string)
+    end
+  end
+end

data/lib/bing_ads_ruby_sdk/preprocessors/order.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module BingAdsRubySdk
+  module Preprocessors
+    class Order
+
+      def initialize(wsdl_wrapper, params)
+        @wrapper = wsdl_wrapper
+        @params = params
+      end
+
+      def call
+        process(params, wrapper.request_namespace_type)
+      end
+
+      private
+
+      attr_reader :wrapper, :params
+
+      # NOTE: there is a potential for high memory usage here as we're using recursive method calling
+      def process(obj, namespace_type)
+        return obj unless obj.is_a?(Hash)
+
+        allowed_attributes = wrapper.ordered_fields_hash(namespace_type)
+
+        order(obj, allowed_attributes).tap do |ordered_hash|
+          ordered_hash.each do |type_name, value|
+            ordered_hash[type_name] = ordered_value(allowed_attributes, type_name, value)
+          end
+        end
+      end
+
+      def ordered_value(allowed_attributes, type_name, value)
+        case value
+        when Hash
+          namespace_type = wrapper.namespace_and_type_from_name(allowed_attributes, type_name)
+          process(value, namespace_type)
+        when Array
+          value.map do |elt|
+            namespace_type = wrapper.namespace_and_type_from_name(allowed_attributes, type_name)
+            process(elt, namespace_type)
+          end
+        else value
+        end
+      end
+
+      def ordered_params(namespace_type)
+        wrapper.ordered_fields_hash(namespace_type)
+      end
+
+      def order(hash, allowed_attributes)
+        array = allowed_attributes.keys
+        # basically order by index in reference array
+        Hash[ hash.sort_by { |k, _| array.index(wrapper.base_type_name(allowed_attributes, k)) || k.ord } ]
+      end
+    end
+  end
+end

data/lib/bing_ads_ruby_sdk/services/ad_insight.rb

@@ -0,0 +1,10 @@
+module BingAdsRubySdk
+  module Services
+    class AdInsight < Base
+
+      def self.service
+        :ad_insight
+      end
+    end
+  end
+end

data/lib/bing_ads_ruby_sdk/services/base.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require 'bing_ads_ruby_sdk/preprocessors/camelize'
+require 'bing_ads_ruby_sdk/preprocessors/order'
+require 'bing_ads_ruby_sdk/postprocessors/snakize'
+require 'bing_ads_ruby_sdk/postprocessors/cast_long_arrays'
+
+
+module BingAdsRubySdk
+  module Services
+    class Base
+
+      def initialize(soap_client)
+        @soap_client = soap_client
+      end
+
+      def call(operation_name, message = {})
+        camelized_name = BingAdsRubySdk::StringUtils.camelize(operation_name.to_s)
+        response = soap_client.call(
+          camelized_name,
+          preprocess(message, camelized_name),
+        )
+        postprocess(response)
+      end
+
+      def self.service
+        raise 'implement me'
+      end
+
+      private
+
+      attr_reader :soap_client
+
+      def call_wrapper(action, message, *response_nesting)
+        response = call(action, message)
+        wrap_array(dig_response(response, response_nesting))
+      end
+
+      def preprocess(message, operation_name)
+        order(
+          soap_client.wsdl_wrapper(operation_name),
+          camelize(message)
+        )
+      end
+
+      def postprocess(message)
+        cast_long_arrays(
+          snakize(message)
+        )
+      end
+
+      def order(wrapper, hash)
+        ::BingAdsRubySdk::Preprocessors::Order.new(wrapper, hash).call
+      end
+
+      def camelize(hash)
+        ::BingAdsRubySdk::Preprocessors::Camelize.new(hash).call
+      end
+
+      def snakize(hash)
+        ::BingAdsRubySdk::Postprocessors::Snakize.new(hash).call
+      end
+
+      def cast_long_arrays(hash)
+        ::BingAdsRubySdk::Postprocessors::CastLongArrays.new(hash).call
+      end
+
+      def dig_response(response, keys)
+        response.dig(*keys)
+      rescue StandardError => e
+        nil
+      end
+
+      def wrap_array(arg)
+        case arg
+        when Array then arg
+        when nil, "" then []
+        else [arg]
+        end
+      end
+    end
+  end
+end

data/lib/bing_ads_ruby_sdk/services/bulk.rb

@@ -0,0 +1,26 @@
+module BingAdsRubySdk
+  module Services
+    class Bulk < Base
+
+      def download_campaigns_by_account_ids(message)
+        call(__method__, message)
+      end
+
+      def get_bulk_download_status(message)
+        call(__method__, message)
+      end
+
+      def get_bulk_upload_url(message)
+        call(__method__, message)
+      end
+
+      def get_bulk_upload_status(message)
+        call(__method__, message)
+      end
+
+      def self.service
+        :bulk
+      end
+    end
+  end
+end

data/lib/bing_ads_ruby_sdk/services/campaign_management.rb

@@ -0,0 +1,116 @@
+module BingAdsRubySdk
+  module Services
+    class CampaignManagement < Base
+
+
+      def add_ad_extensions(message)
+        call(__method__, message)
+      end
+
+      def add_conversion_goals(message)
+        call(__method__, message)
+      end
+
+      def add_shared_entity(message)
+        call(__method__, message)
+      end
+
+      def add_uet_tags(message)
+        call(__method__, message)
+      end
+
+      def set_ad_extensions_associations(message)
+        call(__method__, message)
+      end
+
+
+      def update_conversion_goals(message)
+        call(__method__, message)
+      end
+
+      def update_uet_tags(message)
+        call(__method__, message)
+      end
+
+
+      def get_ad_extensions_associations(message)
+        wrap_array(
+          call(__method__, message)
+            .dig(:ad_extension_association_collection, :ad_extension_association_collection)
+            .first
+            .dig(:ad_extension_associations, :ad_extension_association)
+        )
+      rescue
+        []
+      end
+
+      def get_ad_extension_ids_by_account_id(message)
+        call_wrapper(__method__, message, :ad_extension_ids)
+      end
+
+      def get_ad_extensions_by_ids(message)
+        call_wrapper(__method__, message, :ad_extensions, :ad_extension)
+      end
+
+      def get_ad_groups_by_ids(message)
+        call_wrapper(__method__, message, :ad_groups, :ad_group)
+      end
+
+      def get_ad_groups_by_campaign_id(message)
+        call_wrapper(__method__, message, :ad_groups, :ad_group)
+      end
+
+      def get_ads_by_ad_group_id(message)
+        call_wrapper(__method__, message, :ads, :ad)
+      end
+
+      def get_budgets_by_ids(message= {})
+        call_wrapper(__method__, message, :budgets, :budget)
+      end
+
+      def get_campaigns_by_account_id(message)
+        call_wrapper(__method__, message, :campaigns, :campaign)
+      end
+
+      def get_campaigns_by_ids(message)
+        call_wrapper(__method__, message, :campaigns, :campaign)
+      end
+
+      def get_campaign_criterions_by_ids(message)
+        call_wrapper(__method__, message, :campaign_criterions, :campaign_criterion)
+      end
+
+      def get_conversion_goals_by_ids(message)
+        call_wrapper(__method__, message, :conversion_goals, :conversion_goal)
+      end
+
+      def get_keywords_by_ad_group_id(message)
+        call_wrapper(__method__, message, :keywords, :keyword)
+      end
+
+      def get_keywords_by_editorial_status(message)
+        call_wrapper(__method__, message, :keywords, :keyword)
+      end
+
+      def get_keywords_by_ids(message)
+        call_wrapper(__method__, message, :keywords, :keyword)
+      end
+
+      def get_shared_entities_by_account_id(message)
+        call_wrapper(__method__, message, :shared_entities, :shared_entity)
+      end
+
+      def get_uet_tags_by_ids(message = {})
+        call_wrapper(__method__, message, :uet_tags, :uet_tag)
+      end
+
+      def get_shared_entity_associations_by_entity_ids(message)
+        call_wrapper(__method__, message, :associations, :shared_entity_association)
+      end
+
+      def self.service
+        :campaign_management
+      end
+    end
+  end
+end