kameleoon-client-ruby 2.1.0 → 2.2.0

data/lib/kameleoon/data.rb

@@ -1,175 +0,0 @@
-# frozen_string_literal: true
-
-require 'kameleoon/exceptions'
-
-module Kameleoon
-  NONCE_LENGTH = 16
-
-  module DataType
-    CUSTOM = 'CUSTOM'
-    BROWSER = 'BROWSER'
-    CONVERSION = 'CONVERSION'
-    DEVICE = 'DEVICE'
-    PAGE_VIEW = 'PAGE_VIEW'
-  end
-
-  module BrowserType
-    CHROME = 0
-    INTERNET_EXPLORER = 1
-    FIREFOX = 2
-    SAFARI = 3
-    OPERA = 4
-    OTHER = 5
-  end
-
-  module DeviceType
-    PHONE = 'PHONE'
-    TABLET = 'TABLET'
-    DESKTOP = 'DESKTOP'
-  end
-
-  class Data
-    attr_accessor :instance, :sent
-
-    def initialize(*args)
-      raise KameleoonError.new("Cannot initialise interface.")
-    end
-
-    def obtain_full_post_text_line
-      raise KameleoonError.new("ToDo: implement this method.")
-    end
-
-    def encode(url)
-      encoded_url = CGI.escape(url)
-      encoded_url.gsub! "%27", "'"
-      encoded_url.gsub! "%21", "!"
-      encoded_url.gsub! "+", "%20"
-      encoded_url.gsub! "%2A", "*"
-      encoded_url.gsub! "%28", "("
-      encoded_url.gsub! "%29", ")"
-      encoded_url
-    end
-  end
-
-  class CustomData < Data
-    attr_reader :id, :values
-
-    # @param [Integer] id Id of the custom data
-    # @param [String] value Value of the custom data
-    #
-    # @overload
-    # @param [Hash] hash Json value encoded in a hash.
-    def initialize(arg0, *args)
-      @instance = DataType::CUSTOM
-      @sent = false
-      if arg0.is_a?(Hash)
-        hash = arg0
-        id = hash['id']
-        raise Kameleoon::Exception::NotFound.new('id') if id.nil?
-        @id = id.to_s
-        value = hash['value']
-        values = hash['values']
-        raise Kameleoon::Exception::NotFound.new('values') if values.nil? && value.nil?
-        if values.nil?
-          @values = [value]
-        else
-          @values = values.dup
-          @values.append(value) unless value.nil?
-        end
-      else
-        @id = arg0.to_s
-        @values = args
-      end
-    end
-
-    def obtain_full_post_text_line
-      return '' if @values.empty?
-      
-      str_values = "[[\"#{@values.join('",1],["')}\",1]]"
-      nonce = Kameleoon::Utils.generate_random_string(NONCE_LENGTH)
-      "eventType=customData&index=#{@id}&valueToCount=#{encode(str_values)}&overwrite=true&nonce=#{nonce}"
-    end
-  end
-
-  class Browser < Data
-    attr_accessor :browser
-
-    # @param [BrowserType] browser_type Browser type, can be: CHROME, INTERNET_EXPLORER, FIREFOX, SAFARI, OPERA, OTHER
-    def initialize(browser_type)
-      @instance = DataType::BROWSER
-      @sent = false
-      @browser = browser_type
-    end
-
-    def obtain_full_post_text_line
-      nonce = Kameleoon::Utils.generate_random_string(NONCE_LENGTH)
-      "eventType=staticData&browserIndex=" + @browser.to_s + "&nonce=" + nonce
-    end
-  end
-
-  class PageView < Data
-    attr_accessor :url, :title, :referrer
-
-    # @param [String] url Url of the page
-    # @param [String] title Title of the page
-    # @param [Array] referrers Optional field - Referrer ids
-    def initialize(url, title, referrers = nil)
-      @instance = DataType::PAGE_VIEW
-      @sent = false
-      @url = url
-      @title = title
-      @referrers = referrers
-    end
-
-    def obtain_full_post_text_line
-      nonce = Kameleoon::Utils.generate_random_string(NONCE_LENGTH)
-      referrer_text = ''
-      unless @referrers.nil?
-        referrer_text = "&referrersIndices=" + @referrers.to_s
-      end
-      "eventType=page&href=" + encode(@url) + "&title=" + @title + referrer_text + "&nonce=" + nonce
-    end
-  end
-
-  class Conversion < Data
-    attr_accessor :goal_id, :revenue, :negative
-
-    # @param [Integer] goal_id Id of the goal associated to the conversion
-    # @param [Float] revenue Optional field - Revenue associated to the conversion.
-    # @param [Boolean] negative Optional field - If the revenue is negative. By default it's positive.
-    def initialize(goal_id, revenue = 0.0, negative = false)
-      @instance = DataType::CONVERSION
-      @sent = false
-      @goal_id = goal_id
-      @revenue = revenue
-      @negative = negative
-    end
-
-    def obtain_full_post_text_line
-      nonce = Kameleoon::Utils.generate_random_string(NONCE_LENGTH)
-      "eventType=conversion&goalId=" + @goal_id.to_s + "&revenue=" + @revenue.to_s + "&negative=" + @negative.to_s + "&nonce=" + nonce
-    end
-  end
-
-  # Device uses for sending deviceType parameter for tracking calls
-  class Device < Data
-    def initialize(device_type)
-      @instance = DataType::DEVICE
-      @sent = false
-      @device_type = device_type
-    end
-
-    def obtain_full_post_text_line
-      nonce = Kameleoon::Utils.generate_random_string(NONCE_LENGTH)
-      "eventType=staticData&deviceType=#{@device_type}&nonce=#{nonce}"
-    end
-  end
-
-  # UserAgent uses for changing User-Agent header for tracking calls
-  class UserAgent
-    attr_accessor :value
-    def initialize(value)
-      @value = value
-    end
-  end
-end

data/lib/kameleoon/request.rb

@@ -1,90 +0,0 @@
-require 'em-synchrony/em-http'
-require 'kameleoon/version'
-require 'net/http'
-
-module Kameleoon
-  # @api private
-  module Request
-    protected
-
-    API_URL = 'https://api.kameleoon.com'.freeze
-    CLIENT_CONFIG_URL = 'https://client-config.kameleoon.com'.freeze
-
-    module Method
-      GET = 'get'.freeze
-      POST = 'post'.freeze
-    end
-
-    def get(request_options, url = API_URL, connexion_options = {})
-      request(Method::GET, request_options, url, connexion_options)
-    end
-
-    def post(request_options, url = API_URL, connexion_options = {})
-      request(Method::POST, request_options, url, connexion_options)
-    end
-
-    def get_sync(url = API_URL, connexion_options = {})
-      request_sync(Method::GET, url, connexion_options, {})
-    end
-
-    def post_sync(request_options, url = API_URL, connexion_options = {})
-      request_sync(Method::POST, url, connexion_options, request_options)
-    end
-
-    private
-
-    def request(method, request_options, url, connexion_options)
-      connexion_options[:tls] = { verify_peer: false }
-      add_user_agent(request_options)
-      case method
-        when Method::POST then
-          return EventMachine::HttpRequest.new(url, connexion_options).apost request_options
-        when Method::GET then
-          return EventMachine::HttpRequest.new(url, connexion_options).get request_options
-        else
-          print 'Unknown request type'
-          return false
-      end
-    end
-
-    def request_sync(method, url, connexion_options, request_options)
-      request_options = {} if request_options.nil?
-      add_user_agent(request_options)
-      case method
-        when Method::GET then
-          uri = URI(url)
-          request = Net::HTTP.new(url)
-          response = Net::HTTP.get_response(uri)
-          response
-        when Method::POST then
-          uri = URI.parse(url)
-          http = Net::HTTP.new(uri.host, uri.port)
-          http.use_ssl = true
-          request = Net::HTTP::Post.new(request_options[:path], initheader = request_options[:head])
-          request.body = request_options[:body]
-          response = http.request(request)
-          response
-        else
-          print "Unknown request type"
-          return false
-      end
-    end
-
-    def successful?(request)
-      !request.nil? && request != false && /20\d/.match(request.response_header.status.to_s)
-    end
-
-    def successful_sync?(response)
-      !response.nil? && response != false && response.is_a?(Net::HTTPSuccess)
-    end
-
-    def add_user_agent(request_options)
-      sdk_version = "sdk/ruby/#{Kameleoon::VERSION}"
-      if request_options[:head].nil?
-        request_options[:head] = { 'Kameleoon-Client' => sdk_version }
-      else
-        request_options[:head].store('Kameleoon-Client', sdk_version)
-      end
-    end
-  end
-end