vwo-sdk 1.35.0 → 1.38.0

data/lib/vwo/core/variation_decider.rb

@@ -33,7 +33,7 @@ class VWO
       include VWO::CONSTANTS
       include VWO::Utils::UUID
 
-      FILE = FileNameEnum::VariationDecider
+      FILE = FileNameEnum::VARIATION_DECIDER
 
       # Initializes various services
       # @param[Hash] -   Settings file
@@ -66,43 +66,17 @@ class VWO
 
         return unless campaign
 
-        is_campaign_part_of_group = @settings_file && is_part_of_group(@settings_file, campaign["id"])
+        is_campaign_part_of_group = @settings_file && part_of_group?(@settings_file, campaign['id'])
 
         @has_stored_variation = false
-        decision = {
-          :campaign_id => campaign['id'],
-          :campaign_key => campaign_key,
-          :campaign_type => campaign['type'],
-        # campaign segmentation conditions
-          :custom_variables => custom_variables,
-        # event name
-          :event => Hooks::DECISION_TYPES['CAMPAIGN_DECISION'],
-        # goal tracked in case of track API
-          :goal_identifier => goal_identifier,
-        # campaign whitelisting flag
-          :is_forced_variation_enabled => campaign['isForcedVariationEnabled'] ? campaign['isForcedVariationEnabled'] : false,
-          :sdk_version => SDK_VERSION,
-        # API name which triggered the event
-          :source => api_name,
-        # Passed in API
-          :user_id => user_id,
-        # Campaign Whitelisting conditions
-          :variation_targeting_variables => variation_targeting_variables,
-          :is_user_whitelisted => false,
-          :from_user_storage_service => false,
-          :is_feature_enabled => true,
-        # VWO generated UUID based on passed UserId and Account ID
-          :vwo_user_id => generator_for(user_id, @settings_file['accountId'])
-        }
+        decision = initialize_decision_properties(user_id, campaign, api_name, custom_variables, variation_targeting_variables, goal_identifier)
 
-        if campaign.has_key?("name")
-          decision[:campaign_name] = campaign['name']
-        end
+        decision[:campaign_name] = campaign['name'] if campaign.key?('name')
 
         if is_campaign_part_of_group
-          group_id = @settings_file["campaignGroups"][campaign["id"].to_s]
+          group_id = @settings_file['campaignGroups'][campaign['id'].to_s]
           decision[:group_id] = group_id
-          group_name = @settings_file["groups"][group_id.to_s]["name"]
+          group_name = @settings_file['groups'][group_id.to_s]['name']
           decision[:group_name] = group_name
         end
 
@@ -110,21 +84,17 @@ class VWO
         variation = get_variation_if_whitelisting_passed(user_id, campaign, variation_targeting_variables, api_name, decision, true)
         return variation if variation && variation['name']
 
-        if campaign.has_key?("isAlwaysCheckSegment")
-          is_presegmentation = check_presegmentation(campaign, user_id, custom_variables, api_name)
-          return get_variationIfPreSegmentation_applied(is_presegmentation, campaign, user_id, goal_identifier, decision)
+        if campaign.key?('isAlwaysCheckSegment')
+          is_presegmentation = presegmentation?(campaign, user_id, custom_variables, api_name)
+          return get_variation_if_presegmentation_applied(is_presegmentation, campaign, user_id, goal_identifier, decision)
         else
           user_campaign_map = get_user_storage(user_id, campaign_key)
           variation = get_stored_variation(user_id, campaign_key, user_campaign_map) if valid_hash?(user_campaign_map)
 
+          variation = variation.dup if variation # deep copy
+
           if variation
-            variation = variation.dup  # deep copy
-          end
-  
-          if variation
-            if valid_string?(user_campaign_map['goal_identifier']) && api_name == ApiMethods::TRACK
-              variation['goal_identifier'] = user_campaign_map['goal_identifier']
-            end
+            variation['goal_identifier'] = user_campaign_map['goal_identifier'] if valid_string?(user_campaign_map['goal_identifier']) && api_name == ApiMethods::TRACK
             @has_stored_variation = true
             @logger.log(
               LogLevelEnum::INFO,
@@ -137,16 +107,8 @@ class VWO
               }
             )
             decision[:from_user_storage_service] = !!variation['name']
-            if variation
-              if campaign['type'] == CampaignTypes::VISUAL_AB || campaign['type'] == CampaignTypes::FEATURE_TEST
-                decision[:variation_name] = variation['name']
-                decision[:variation_id] = variation['id']
-                if campaign['type'] == CampaignTypes::FEATURE_TEST
-                  decision[:is_feature_enabled] = variation['isFeatureEnabled']
-                end
-              end
-              @hooks_manager.execute(decision)
-            end
+            decision = add_variation_to_decision_properties(decision, campaign, variation)
+            @hooks_manager.execute(decision)
             return variation
           else
             @logger.log(
@@ -158,48 +120,20 @@ class VWO
                 '{userId}' => user_id
               }
             )
-  
-            if ([ApiMethods::TRACK, ApiMethods::GET_VARIATION_NAME, ApiMethods::GET_FEATURE_VARIABLE_VALUE].include? api_name) && @user_storage_service
-              @logger.log(
-                LogLevelEnum::WARNING,
-                'CAMPAIGN_NOT_ACTIVATED',
-                {
-                  '{file}' => FILE,
-                  '{campaignKey}' => campaign_key,
-                  '{userId}' => user_id,
-                  '{api}' => api_name
-                }
-              )
-  
-              @logger.log(
-                LogLevelEnum::INFO,
-                'CAMPAIGN_NOT_ACTIVATED',
-                {
-                  '{file}' => FILE,
-                  '{campaignKey}' => campaign_key,
-                  '{userId}' => user_id,
-                  '{reason}' => api_name == ApiMethods::TRACK ? 'track it' : 'get the decision/value'
-                }
-              )
-              return
-            end
+
+            return if campaign_not_activated?(user_id, campaign_key, api_name)
           end
         end
 
-
-
         # Pre-segmentation
-        is_presegmentation = check_presegmentation(campaign, user_id, custom_variables, api_name)
+        is_presegmentation = presegmentation?(campaign, user_id, custom_variables, api_name)
         is_presegmentation_and_traffic_passed = is_presegmentation && @bucketer.user_part_of_campaign?(user_id, campaign)
-        unless is_presegmentation_and_traffic_passed
-          return nil
-        end
+        return nil unless is_presegmentation_and_traffic_passed
 
         if is_presegmentation_and_traffic_passed && is_campaign_part_of_group
           group_campaigns = get_group_campaigns(@settings_file, group_id)
           if group_campaigns
-            is_any_campaign_whitelisted_or_stored = check_whitelisting_or_storage_for_grouped_campaigns(user_id, campaign, group_campaigns, group_name, variation_targeting_variables, true)
-            if is_any_campaign_whitelisted_or_stored
+            if whitelisting_or_storage_for_grouped_campaigns?(user_id, campaign, group_campaigns, group_name, variation_targeting_variables, true)
               @logger.log(
                 LogLevelEnum::INFO,
                 'MEG_CALLED_CAMPAIGN_NOT_WINNER',
@@ -207,7 +141,7 @@ class VWO
                   '{file}' => FILE,
                   '{campaignKey}' => campaign_key,
                   '{userId}' => user_id,
-                  '{groupName}' => group_name,
+                  '{groupName}' => group_name
                 }
               )
               return nil
@@ -220,8 +154,8 @@ class VWO
               {
                 '{file}' => FILE,
                 '{userId}' => user_id,
-                '{eligibleCampaignKeys}' => get_eligible_campaigns_key(eligible_campaigns).join(","),
-                '{inEligibleText}' => non_eligible_campaigns_key ? ("campaigns:" + non_eligible_campaigns_key.join("'")) : "no campaigns",
+                '{eligibleCampaignKeys}' => get_eligible_campaigns_key(eligible_campaigns).join(','),
+                '{inEligibleText}' => non_eligible_campaigns_key ? "campaigns: + #{non_eligible_campaigns_key.join("'")}" : 'no campaigns',
                 '{groupName}' => group_name
               }
             )
@@ -245,47 +179,120 @@ class VWO
               {
                 '{file}' => FILE,
                 '{userId}' => user_id,
-                '{campaignKey}' => winner_campaign["key"],
-                '{groupName}' => group_name,
+                '{campaignKey}' => winner_campaign['key'],
+                '{groupName}' => group_name
               }
             )
 
-            if winner_campaign && winner_campaign["id"] == campaign["id"]
-              variation = get_variation_allotted(user_id, campaign, true)
-              if variation && variation['name']
-                save_user_storage(user_id, campaign_key, campaign['type'], variation['name'], goal_identifier, true) if variation['name']
-              else
-                return nil
-              end
-            else
-              @logger.log(
-                LogLevelEnum::INFO,
-                'MEG_CALLED_CAMPAIGN_NOT_WINNER',
-                {
-                  '{file}' => FILE,
-                  '{campaignKey}' => campaign_key,
-                  '{userId}' => user_id,
-                  '{groupName}' => group_name,
-                }
-              )
-              return nil
-            end
+            return if meg_called_campaign_not_winner?(user_id, group_name, campaign, winner_campaign)
+
+            variation = get_variation_allotted(user_id, campaign, true)
+            return nil unless variation && variation['name']
+
+            save_user_storage(user_id, campaign_key, campaign['type'], variation['name'], goal_identifier, true) if variation['name']
           end
         end
 
-        if variation
-          if campaign['type'] == CampaignTypes::VISUAL_AB || campaign['type'] == CampaignTypes::FEATURE_TEST
-            decision[:variation_name] = variation['name']
-            decision[:variation_id] = variation['id']
-            if campaign['type'] == CampaignTypes::FEATURE_TEST
-              decision[:is_feature_enabled] = variation['isFeatureEnabled']
-            end
-          end
-          @hooks_manager.execute(decision)
-          return variation
+        variation ||= get_variation_if_presegmentation_applied(is_presegmentation, campaign, user_id, goal_identifier, decision)
+        return unless variation
+
+        variation
+      end
+
+      def campaign_not_activated?(user_id, campaign_key, api_name)
+        if ([ApiMethods::TRACK, ApiMethods::GET_VARIATION_NAME, ApiMethods::GET_FEATURE_VARIABLE_VALUE].include? api_name) && @user_storage_service
+          @logger.log(
+            LogLevelEnum::WARNING,
+            'CAMPAIGN_NOT_ACTIVATED',
+            {
+              '{file}' => FILE,
+              '{campaignKey}' => campaign_key,
+              '{userId}' => user_id,
+              '{api}' => api_name
+            }
+          )
+
+          @logger.log(
+            LogLevelEnum::INFO,
+            'CAMPAIGN_NOT_ACTIVATED',
+            {
+              '{file}' => FILE,
+              '{campaignKey}' => campaign_key,
+              '{userId}' => user_id,
+              '{reason}' => api_name == ApiMethods::TRACK ? 'track it' : 'get the decision/value'
+            }
+          )
+          return true
+        end
+        false
+      end
+
+      def meg_called_campaign_not_winner?(user_id, group_name, campaign, winner_campaign)
+        unless winner_campaign && winner_campaign['id'] == campaign['id']
+          @logger.log(
+            LogLevelEnum::INFO,
+            'MEG_CALLED_CAMPAIGN_NOT_WINNER',
+            {
+              '{file}' => FILE,
+              '{campaignKey}' => campaign['key'],
+              '{userId}' => user_id,
+              '{groupName}' => group_name
+            }
+          )
+          return true
         end
+        false
+      end
 
-        return get_variationIfPreSegmentation_applied(is_presegmentation, campaign, user_id, goal_identifier, decision)
+      # Intitialize decision properties for hook manager
+      #
+      # @param[String]          :user_id                          The unique ID assigned to User
+      # @param[Hash]            :campaign                         Campaign hash itself
+      # @param[String]          :api_name                         Name of the current api call
+      # @param[String]          :goal_identifier                  The unique campaign's goal identifier
+      # @param[Hash]            :custom_variables                 Key/value pair for segmentation
+      # @param[Hash]            :variation_targeting_variables    Key/value pair for whitelisting
+      # @return[Hash]                                             Decision properties for the callback by hook manager
+      def initialize_decision_properties(user_id, campaign, api_name, custom_variables = {}, variation_targeting_variables = {}, goal_identifier = '')
+        {
+          campaign_id: campaign['id'],
+          campaign_key: campaign['key'],
+          campaign_type: campaign['type'],
+          # campaign segmentation conditions
+          custom_variables: custom_variables,
+          # event name
+          event: Hooks::DECISION_TYPES['CAMPAIGN_DECISION'],
+          # goal tracked in case of track API
+          goal_identifier: goal_identifier,
+          # campaign whitelisting flag
+          is_forced_variation_enabled: campaign['isForcedVariationEnabled'] || false,
+          sdk_version: SDK_VERSION,
+          # API name which triggered the event
+          source: api_name,
+          # Passed in API
+          user_id: user_id,
+          # Campaign Whitelisting conditions
+          variation_targeting_variables: variation_targeting_variables,
+          is_user_whitelisted: false,
+          from_user_storage_service: false,
+          # VWO generated UUID based on passed UserId and Account ID
+          vwo_user_id: generator_for(user_id, @settings_file['accountId'])
+        }
+      end
+
+      # Add variation details to decision properties for hook manager
+      #
+      # @param[Hash]            :campaign                  Campaign details
+      # @param[Hash]            :variation                 Variation assigned to user
+      # @param[Hash]            :decision                  Decision properties
+      # @return[Hash]           :decision                  Decision properties
+      def add_variation_to_decision_properties(decision, campaign, variation)
+        if campaign['type'] == CampaignTypes::VISUAL_AB || campaign['type'] == CampaignTypes::FEATURE_TEST
+          decision[:variation_name] = variation['name']
+          decision[:variation_id] = variation['id']
+        end
+        decision[:is_feature_enabled] = variation['isFeatureEnabled'] if campaign['type'] == CampaignTypes::FEATURE_TEST
+        decision
       end
 
       # Get variation by murmur logic if pre segmentation pass
@@ -297,10 +304,9 @@ class VWO
       # @param[Hash]    :decision               data containing campaign info passed to hooks manager
       #
       # @return[Hash]
-      def get_variationIfPreSegmentation_applied(is_presegmentation, campaign, user_id, goal_identifier, decision)
-        unless is_presegmentation
-          return nil
-        end
+      def get_variation_if_presegmentation_applied(is_presegmentation, campaign, user_id, goal_identifier, decision)
+        return nil unless is_presegmentation
+
         campaign_key = campaign['key']
         variation = get_variation_allotted(user_id, campaign)
         if variation && variation['name']
@@ -318,13 +324,7 @@ class VWO
         end
 
         if variation
-          if campaign['type'] == CampaignTypes::VISUAL_AB || campaign['type'] == CampaignTypes::FEATURE_TEST
-            decision[:variation_name] = variation['name']
-            decision[:variation_id] = variation['id']
-            if campaign['type'] == CampaignTypes::FEATURE_TEST
-              decision[:is_feature_enabled] = variation['isFeatureEnabled']
-            end
-          end
+          decision = add_variation_to_decision_properties(decision, campaign, variation)
           @hooks_manager.execute(decision)
         end
         variation
@@ -352,8 +352,8 @@ class VWO
         end
 
         if @bucketer.user_part_of_campaign?(user_id, campaign, true)
-          variation = get_variation_of_campaign_for_user(user_id, campaign, disable_logs)
-          variation
+          get_variation_of_campaign_for_user(user_id, campaign, disable_logs)
+
         else
           # not part of campaign
           @logger.log(
@@ -385,7 +385,7 @@ class VWO
             'USER_VARIATION_ALLOCATION_STATUS',
             {
               '{file}' => FILE,
-              '{status}' => variation ? 'got variation:' + variation['name'] : 'did not get any variation',
+              '{status}' => variation ? "got variation: + #{variation['name']}" : 'did not get any variation',
               '{userId}' => user_id,
               '{campaignKey}' => campaign['key']
             },
@@ -418,12 +418,12 @@ class VWO
       # @param[Boolean]             :disable_logs       optional: disable logs if True
       # @return[Boolean]                                true if found otherwise false
 
-      def save_user_storage(user_id, campaign_key, campaign_type, variation_name, goal_identifier, disable_logs = false)
+      def save_user_storage(user_id, campaign_key, _campaign_type, variation_name, goal_identifier, disable_logs = false)
         unless @user_storage_service
           @logger.log(
             LogLevelEnum::DEBUG,
             'USER_STORAGE_SERVICE_NOT_CONFIGURED',
-            {'{file}' => FILE},
+            { '{file}' => FILE },
             disable_logs
           )
           return false
@@ -432,9 +432,7 @@ class VWO
         new_campaign_user_mapping['campaign_key'] = campaign_key
         new_campaign_user_mapping['user_id'] = user_id
         new_campaign_user_mapping['variation_name'] = variation_name
-        if !goal_identifier.empty?
-          new_campaign_user_mapping['goal_identifier'] = goal_identifier
-        end
+        new_campaign_user_mapping['goal_identifier'] = goal_identifier unless goal_identifier.empty?
 
         @user_storage_service.set(new_campaign_user_mapping)
 
@@ -463,6 +461,12 @@ class VWO
         false
       end
 
+      def update_goal_identifier(user_id, campaign, variation, goal_identifier)
+        updated_goal_identifier = variation['goal_identifier']
+        updated_goal_identifier += VWO_DELIMITER + goal_identifier
+        save_user_storage(user_id, campaign['key'], campaign['name'], variation['name'], updated_goal_identifier) if variation['name']
+      end
+
       private
 
       # Evaluate all the variations in the campaign to find
@@ -476,20 +480,18 @@ class VWO
       #
       # @return[Hash]
 
-      def evaluate_whitelisting(user_id, campaign, api_name, campaign_key, variation_targeting_variables = {}, disable_logs = false)
-        if campaign.key?('isUserListEnabled') && campaign["isUserListEnabled"]
+      def evaluate_whitelisting(user_id, campaign, _api_name, campaign_key, variation_targeting_variables = {}, disable_logs = false)
+        if campaign.key?('isUserListEnabled') && campaign['isUserListEnabled']
           vwo_user_id = generator_for(user_id, @settings_file['accountId'], true)
           if variation_targeting_variables.nil?
             variation_targeting_variables = { _vwo_user_id: vwo_user_id }
           else
             variation_targeting_variables[:_vwo_user_id] = vwo_user_id
           end
+        elsif variation_targeting_variables.nil?
+          variation_targeting_variables = { _vwo_user_id: user_id }
         else
-          if variation_targeting_variables.nil?
-            variation_targeting_variables = { _vwo_user_id: user_id }
-          else
-            variation_targeting_variables[:_vwo_user_id] = user_id
-          end
+          variation_targeting_variables[:_vwo_user_id] = user_id
         end
         targeted_variations = []
 
@@ -513,7 +515,11 @@ class VWO
                 '{customVariables}' => variation_targeting_variables,
                 '{status}' => status,
                 '{segmentationType}' => SegmentationTypeEnum::WHITELISTING,
-                '{variation}' => status == StatusEnum::PASSED ? (campaign['type'] == CampaignTypes::FEATURE_ROLLOUT ? 'and hence becomes part of the rollout' : variation['name'] + ' and hence becomes part of the rollout') : '',
+                '{variation}' => if status == StatusEnum::PASSED
+                                   campaign['type'] == CampaignTypes::FEATURE_ROLLOUT ? 'and hence becomes part of the rollout' : "#{variation['name']} and hence becomes part of the rollout"
+                                 else
+                                   ''
+                                 end
               },
               disable_logs
             )
@@ -525,7 +531,7 @@ class VWO
                 '{file}' => FILE,
                 '{campaignKey}' => campaign_key,
                 '{userId}' => user_id,
-                '{variation}' => campaign['type'] == CampaignTypes::FEATURE_ROLLOUT ? '' : 'for variation:' + variation['name']
+                '{variation}' => campaign['type'] == CampaignTypes::FEATURE_ROLLOUT ? '' : "for variation:#{variation['name']}"
               },
               disable_logs
             )
@@ -582,7 +588,7 @@ class VWO
       end
 
       def scale_campaigns_weight(campaigns)
-        normalize_weight = 100/campaigns.length
+        normalize_weight = 100 / campaigns.length
         campaigns.each do |campaign|
           campaign['weight'] = normalize_weight
         end
@@ -600,7 +606,7 @@ class VWO
           @logger.log(
             LogLevelEnum::DEBUG,
             'USER_STORAGE_SERVICE_NOT_CONFIGURED',
-            {'{file}' => FILE},
+            { '{file}' => FILE },
             disable_logs
           )
           return false
@@ -643,7 +649,7 @@ class VWO
       #
       # @return[Object, nil]      if found then variation settings object otherwise None
 
-      def get_stored_variation(user_id, campaign_key, user_campaign_map, disable_logs = false)
+      def get_stored_variation(_user_id, campaign_key, user_campaign_map, _disable_logs = false)
         return unless user_campaign_map['campaign_key'] == campaign_key
 
         variation_name = user_campaign_map['variation_name']
@@ -664,15 +670,13 @@ class VWO
       # @param[Boolean] :disable_logs                       optional: disable logs if True
       #
       # @return[Boolean]
-      def check_presegmentation(campaign, user_id, custom_variables, api_name, disable_logs = false)
+      def presegmentation?(campaign, user_id, custom_variables, _api_name, disable_logs = false)
         campaign_key = campaign['key']
         segments = get_segments(campaign)
         is_valid_segments = valid_value?(segments)
 
         if is_valid_segments
-          unless custom_variables
-            custom_variables = {}
-          end
+          custom_variables ||= {}
           response = @segment_evaluator.evaluate(campaign_key, user_id, segments, custom_variables, disable_logs)
           @logger.log(
             LogLevelEnum::INFO,
@@ -732,11 +736,11 @@ class VWO
         eligible_campaigns = []
 
         group_campaigns.each do |campaign|
-          if called_campaign["id"] == campaign["id"] || check_presegmentation(campaign, user_id, custom_variables, '', true) && @bucketer.user_part_of_campaign?(user_id, campaign, true)
+          if called_campaign['id'] == campaign['id'] || presegmentation?(campaign, user_id, custom_variables, '', true) && @bucketer.user_part_of_campaign?(user_id, campaign, true)
             eligible_campaigns.push(campaign)
           end
         end
-        return eligible_campaigns
+        eligible_campaigns
       end
 
       # Finds and returns the winner campaign from eligible_campaigns list.
@@ -746,14 +750,12 @@ class VWO
       #
       # @return[Hash]
       def get_winner_campaign(user_id, eligible_campaigns, group_id)
-        if eligible_campaigns.length == 1
-          return eligible_campaigns[0]
-        end
+        return eligible_campaigns[0] if eligible_campaigns.length == 1
 
         eligible_campaigns = scale_campaigns_weight(eligible_campaigns)
         eligible_campaigns = set_campaign_allocation(eligible_campaigns)
         bucket_value = @bucketer.get_bucket_value_for_user(user_id, {}, group_id, true)
-        return @bucketer.get_campaign_using_range(bucket_value, eligible_campaigns)
+        @bucketer.get_campaign_using_range(bucket_value, eligible_campaigns)
       end
 
       # Get campaign keys of all eligible Campaigns.
@@ -764,7 +766,7 @@ class VWO
       def get_eligible_campaigns_key(eligible_campaigns)
         eligible_campaigns_key = []
         eligible_campaigns.each do |campaign|
-          eligible_campaigns_key.push(campaign["key"])
+          eligible_campaigns_key.push(campaign['key'])
         end
         eligible_campaigns_key
       end
@@ -778,9 +780,7 @@ class VWO
       def get_non_eligible_campaigns_key(eligible_campaigns, group_campaigns)
         non_eligible_campaigns_key = []
         group_campaigns.each do |campaign|
-          unless eligible_campaigns.include? campaign
-            non_eligible_campaigns_key.push(campaign["key"])
-          end
+          non_eligible_campaigns_key.push(campaign['key']) unless eligible_campaigns.include? campaign
         end
         non_eligible_campaigns_key
       end
@@ -795,54 +795,54 @@ class VWO
       # @param[Boolean] :disable_logs                       optional: disable logs if True
       # @return[Boolean]
 
-      def check_whitelisting_or_storage_for_grouped_campaigns(user_id, called_campaign, group_campaigns, group_name, variation_targeting_variables, disable_logs = false)
+      def whitelisting_or_storage_for_grouped_campaigns?(user_id, called_campaign, group_campaigns, group_name, variation_targeting_variables, disable_logs = false)
         group_campaigns.each do |campaign|
-          if called_campaign["id"] != campaign["id"]
-            targeted_variation = evaluate_whitelisting(
-              user_id,
-              campaign,
-              '',
-              campaign["key"],
-              variation_targeting_variables,
-              true
-            )
-            if targeted_variation
-              @logger.log(
-                LogLevelEnum::INFO,
-                'OTHER_CAMPAIGN_SATISFIES_WHITELISTING_STORAGE',
-                {
-                  '{file}' => FILE,
-                  '{campaignKey}' => campaign["key"],
-                  '{userId}' => user_id,
-                  '{groupName}' => group_name,
-                  '{type}' => "whitelisting"
-                },
-                disable_logs
-              )
-              return true
-            end
-          end
+          next unless called_campaign['id'] != campaign['id']
+
+          targeted_variation = evaluate_whitelisting(
+            user_id,
+            campaign,
+            '',
+            campaign['key'],
+            variation_targeting_variables,
+            true
+          )
+          next unless targeted_variation
+
+          @logger.log(
+            LogLevelEnum::INFO,
+            'OTHER_CAMPAIGN_SATISFIES_WHITELISTING_STORAGE',
+            {
+              '{file}' => FILE,
+              '{campaignKey}' => campaign['key'],
+              '{userId}' => user_id,
+              '{groupName}' => group_name,
+              '{type}' => 'whitelisting'
+            },
+            disable_logs
+          )
+          return true
         end
 
         group_campaigns.each do |campaign|
-          if called_campaign["id"] != campaign["id"]
-            user_storage_data = get_user_storage(user_id, campaign["key"], true)
-            if user_storage_data
-              @logger.log(
-                LogLevelEnum::INFO,
-                'OTHER_CAMPAIGN_SATISFIES_WHITELISTING_STORAGE',
-                {
-                  '{file}' => FILE,
-                  '{campaignKey}' => campaign["key"],
-                  '{userId}' => user_id,
-                  '{groupName}' => group_name,
-                  '{type}' => "user storag"
-                },
-                disable_logs
-              )
-              return true
-            end
-          end
+          next unless called_campaign['id'] != campaign['id']
+
+          user_storage_data = get_user_storage(user_id, campaign['key'], true)
+          next unless user_storage_data
+
+          @logger.log(
+            LogLevelEnum::INFO,
+            'OTHER_CAMPAIGN_SATISFIES_WHITELISTING_STORAGE',
+            {
+              '{file}' => FILE,
+              '{campaignKey}' => campaign['key'],
+              '{userId}' => user_id,
+              '{groupName}' => group_name,
+              '{type}' => 'user storag'
+            },
+            disable_logs
+          )
+          return true
         end
         false
       end
@@ -880,22 +880,16 @@ class VWO
               '{file}' => FILE,
               '{campaignKey}' => campaign_key,
               '{userId}' => user_id,
-              '{customVariables}' => variation_targeting_variables ? variation_targeting_variables : {},
+              '{customVariables}' => variation_targeting_variables || {},
               '{status}' => status,
               '{segmentationType}' => SegmentationTypeEnum::WHITELISTING,
-              '{variation}' => (status == StatusEnum::PASSED && campaign['type'] != CampaignTypes::FEATURE_ROLLOUT) ? "for variation:#{variation['name']}" : ' '
+              '{variation}' => status == StatusEnum::PASSED && campaign['type'] != CampaignTypes::FEATURE_ROLLOUT ? "for variation:#{variation['name']}" : ' '
             },
             disable_logs
           )
 
           if variation
-            if campaign['type'] == CampaignTypes::VISUAL_AB || campaign['type'] == CampaignTypes::FEATURE_TEST
-              decision[:variation_name] = variation['name']
-              decision[:variation_id] = variation['id']
-              if campaign['type'] == CampaignTypes::FEATURE_TEST
-                decision[:is_feature_enabled] = variation['isFeatureEnabled']
-              end
-            end
+            decision = add_variation_to_decision_properties(decision, campaign, variation)
             decision[:is_user_whitelisted] = true
             @hooks_manager.execute(decision)
           end
@@ -917,7 +911,6 @@ class VWO
         end
         nil
       end
-
     end
   end
 end