kameleoon-client-ruby 3.1.1 → 3.3.0

data/lib/kameleoon/kameleoon_client.rb

@@ -2,6 +2,7 @@
 
 require 'kameleoon/client_readiness'
 require 'kameleoon/targeting/models'
+require 'kameleoon/targeting/targeting_manager'
 require 'kameleoon/exceptions'
 require 'kameleoon/data/custom_data'
 require 'kameleoon/data/user_agent'
@@ -19,6 +20,7 @@ require 'kameleoon/managers/warehouse/warehouse_manager'
 require 'kameleoon/real_time/real_time_configuration_service'
 require 'kameleoon/hybrid/manager'
 require 'kameleoon/storage/cache_factory'
+require 'kameleoon/managers/remote_data/remote_data_manager'
 require 'rufus/scheduler'
 require 'yaml'
 require 'json'
@@ -46,8 +48,8 @@ module Kameleoon
       @real_time_configuration_service = nil
       @update_configuration_handler = nil
       @fetch_configuration_update_job = nil
-      @data_file = Configuration::DataFile.new(config.environment)
-      @visitor_manager = Kameleoon::DataManager::VisitorManager.new(config.session_duration_second)
+      @data_file = Configuration::DataFile.new(config.environment, method(:log))
+      @visitor_manager = Kameleoon::DataManager::VisitorManager.new(config.session_duration_second, method(:log))
       @hybrid_manager = Kameleoon::Hybrid::ManagerImpl.new(HYBRID_EXPIRATION_TIME, method(:log))
       @network_manager = Network::NetworkManager.new(
         config.environment,
@@ -57,8 +59,12 @@ module Kameleoon
         method(:log)
       )
       @warehouse_manager = Managers::Warehouse::WarehouseManager.new(@network_manager, @visitor_manager, method(:log))
+      @remote_data_manager = Kameleoon::Managers::RemoteData::RemoteDataManager.new(@network_manager, @visitor_manager,
+                                                                                    method(:log))
       @cookie_manager = Network::Cookie::CookieManager.new(config.top_level_domain)
       @readiness = ClientReadiness.new
+      @targeting_manager = Kameleoon::Targeting::TargetingManager.new(@visitor_manager, @data_file)
+      @visitor_manager.custom_data_info = @data_file.custom_data_info
     end
 
     def wait_init
@@ -117,8 +123,7 @@ module Kameleoon
     #
     def add_data(visitor_code, *args)
       Utils::VisitorCode.validate(visitor_code)
-      visitor = @visitor_manager.get_or_create_visitor(visitor_code)
-      visitor.add_data(method(:log), *args)
+      @visitor_manager.add_data(visitor_code, *args)
     end
 
     ##
@@ -133,13 +138,15 @@ module Kameleoon
     # @param [String] visitor_code Visitor code
     # @param [Integer] goal_id Id of the goal
     # @param [Float] revenue Optional - Revenue of the conversion.
+    # @param [Bool] is_unique_identifier Parameter that specifies whether the visitorCode is a unique identifier.
+    # This field is optional.
     #
     # @raise [Kameleoon::Exception::VisitorCodeInvalid] If the visitor code is empty or longer than 255 chars
     #
-    def track_conversion(visitor_code, goal_id, revenue = 0.0)
+    def track_conversion(visitor_code, goal_id, revenue = 0.0, is_unique_identifier: false)
       Utils::VisitorCode.validate(visitor_code)
       add_data(visitor_code, Conversion.new(goal_id, revenue))
-      flush(visitor_code)
+      flush(visitor_code, is_unique_identifier: is_unique_identifier)
     end
 
     ##
@@ -150,15 +157,19 @@ module Kameleoon
     # With this method you can manually send it.
     #
     # @param [String] visitor_code Optional field - Visitor code, without visitor code it flush all of the data
+    # @param [Bool] is_unique_identifier Parameter that specifies whether the visitorCode is a unique identifier.
+    # This field is optional.
     #
     # @raise [Kameleoon::Exception::VisitorCodeInvalid] If the visitor code is not nil and is empty or longer than 255 chars
     #
-    def flush(visitor_code = nil)
+    def flush(visitor_code = nil, is_unique_identifier: false)
       Utils::VisitorCode.validate(visitor_code) unless visitor_code.nil?
       if visitor_code.nil?
-        @visitor_manager.enumerate { |visitor_code, visitor| _send_tracking_request(visitor_code, visitor, false) }
+        @visitor_manager.enumerate do |visitor_code, visitor|
+          _send_tracking_request(visitor_code, visitor, false, is_unique_identifier)
+        end
       else
-        _send_tracking_request(visitor_code, nil, true)
+        _send_tracking_request(visitor_code, nil, true, is_unique_identifier)
       end
     end
 
@@ -175,12 +186,14 @@ module Kameleoon
     #
     # @param [String] visitor_code Unique identifier of the user. This field is mandatory.
     # @param [String] feature_key Key of the feature flag you want to expose to a user. This field is mandatory.
+    # @param [Bool] is_unique_identifier Parameter that specifies whether the visitorCode is a unique identifier.
+    # This field is optional.
     #
     # @raise [Kameleoon::Exception::FeatureNotFound] Feature Flag isn't found in this configuration
     # @raise [Kameleoon::Exception::VisitorCodeInvalid] If the visitor code is empty or longer than 255 chars
     #
-    def feature_active?(visitor_code, feature_key)
-      _, variation_key = _get_feature_variation_key(visitor_code, feature_key)
+    def feature_active?(visitor_code, feature_key, is_unique_identifier: false)
+      _, variation_key = _get_feature_variation_key(visitor_code, feature_key, is_unique_identifier)
       variation_key != Kameleoon::Configuration::VariationType::VARIATION_OFF
     rescue Exception::FeatureEnvironmentDisabled
       false
@@ -197,14 +210,16 @@ module Kameleoon
     #
     # @param [String] visitor_code
     # @param [String] feature_key
+    # @param [Bool] is_unique_identifier Parameter that specifies whether the visitorCode is a unique identifier.
+    # This field is optional.
     #
     # @raise [Kameleoon::Exception::FeatureNotFound] Feature Flag isn't found in this configuration
     # @raise [Kameleoon::Exception::VisitorCodeInvalid] If the visitor code is empty or longer than 255 chars
     # @raise [Kameleoon::Exception::FeatureEnvironmentDisabled] If the requested feature flag is disabled for
     # the current environment
     #
-    def get_feature_variation_key(visitor_code, feature_key)
-      _, variation_key = _get_feature_variation_key(visitor_code, feature_key)
+    def get_feature_variation_key(visitor_code, feature_key, is_unique_identifier: false)
+      _, variation_key = _get_feature_variation_key(visitor_code, feature_key, is_unique_identifier)
       variation_key
     end
 
@@ -216,6 +231,8 @@ module Kameleoon
     # @param [String] visitor_code
     # @param [String] feature_key
     # @param [String] variable_name
+    # @param [Bool] is_unique_identifier Parameter that specifies whether the visitorCode is a unique identifier.
+    # This field is optional.
     #
     # @raise [Kameleoon::Exception::FeatureNotFound] Feature Flag isn't found in this configuration
     # @raise [Kameleoon::Exception::FeatureVariableNotFound]
@@ -223,8 +240,8 @@ module Kameleoon
     # @raise [Kameleoon::Exception::FeatureEnvironmentDisabled] If the requested feature flag is disabled for
     # the current environment
     #
-    def get_feature_variable(visitor_code, feature_key, variable_name)
-      feature_flag, variation_key = _get_feature_variation_key(visitor_code, feature_key)
+    def get_feature_variable(visitor_code, feature_key, variable_name, is_unique_identifier: false)
+      feature_flag, variation_key = _get_feature_variation_key(visitor_code, feature_key, is_unique_identifier)
       variation = feature_flag.get_variation_key(variation_key)
       variable = variation&.get_variable_by_key(variable_name)
       if variable.nil?
@@ -273,8 +290,7 @@ module Kameleoon
     #
     # @return [Hash] Hash object of the json object.
     def get_remote_data(key, timeout = @default_timeout)
-      response = @network_manager.get_remote_data(key, timeout)
-      JSON.parse(response) if response
+      @remote_data_manager.get_data(key, timeout)
     end
 
     ##
@@ -288,13 +304,12 @@ module Kameleoon
     # for a visitor. If not specified, the default value is `True`. This field is optional.
     # @param [Integer] timeout Timeout for request (in milliseconds). Equals default_timeout in a config file.
     # This field is optional.
+    # @param [Bool] is_unique_identifier Parameter that specifies whether the visitorCode is a unique identifier.
+    # This field is optional.
     #
     # @return [Array] An array of data assigned to the given visitor.
-    def get_remote_visitor_data(visitor_code, timeout = nil, add_data: true)
-      response = @network_manager.get_remote_visitor_data(visitor_code, timeout)
-      data_array = parse_custom_data_array(visitor_code, response)
-      add_data(visitor_code, *data_array) if add_data && !data_array.empty?
-      data_array
+    def get_remote_visitor_data(visitor_code, timeout = nil, add_data: true, filter: nil, is_unique_identifier: false)
+      @remote_data_manager.get_visitor_data(visitor_code, add_data, filter, is_unique_identifier, timeout)
     end
 
     ##
@@ -338,10 +353,15 @@ module Kameleoon
     # @raise [Kameleoon::Exception::VisitorCodeInvalid] If the visitor code is empty or longer than 255 chars
     #
     # @return [Array] array of active feature flag keys for a visitor
+    #
+    # DEPRECATED. Please use `get_active_features` instead.
     def get_active_feature_list_for_visitor(visitor_code)
+      warn '[DEPRECATION] `get_active_feature_list_for_visitor` is deprecated.  Please use `get_active_features` instead.'
       Utils::VisitorCode.validate(visitor_code)
       list_keys = []
       @data_file.feature_flags.each do |feature_key, feature_flag|
+        next unless feature_flag.environment_enabled
+
         variation, rule, = _calculate_variation_key_for_feature(visitor_code, feature_flag)
         variation_key = _get_variation_key(variation, rule, feature_flag)
         list_keys.push(feature_key) if variation_key != Kameleoon::Configuration::VariationType::VARIATION_OFF
@@ -349,6 +369,50 @@ module Kameleoon
       list_keys
     end
 
+    ##
+    # Returns a Hash that contains the assigned variations of the active features using the keys
+    #          of the corresponding active features.
+    #
+    # @param [String] visitor_code unique identifier of a visitor.
+    #
+    # @raise [Kameleoon::Exception::VisitorCodeInvalid] If the visitor code is empty or longer than 255 chars or is nil
+    #
+    # @return [Hash] Hash of active features for a visitor
+    def get_active_features(visitor_code)
+      Utils::VisitorCode.validate(visitor_code)
+      map_active_features = {}
+
+      @data_file.feature_flags.each_value do |feature_flag|
+        next unless feature_flag.environment_enabled
+
+        var_by_exp, rule = _calculate_variation_key_for_feature(visitor_code, feature_flag)
+        variation_key = _get_variation_key(var_by_exp, rule, feature_flag)
+
+        next if variation_key == Configuration::VariationType::VARIATION_OFF
+
+        variation = feature_flag.get_variation_key(variation_key)
+        variables = {}
+
+        variation&.variables&.each do |variable|
+          variables[variable.key] = Kameleoon::Types::Variable.new(
+            variable.key,
+            variable.type,
+            _parse_feature_variable(variable)
+          )
+        end
+
+        variables.freeze
+        map_active_features[feature_flag.feature_key] = Kameleoon::Types::Variation.new(
+          variation_key,
+          var_by_exp ? var_by_exp.variation_id : nil,
+          rule ? rule.experiment_id : nil,
+          variables
+        )
+      end
+
+      map_active_features.freeze
+    end
+
     ##
     # The `on_update_configuration()` method allows you to handle the event when configuration
     # has updated data. It takes one input parameter: callable **handler**. The handler
@@ -471,16 +535,21 @@ module Kameleoon
       return false unless response
 
       configuration = JSON.parse(response)
-      @data_file = Configuration::DataFile.new(@config.environment).init(configuration)
-      @cookie_manager.consent_required =
-        @data_file.settings.is_consent_required && !@data_file.has_any_targeted_delivery_rule
-      @network_manager.url_provider.apply_data_api_domain(@data_file.settings.data_api_domain)
-
+      @data_file = Configuration::DataFile.new(@config.environment, method(:log)).init(configuration)
+      apply_new_configuration(@data_file)
       call_update_handler_if_needed(!time_stamp.nil?)
       log "Feature flags are fetched: #{response.inspect}"
       true
     end
 
+    def apply_new_configuration(data_file)
+      @cookie_manager.consent_required =
+        data_file.settings.is_consent_required && !data_file.has_any_targeted_delivery_rule
+      @network_manager.url_provider.apply_data_api_domain(data_file.settings.data_api_domain)
+      @targeting_manager = Kameleoon::Targeting::TargetingManager.new(@visitor_manager, data_file)
+      @visitor_manager.custom_data_info = data_file.custom_data_info
+    end
+
     ##
     # Call the handler when configuraiton was updated with new time stamp.
     #
@@ -513,47 +582,12 @@ module Kameleoon
     # end
 
     def check_targeting(visitor_code, campaign_id, exp_ff_rule)
-      segment = exp_ff_rule.targeting_segment
-      return true if segment.nil?
-
-      visitor = @visitor_manager.get_visitor(visitor_code)
-      segment.check_tree(->(type) { get_condition_data(type, visitor, visitor_code, campaign_id) })
-    end
-
-    def get_condition_data(type, visitor, visitor_code, campaign_id)
-      condition_data = nil
-      case type
-      when Kameleoon::Targeting::ConditionType::CUSTOM_DATUM
-        condition_data = visitor.custom_data unless visitor.nil?
-      when Kameleoon::Targeting::ConditionType::PAGE_TITLE,
-           Kameleoon::Targeting::ConditionType::PAGE_URL
-        condition_data = visitor.page_view_visits unless visitor.nil?
-      when Kameleoon::Targeting::ConditionType::DEVICE_TYPE
-        condition_data = visitor.device unless visitor.nil?
-      when Kameleoon::Targeting::ConditionType::BROWSER
-        condition_data = visitor.browser unless visitor.nil?
-      when Kameleoon::Targeting::ConditionType::CONVERSIONS
-        condition_data = visitor.conversions unless visitor.nil?
-      when Kameleoon::Targeting::ConditionType::SDK_LANGUAGE
-        condition_data = Kameleoon::Targeting::SdkInfo.new(Kameleoon::SDK_NAME, Kameleoon::SDK_VERSION)
-      when Kameleoon::Targeting::ConditionType::VISITOR_CODE
-        condition_data = visitor_code
-      when Kameleoon::Targeting::ConditionType::TARGET_EXPERIMENT
-        condition_data = visitor.variations unless visitor.nil?
-      when Kameleoon::Targeting::ConditionType::EXCLUSIVE_EXPERIMENT
-        unless visitor.nil?
-          condition_data = OpenStruct.new
-          condition_data.experiment_id = campaign_id
-          condition_data.storage = visitor.variations
-        end
-      end
-      condition_data
+      @targeting_manager.check_targeting(visitor_code, campaign_id, exp_ff_rule)
     end
 
     ##
     # helper method for getting variation key for feature flag
-    def _get_feature_variation_key(visitor_code, feature_key)
-      Utils::VisitorCode.validate(visitor_code)
+    def _get_feature_variation_key(visitor_code, feature_key, is_unique_identifier = false)
       feature_flag = @data_file.get_feature_flag(feature_key)
       variation, rule = _calculate_variation_key_for_feature(visitor_code, feature_flag)
       variation_key = _get_variation_key(variation, rule, feature_flag)
@@ -567,7 +601,7 @@ module Kameleoon
           visitor.assign_variation(as_variation)
         end
       end
-      _send_tracking_request(visitor_code, visitor)
+      flush(visitor_code, is_unique_identifier: is_unique_identifier)
       [feature_flag, variation_key]
     end
 
@@ -577,16 +611,19 @@ module Kameleoon
       # no rules -> return default_variation_key
       feature_flag.rules.each do |rule|
         # check if visitor is targeted for rule, else next rule
-        next unless check_targeting(visitor_code, feature_flag.id, rule)
+        next unless check_targeting(visitor_code, rule.experiment_id, rule)
 
+        vis = @visitor_manager.get_visitor(visitor_code)
+        # use mappingIdentifier instead of visitorCode if it was set up
+        code_for_hash = vis&.mapping_identifier || visitor_code
         # uses for rule exposition
-        hash_rule = Utils::HashDouble.obtain_rule(visitor_code, rule.id, rule.respool_time)
+        hash_rule = Utils::HashDouble.obtain_rule(code_for_hash, rule.id, rule.respool_time)
         # check main expostion for rule with hashRule
         if hash_rule <= rule.exposition
-          return [rule.variation_by_exposition[0], rule] if rule.targeted_delivery_type?
+          return [rule.first_variation, rule] if rule.targeted_delivery_type?
 
           # uses for variation's expositions
-          hash_variation = Utils::HashDouble.obtain_rule(visitor_code, rule.experiment_id, rule.respool_time)
+          hash_variation = Utils::HashDouble.obtain_rule(code_for_hash, rule.experiment_id, rule.respool_time)
           # get variation key with new hashVariation
           variation = rule.get_variation(hash_variation)
           return [variation, rule] unless variation.nil?
@@ -607,11 +644,12 @@ module Kameleoon
 
     ##
     # helper method for sending tracking requests for new FF
-    def _send_tracking_request(visitor_code, visitor = nil, force_request = true)
+    def _send_tracking_request(visitor_code, visitor = nil, force_request = true, is_unique_identifier = false)
       if visitor.nil?
         visitor = @visitor_manager.get_visitor(visitor_code)
         return if visitor.nil? && @data_file.settings.is_consent_required
       end
+      use_mapping_value, visitor = create_anonymous_if_required(visitor_code, visitor, is_unique_identifier)
       consent = consent_provided?(visitor)
       user_agent = visitor&.user_agent
       unsent = visitor.nil? ? [] : select_unsent_data(visitor, consent)
@@ -621,7 +659,20 @@ module Kameleoon
         unsent.push(Network::ActivityEvent.new)
       end
       log "Start post tracking: #{unsent.inspect}"
-      @network_manager.send_tracking_data(visitor_code, unsent, user_agent)
+      @network_manager.send_tracking_data(visitor_code, unsent, user_agent, use_mapping_value)
+    end
+
+    def create_anonymous_if_required(visitor_code, visitor, is_unique_identifier)
+      use_mapping_value = is_unique_identifier && !visitor&.mapping_identifier.nil?
+      # need to find if anonymous visitor is behind unique (anonym doesn't exist if MappingIdentifier == null)
+      if is_unique_identifier && visitor&.mapping_identifier.nil?
+        # We haven't anonymous behind, in this case we should create "fake" anonymous with id == visitorCode
+        # and link it with with mapping value == visitorCode (like we do as we have real anonymous visitor)
+        visitor = @visitor_manager.add_data(visitor_code,
+                                            CustomData.new(@data_file.custom_data_info.mapping_identifier_index,
+                                                           visitor_code))
+      end
+      [use_mapping_value, visitor]
     end
 
     def select_unsent_data(visitor, consent)
@@ -654,29 +705,6 @@ module Kameleoon
       end
     end
 
-    ##
-    # helper method used by `get_remote_visitor_data`
-    def parse_custom_data_array(visitor_code, response)
-      return [] unless response
-
-      raw = JSON.parse(response)
-      latest_record = raw['currentVisit']
-      if latest_record.nil?
-        previous_visits = raw['previousVisits']
-        return [] unless previous_visits
-
-        latest_record = previous_visits.first
-      end
-      events = latest_record['customDataEvents']
-      return [] if events.nil?
-
-      events.map { |ev| ev['data'] }.compact
-            .map { |jcd| CustomData.new(jcd['index'] || -1, *(jcd['valuesCountMap'] || {}).keys) }
-    rescue StandardError => e
-      log("Parsing of visitor data of '#{visitor_code}' failed: #{e}")
-      []
-    end
-
     def consent_provided?(visitor)
       !@data_file.settings.is_consent_required || visitor&.legal_consent
     end

data/lib/kameleoon/managers/remote_data/remote_data_manager.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'kameleoon/managers/remote_data/remote_visitor_data'
+require 'kameleoon/types/remote_visitor_data_filter'
+
+module Kameleoon
+  module Managers
+    module RemoteData
+      class RemoteDataManager
+        attr_reader :network_manager, :visitor_manger, :log_func
+
+        def initialize(network_manager, visitor_manger, log_func = nil)
+          @network_manager = network_manager
+          @visitor_manger = visitor_manger
+          @log_func = log_func
+        end
+
+        def get_data(key, timeout)
+          response = @network_manager.get_remote_data(key, timeout)
+          JSON.parse(response) if response
+        rescue StandardError => e
+          log("Parsing of visitor data of '#{key}' failed: #{e}")
+          raise
+        end
+
+        def get_visitor_data(visitor_code, add_data, filter = nil, is_unique_identifier = false, timeout = nil)
+          Utils::VisitorCode.validate(visitor_code)
+          filter = Kameleoon::Types::RemoteVisitorDataFilter.new unless filter.is_a?(Kameleoon::Types::RemoteVisitorDataFilter)
+          response = @network_manager.get_remote_visitor_data(visitor_code, filter, is_unique_identifier, timeout)
+          (data_to_add, data_to_return) = parse_custom_data_array(visitor_code, response)
+          if add_data && !data_to_add.empty?
+            visitor = @visitor_manger.get_or_create_visitor(visitor_code)
+            visitor.add_data(@log_func, *data_to_add, overwrite: false)
+          end
+          data_to_return
+        end
+
+        ##
+        # helper method used by `get_remote_visitor_data`
+        def parse_custom_data_array(visitor_code, response)
+          remote_visitor_data = Kameleoon::Managers::RemoteData::RemoteVisitorData.new(JSON.parse(response))
+          remote_visitor_data.mark_data_as_sent(@visitor_manger.custom_data_info)
+          [remote_visitor_data.collect_data_to_add, remote_visitor_data.collect_data_to_return]
+        rescue StandardError => e
+          log("Parsing of visitor data of '#{visitor_code}' failed: #{e}")
+          raise
+        end
+
+        def log(text)
+          @log_func&.call(text)
+        end
+      end
+    end
+  end
+end

data/lib/kameleoon/managers/remote_data/remote_visitor_data.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+require 'kameleoon/data/manager/page_view_visit'
+require 'kameleoon/data/manager/assigned_variation'
+require 'kameleoon/data/visitor_visits'
+require 'kameleoon/data/browser'
+require 'kameleoon/data/device'
+require 'kameleoon/data/conversion'
+require 'kameleoon/data/custom_data'
+require 'kameleoon/data/geolocation'
+require 'kameleoon/data/kcs_heat'
+require 'kameleoon/data/page_view'
+
+module Kameleoon
+  module Managers
+    module RemoteData
+      class RemoteVisitorData
+        attr_reader :custom_data_dict, :page_view_visits, :conversions, :experiments, :device, :browser,
+                    :operating_system, :geolocation, :previous_visitor_visits, :kcs_heat
+
+        def initialize(hash)
+          current_visit = hash['currentVisit']
+          parse_visit(current_visit) unless current_visit.nil?
+          previous_visits = hash['previousVisits']
+          previous_visits = [] if previous_visits.nil?
+
+          if previous_visits.size.positive?
+            times_started = []
+            previous_visits.each do |visit|
+              times_started.push(visit['timeStarted'])
+              parse_visit(visit)
+            end
+            @previous_visitor_visits = VisitorVisits.new(times_started)
+          end
+          @kcs_heat = parse_kcs_heat(hash['kcs'])
+        end
+
+        def collect_data_to_add
+          data_to_add = []
+          data_to_add.concat(@custom_data_dict.values) unless @custom_data_dict.nil?
+          data_to_add.push(@previous_visitor_visits) unless @previous_visitor_visits.nil?
+          data_to_add.push(@kcs_heat) unless @kcs_heat.nil?
+          data_to_add.concat(@page_view_visits.values) unless @page_view_visits.nil?
+          data_to_add.concat(@experiments.values) unless @experiments.nil?
+          data_to_add.concat(conversions_single_objects)
+        end
+
+        def collect_data_to_return
+          data_to_return = []
+          data_to_return.concat(@custom_data_dict.values) unless @custom_data_dict.nil?
+          @page_view_visits&.each_value do |visit|
+            data_to_return.push(visit.page_view)
+          end
+          data_to_return.concat(conversions_single_objects)
+        end
+
+        def mark_data_as_sent(custom_data_info)
+          @custom_data_dict&.each_value do |data|
+            data.mark_as_sent unless custom_data_info.visitor_scope?(data.id)
+          end
+          @experiments&.each_value(&:mark_as_sent)
+          @page_view_visits&.each_value do |visit|
+            visit.page_view.mark_as_sent
+          end
+          conversions_single_objects.each(&:mark_as_sent)
+        end
+
+        private
+
+        def parse_visit(hash)
+          custom_data_events = hash['customDataEvents']
+          parse_custom_data(custom_data_events) if custom_data_events != nil && custom_data_events.size.positive?
+          page_events = hash['pageEvents']
+          parse_pages(page_events) if page_events != nil && page_events.size.positive?
+          experiment_events = hash['experimentEvents']
+          parse_experiments(experiment_events) if experiment_events != nil && experiment_events.size.positive?
+          conversion_events = hash['conversionEvents']
+          parse_conversions(conversion_events) if conversion_events != nil && conversion_events.size.positive?
+          geolocation_events = hash['geolocationEvents']
+          @geolocation = parse_geolocation(geolocation_events) if @geolocation.nil? && geolocation_events != nil && geolocation_events.size.positive?
+          static_data_events = hash['staticDataEvent']
+          parse_static_data(static_data_events) if static_data_events != nil
+        end
+
+        def parse_custom_data(custom_data_events)
+          @custom_data_dict = {} if @custom_data_dict.nil?
+          custom_data_events.reverse_each do |custom_data_event|
+            data = custom_data_event['data']
+            id = data['index']
+            id = -1 if id.nil?
+            @custom_data_dict[id] = CustomData.new(id, *data['valuesCountMap'].keys) unless @custom_data_dict.include?(id)
+          end
+        end
+
+        def parse_pages(page_events)
+          @page_view_visits = {} if @page_view_visits.nil?
+          page_events.reverse_each do |page_event|
+            href = page_event['data']['href']
+            page_view_visit = @page_view_visits[href]
+            if page_view_visit.nil?
+              page_view = PageView.new(href, page_event['data']['title'])
+              @page_view_visits[href] = DataManager::PageViewVisit.new(page_view, 1, page_event['time'])
+            else
+              page_view_visit.increase_page_visits
+            end
+          end
+        end
+
+        def parse_experiments(experiment_events)
+          @experiments = {} if @experiments.nil?
+          experiment_events.reverse_each do |experiment_event|
+            id = experiment_event['data']['id']
+            variation = @experiments[id]
+            if variation.nil?
+              variation = DataManager::AssignedVariation.new(
+                id, experiment_event['data']['variationId'],
+                Configuration::RuleType::UNKNOWN, assignment_time: experiment_event['time']
+              )
+              @experiments[id] = variation
+            end
+          end
+        end
+
+        def parse_conversions(conversion_events)
+          @conversions = [] if @conversions.nil?
+          conversion_events.each do |conversion_event|
+            data = conversion_event['data']
+            conversion = Conversion.new(data['goalId'], data['revenue'], data['negative'])
+            @conversions.push(conversion)
+          end
+        end
+
+        def parse_geolocation(geolocation_events)
+          data = geolocation_events[geolocation_events.size - 1]['data']
+          Geolocation.new(data['country'], data['region'], data['city'])
+        end
+
+        def parse_static_data(static_data_event)
+          return if @device != nil && @browser != nil && @operating_system != nil
+
+          data = static_data_event['data']
+          if @device.nil?
+            device_type = data['deviceType']
+            @device = Device.new(device_type) unless device_type.nil?
+          end
+          if @browser.nil?
+            browser_type = BrowserType.from_name(data['browser'])
+            @browser = Browser.new(browser_type, data['browserVersion']) unless browser_type.nil?
+          end
+          if @operating_system.nil?
+            operating_system_type = OperatingSystemType.from_name(data['os'])
+            @operating_system = OperatingSystem.new(operating_system_type) unless operating_system_type.nil?
+          end
+        end
+
+        def conversions_single_objects
+          objects = []
+          objects += @conversions unless @conversions.nil?
+          objects.push(@device) unless @device.nil?
+          objects.push(@browser) unless @browser.nil?
+          objects.push(@operating_system) unless @operating_system.nil?
+          objects.push(@geolocation) unless @geolocation.nil?
+          objects
+        end
+
+        def parse_kcs_heat(kcs)
+          return nil if kcs.nil?
+
+          value_map = {}
+          kcs.each do |str_key_moment_id, goal_scores|
+            next unless str_key_moment_id.is_a?(String) && goal_scores.is_a?(Hash)
+
+            goal_score_map = {}
+            goal_scores.each do |str_goal_id, score|
+              next unless str_goal_id.is_a?(String) && (score.is_a?(Float) || score.is_a?(Integer))
+
+              goal_id = str_goal_id.to_i
+              goal_score_map[goal_id] = score
+            end
+            key_moment_id = str_key_moment_id.to_i
+            value_map[key_moment_id] = goal_score_map
+          end
+          KcsHeat.new(value_map)
+        end
+      end
+    end
+  end
+end

data/lib/kameleoon/managers/warehouse/warehouse_manager.rb

@@ -19,7 +19,9 @@ module Kameleoon
           Utils::VisitorCode.validate(visitor_code)
           remote_data_key = warehouse_key.nil? || warehouse_key.empty? ? visitor_code : warehouse_key
           response = @network_manager.get_remote_data(remote_data_key, timeout)
-          remote_data = response.is_a?(String) ? JSON.parse(response) : nil
+          return nil unless response.is_a?(String)
+
+          remote_data = JSON.parse(response)
           warehouse_audiences = remote_data.is_a?(Hash) ? remote_data[WAREHOUSE_AUDIENCES_FIELD_NAME] : nil
           data_values = warehouse_audiences.is_a?(Hash) ? warehouse_audiences.keys : []
           warehouse_audiences_data = CustomData.new(custom_data_index, *data_values)