vwo-sdk 1.15.0 → 1.23.1

data/lib/vwo/core/variation_decider.rb

@@ -66,6 +66,8 @@ class VWO
 
         return unless campaign
 
+        is_campaign_part_of_group = @settings_file && is_part_of_group(@settings_file, campaign["id"])
+
         @has_stored_variation = false
         decision = {
           :campaign_id => campaign['id'],
@@ -93,62 +95,17 @@ class VWO
           :vwo_user_id => generator_for(user_id, @settings_file['accountId'])
         }
 
-        if campaign['isForcedVariationEnabled']
-          variation = evaluate_whitelisting(
-            user_id,
-            campaign,
-            api_name,
-            campaign_key,
-            variation_targeting_variables
-          )
-          status = if variation
-                     StatusEnum::PASSED
-                   else
-                     StatusEnum::FAILED
-                   end
-
-          @logger.log(
-            LogLevelEnum::INFO,
-            format(
-              LogMessageEnum::InfoMessages::SEGMENTATION_STATUS,
-              file: FILE,
-              campaign_key: campaign_key,
-              user_id: user_id,
-              status: status,
-              custom_variables: variation_targeting_variables,
-              variation_name: status == StatusEnum::PASSED ? "and #{variation['name']} is Assigned" : ' ',
-              segmentation_type: SegmentationTypeEnum::WHITELISTING,
-              api_name: api_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']
-              elsif campaign['type'] == CampaignTypes::VISUAL_AB
-                decision[:is_user_whitelisted] = !!variation['name']
-              end
-            end
-            @hooks_manager.execute(decision)
-          end
-
-          return variation if variation && variation['name']
-        else
-          @logger.log(
-            LogLevelEnum::INFO,
-            format(
-              LogMessageEnum::InfoMessages::WHITELISTING_SKIPPED,
-              file: FILE,
-              campaign_key: campaign_key,
-              user_id: user_id,
-              api_name: api_name
-            )
-          )
+        if is_campaign_part_of_group
+          group_id = @settings_file["campaignGroups"][campaign["id"].to_s]
+          decision[:group_id] = group_id
+          group_name = @settings_file["groups"][group_id.to_s]["name"]
+          decision[:group_name] = group_name
         end
 
+        # evaluate whitelisting
+        variation = get_variation_if_whitelisting_passed(user_id, campaign, variation_targeting_variables, api_name, decision, true)
+        return variation if variation && variation['name']
+
         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)
 
@@ -194,8 +151,7 @@ class VWO
             )
           )
 
-          if ([ApiMethods::TRACK, ApiMethods::GET_VARIATION_NAME, ApiMethods::GET_FEATURE_VARIABLE_VALUE].include? api_name) &&
-            @user_storage_service && campaign['type'] != CampaignTypes::FEATURE_ROLLOUT
+          if ([ApiMethods::TRACK, ApiMethods::GET_VARIATION_NAME, ApiMethods::GET_FEATURE_VARIABLE_VALUE].include? api_name) && @user_storage_service
             @logger.log(
               LogLevelEnum::DEBUG,
               format(
@@ -223,82 +179,106 @@ class VWO
         end
 
         # Pre-segmentation
+        is_presegmentation = check_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
 
-        segments = get_segments(campaign)
-        is_valid_segments = valid_value?(segments)
+        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
+              @logger.log(
+                LogLevelEnum::INFO,
+                format(
+                  LogMessageEnum::InfoMessages::CALLED_CAMPAIGN_NOT_WINNER,
+                  file: FILE,
+                  campaign_key: campaign_key,
+                  user_id: user_id,
+                  group_name: group_name
+                )
+              )
+              return nil
+            end
+
+            eligible_campaigns = get_eligible_campaigns(user_id, group_campaigns, campaign, custom_variables)
+            non_eligible_campaigns_key = get_non_eligible_campaigns_key(eligible_campaigns, group_campaigns)
+
+            @logger.log(
+              LogLevelEnum::DEBUG,
+              format(
+                LogMessageEnum::DebugMessages::GOT_ELIGIBLE_CAMPAIGNS,
+                file: FILE,
+                user_id: user_id,
+                eligible_campaigns_key: get_eligible_campaigns_key(eligible_campaigns).join(","),
+                ineligible_campaigns_log_text: non_eligible_campaigns_key ? ("campaigns:" + non_eligible_campaigns_key.join("'")) : "no campaigns",
+                group_name: group_name
+              )
+            )
 
-        if is_valid_segments
-          unless custom_variables
             @logger.log(
               LogLevelEnum::INFO,
               format(
-                LogMessageEnum::InfoMessages::NO_CUSTOM_VARIABLES,
+                LogMessageEnum::InfoMessages::GOT_ELIGIBLE_CAMPAIGNS,
                 file: FILE,
-                campaign_key: campaign_key,
                 user_id: user_id,
-                api_name: api_name
+                no_of_eligible_campaigns: eligible_campaigns.length,
+                no_of_group_campaigns: group_campaigns.length,
+                group_name: group_name
               )
             )
-            custom_variables = {}
-          end
-          unless @segment_evaluator.evaluate(campaign_key, user_id, segments, custom_variables)
+
+            winner_campaign = get_winner_campaign(user_id, eligible_campaigns, group_id)
             @logger.log(
               LogLevelEnum::INFO,
               format(
-                LogMessageEnum::InfoMessages::USER_FAILED_SEGMENTATION,
-                file: FileNameEnum::SegmentEvaluator,
+                LogMessageEnum::InfoMessages::GOT_WINNER_CAMPAIGN,
+                file: FILE,
                 user_id: user_id,
-                campaign_key: campaign_key,
-                custom_variables: custom_variables
+                campaign_key: winner_campaign["key"],
+                group_name: group_name
               )
             )
-            return
+
+            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,
+                format(
+                  LogMessageEnum::InfoMessages::CALLED_CAMPAIGN_NOT_WINNER,
+                  file: FILE,
+                  campaign_key: campaign_key,
+                  user_id: user_id,
+                  group_name: group_name
+                )
+              )
+              return nil
+            end
           end
-          @logger.log(
-            LogLevelEnum::INFO,
-            format(
-              LogMessageEnum::InfoMessages::USER_PASSED_SEGMENTATION,
-              file: FileNameEnum::SegmentEvaluator,
-              user_id: user_id,
-              campaign_key: campaign_key,
-              custom_variables: custom_variables
-            )
-          )
-        else
-          @logger.log(
-            LogLevelEnum::INFO,
-            format(
-              LogMessageEnum::InfoMessages::SKIPPING_SEGMENTATION,
-              file: FILE,
-              campaign_key: campaign_key,
-              user_id: user_id,
-              api_name: api_name,
-              variation: ''
-            )
-          )
         end
 
-        variation = get_variation_allotted(user_id, campaign)
+        if variation.nil?
+          variation = get_variation_allotted(user_id, campaign)
 
-        if variation && variation['name']
-          save_user_storage(user_id, campaign_key, variation['name'], goal_identifier) if variation['name']
-
-          @logger.log(
-            LogLevelEnum::INFO,
-            format(
-              LogMessageEnum::InfoMessages::VARIATION_ALLOCATED,
-              file: FILE,
-              campaign_key: campaign_key,
-              user_id: user_id,
-              variation_name: variation['name'],
-              campaign_type: campaign['type']
+          if variation && variation['name']
+            save_user_storage(user_id, campaign_key, campaign['type'], variation['name'], goal_identifier) if variation['name']
+          else
+            @logger.log(
+              LogLevelEnum::INFO,
+              format(LogMessageEnum::InfoMessages::NO_VARIATION_ALLOCATED, file: FILE, campaign_key: campaign_key, user_id: user_id)
             )
-          )
-        else
-          @logger.log(
-            LogLevelEnum::INFO,
-            format(LogMessageEnum::InfoMessages::NO_VARIATION_ALLOCATED, file: FILE, campaign_key: campaign_key, user_id: user_id)
-          )
+          end
+
         end
 
         if variation
@@ -321,7 +301,7 @@ class VWO
       #
       # @return[Hash]
 
-      def get_variation_allotted(user_id, campaign)
+      def get_variation_allotted(user_id, campaign, disable_logs = false)
         unless valid_value?(user_id)
           @logger.log(
             LogLevelEnum::ERROR,
@@ -341,7 +321,8 @@ class VWO
               user_id: user_id,
               campaign_key: campaign['key'],
               method: 'get_variation_allotted'
-            )
+            ),
+            disable_logs
           )
           variation
         else
@@ -354,7 +335,8 @@ class VWO
               user_id: user_id,
               campaign_key: nil,
               method: 'get_variation_allotted'
-            )
+            ),
+            disable_logs
           )
           nil
         end
@@ -413,13 +395,15 @@ class VWO
       # @param[String]              :campaign_key       Unique campaign identifier
       # @param[String]              :variation_name     Variation identifier
       # @param[String]              :goal_identifier    The unique campaign's goal identifier
+      # @param[Boolean]             :disable_logs       optional: disable logs if True
       # @return[Boolean]                                true if found otherwise false
 
-      def save_user_storage(user_id, campaign_key, variation_name, goal_identifier)
+      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,
-            format(LogMessageEnum::DebugMessages::NO_USER_STORAGE_SERVICE_SAVE, file: FILE)
+            format(LogMessageEnum::DebugMessages::NO_USER_STORAGE_SERVICE_SAVE, file: FILE),
+            disable_logs
           )
           return false
         end
@@ -435,13 +419,28 @@ class VWO
 
         @logger.log(
           LogLevelEnum::INFO,
-          format(LogMessageEnum::InfoMessages::SAVING_DATA_USER_STORAGE_SERVICE, file: FILE, user_id: user_id)
+          format(LogMessageEnum::InfoMessages::SAVING_DATA_USER_STORAGE_SERVICE, file: FILE, user_id: user_id),
+          disable_logs
+        )
+
+        @logger.log(
+          LogLevelEnum::INFO,
+          format(
+            LogMessageEnum::InfoMessages::VARIATION_ALLOCATED,
+            file: FILE,
+            campaign_key: campaign_key,
+            user_id: user_id,
+            variation_name: variation_name,
+            campaign_type: campaign_type
+          ),
+          disable_logs
         )
         true
       rescue StandardError
         @logger.log(
           LogLevelEnum::ERROR,
-          format(LogMessageEnum::ErrorMessages::SAVE_USER_STORAGE_SERVICE_FAILED, file: FILE, user_id: user_id)
+          format(LogMessageEnum::ErrorMessages::SAVE_USER_STORAGE_SERVICE_FAILED, file: FILE, user_id: user_id),
+          disable_logs
         )
         false
       end
@@ -455,14 +454,15 @@ class VWO
       # @param[String]  :api_name                           The key Passed to identify the calling API
       # @param[String]  :campaign_key                       Unique campaign key
       # @param[Hash]    :variation_targeting_variables      Key/value pair of Whitelisting Custom Attributes
+      # @param[Boolean] :disable_logs                       optional: disable logs if True
       #
       # @return[Hash]
 
-      def evaluate_whitelisting(user_id, campaign, api_name, campaign_key, variation_targeting_variables = {})
+      def evaluate_whitelisting(user_id, campaign, api_name, campaign_key, variation_targeting_variables = {}, disable_logs = false)
         if variation_targeting_variables.nil?
-          variation_targeting_variables = { '_vwo_user_id' => user_id }
+          variation_targeting_variables = { _vwo_user_id: user_id }
         else
-          variation_targeting_variables['_vwo_user_id'] = user_id
+          variation_targeting_variables[:_vwo_user_id] = user_id
         end
         targeted_variations = []
 
@@ -470,7 +470,7 @@ class VWO
           segments = get_segments(variation)
           is_valid_segments = valid_value?(segments)
           if is_valid_segments
-            if @segment_evaluator.evaluate(campaign_key, user_id, segments, variation_targeting_variables)
+            if @segment_evaluator.evaluate(campaign_key, user_id, segments, variation_targeting_variables, disable_logs)
               targeted_variations.push(variation)
               status = StatusEnum::PASSED
             else
@@ -485,10 +485,11 @@ class VWO
                 user_id: user_id,
                 status: status,
                 custom_variables: variation_targeting_variables,
-                variation_name: variation['name'],
+                variation_name: status == StatusEnum::PASSED ? (campaign['type'] == CampaignTypes::FEATURE_ROLLOUT ? 'and hence becomes part of the rollout' : "for " + variation['name']) : '',
                 segmentation_type: SegmentationTypeEnum::WHITELISTING,
                 api_name: api_name
-              )
+              ),
+              disable_logs
             )
           else
             @logger.log(
@@ -500,7 +501,8 @@ class VWO
                 user_id: user_id,
                 api_name: api_name,
                 variation: variation['name']
-              )
+              ),
+              disable_logs
             )
           end
         end
@@ -525,7 +527,8 @@ class VWO
           whitelisted_variation = @bucketer.get_variation(
             targeted_variations_deep_clone,
             @bucketer.get_bucket_value_for_user(
-              user_id
+              user_id,
+              campaign
             )
           )
         else
@@ -553,18 +556,26 @@ class VWO
         end
       end
 
+      def scale_campaigns_weight(campaigns)
+        normalize_weight = 100/campaigns.length
+        campaigns.each do |campaign|
+          campaign['weight'] = normalize_weight
+        end
+      end
       # Get the UserStorageData after looking up into get method
       # Being provided via UserStorageService
       #
       # @param[String]: Unique user identifier
       # @param[String]: Unique campaign key
+      # @param[Boolean] :disable_logs if True
       # @return[Hash|Boolean]: user_storage data
 
-      def get_user_storage(user_id, campaign_key)
+      def get_user_storage(user_id, campaign_key, disable_logs = false)
         unless @user_storage_service
           @logger.log(
             LogLevelEnum::DEBUG,
-            format(LogMessageEnum::DebugMessages::NO_USER_STORAGE_SERVICE_LOOKUP, file: FILE)
+            format(LogMessageEnum::DebugMessages::NO_USER_STORAGE_SERVICE_LOOKUP, file: FILE),
+            disable_logs
           )
           return false
         end
@@ -577,13 +588,15 @@ class VWO
             file: FILE,
             user_id: user_id,
             status: data.nil? ? 'Not Found' : 'Found'
-          )
+          ),
+          disable_logs
         )
         data
       rescue StandardError
         @logger.log(
           LogLevelEnum::ERROR,
-          format(LogMessageEnum::ErrorMessages::LOOK_UP_USER_STORAGE_SERVICE_FAILED, file: FILE, user_id: user_id)
+          format(LogMessageEnum::ErrorMessages::LOOK_UP_USER_STORAGE_SERVICE_FAILED, file: FILE, user_id: user_id),
+          disable_logs
         )
         false
       end
@@ -593,10 +606,11 @@ class VWO
       # @param[String]            :user_id
       # @param[String]            :campaign_key campaign identified
       # @param[Hash]              :user_campaign_map BucketMap consisting of stored user variation
+      # @param[Boolean] :disable_logs if True
       #
       # @return[Object, nil]      if found then variation settings object otherwise None
 
-      def get_stored_variation(user_id, campaign_key, user_campaign_map)
+      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']
@@ -608,7 +622,8 @@ class VWO
             campaign_key: campaign_key,
             user_id: user_id,
             variation_name: variation_name
-          )
+          ),
+          disable_logs
         )
 
         get_campaign_variation(
@@ -617,6 +632,276 @@ class VWO
           variation_name
         )
       end
+
+      # this function check whether pre-segmentation is passed or not
+      #
+      # @param[String]  :user_id                            The unique key assigned to User
+      # @param[Hash]    :campaign                           Campaign hash for Unique campaign key
+      # @param[Hash]    :custom_variables                   Key/value pair for segmentation
+      # @param[String]  :api_name                           The key Passed to identify the calling API
+      # @param[Boolean] :disable_logs                       optional: disable logs if True
+      #
+      # @return[Boolean]
+      def check_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
+            @logger.log(
+              LogLevelEnum::INFO,
+              format(
+                LogMessageEnum::InfoMessages::NO_CUSTOM_VARIABLES,
+                file: FILE,
+                campaign_key: campaign_key,
+                user_id: user_id,
+                api_name: api_name
+              ),
+              disable_logs
+            )
+            custom_variables = {}
+          end
+          unless @segment_evaluator.evaluate(campaign_key, user_id, segments, custom_variables, disable_logs)
+            @logger.log(
+              LogLevelEnum::INFO,
+              format(
+                LogMessageEnum::InfoMessages::USER_FAILED_SEGMENTATION,
+                file: FileNameEnum::SegmentEvaluator,
+                user_id: user_id,
+                campaign_key: campaign_key,
+                custom_variables: custom_variables
+              ),
+              disable_logs
+            )
+            return false
+          end
+          @logger.log(
+            LogLevelEnum::INFO,
+            format(
+              LogMessageEnum::InfoMessages::USER_PASSED_SEGMENTATION,
+              file: FileNameEnum::SegmentEvaluator,
+              user_id: user_id,
+              campaign_key: campaign_key,
+              custom_variables: custom_variables
+            ),
+            disable_logs
+          )
+        else
+          @logger.log(
+            LogLevelEnum::INFO,
+            format(
+              LogMessageEnum::InfoMessages::SKIPPING_SEGMENTATION,
+              file: FILE,
+              campaign_key: campaign_key,
+              user_id: user_id,
+              api_name: api_name,
+              variation: ''
+            ),
+            disable_logs
+          )
+        end
+        true
+      end
+
+      # Finds and returns eligible campaigns from group_campaigns.
+      #
+      # @param[String]  :user_id                            The unique key assigned to User
+      # @param[Hash]    :called_campaign                    campaign for which api is called
+      # @param[Array]   :group_campaigns                    campaigns part of group
+      # @param[String]  :custom_variables                   Key/value pair for segmentation
+      #
+      # @return[Array]
+      def get_eligible_campaigns(user_id, group_campaigns, called_campaign, custom_variables)
+        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)
+            eligible_campaigns.push(campaign)
+          end
+        end
+        return eligible_campaigns
+      end
+
+      # Finds and returns the winner campaign from eligible_campaigns list.
+      #
+      # @param[String]  :user_id                            The unique key assigned to User
+      # @param[Array]   :eligible_campaigns                 campaigns part of group which were eligible to be winner
+      #
+      # @return[Hash]
+      def get_winner_campaign(user_id, eligible_campaigns, group_id)
+        if eligible_campaigns.length == 1
+          return eligible_campaigns[0]
+        end
+
+        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)
+      end
+
+      # Get campaign keys of all eligible Campaigns.
+      #
+      # @param[Array]   :eligible_campaigns                 campaigns part of group which were eligible to be winner
+      #
+      # @return[Array]
+      def get_eligible_campaigns_key(eligible_campaigns)
+        eligible_campaigns_key = []
+        eligible_campaigns.each do |campaign|
+          eligible_campaigns_key.push(campaign["key"])
+        end
+        eligible_campaigns_key
+      end
+
+      # Get campaign keys of all non eligible Campaigns.
+      #
+      # @param[Array]   :eligible_campaigns                 campaigns part of group which were eligible to be winner
+      # @param[Array]   :group_campaigns                    campaigns part of group
+      #
+      # @return[Array]
+      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
+        end
+        non_eligible_campaigns_key
+      end
+
+      # Checks if any other campaign in groupCampaigns satisfies whitelisting or is in user storage.
+      #
+      # @param[String]  :user_id                            the unique ID assigned to User
+      # @param[Hash]    :called_campaign                    campaign for which api is called
+      # @param[Array]   :group_campaigns                    campaigns part of group
+      # @param[String]  :group_name                         group name
+      # @param[Hash]    :variation_targeting_variables      Key/value pair of Whitelisting Custom Attributes
+      # @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)
+        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,
+                format(
+                  LogMessageEnum::InfoMessages::OTHER_CAMPAIGN_SATISFIES_WHITELISTING_OR_STORAGE,
+                  file: FILE,
+                  campaign_key: campaign["key"],
+                  user_id: user_id,
+                  group_name: group_name,
+                  type: "whitelisting"
+                ),
+                disable_logs
+              )
+              return true
+            end
+          end
+        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,
+                format(
+                  LogMessageEnum::InfoMessages::OTHER_CAMPAIGN_SATISFIES_WHITELISTING_OR_STORAGE,
+                  file: FILE,
+                  campaign_key: campaign["key"],
+                  user_id: user_id,
+                  group_name: group_name,
+                  type: "user storage"
+                ),
+                disable_logs
+              )
+              return true
+            end
+          end
+        end
+        false
+      end
+
+      # Get variation if whitelisting passes
+      #
+      # @param[String]  :user_id                            the unique ID assigned to User
+      # @param[Hash]    :campaign                           campaign for which checking whitelisting
+      # @param[Hash]    :variation_targeting_variables      Key/value pair of Whitelisting Custom Attributes
+      # @param[String]  :api_name                           The key Passed to identify the calling API
+      # @param[Hash]    :decision                           data containing campaign info passed to hooks manager
+      # @param[Boolean] :disable_logs                       optional: disable logs if True
+      # @return[Hash]
+      def get_variation_if_whitelisting_passed(user_id, campaign, variation_targeting_variables, api_name, decision, disable_logs = false)
+        campaign_key = campaign['key']
+        if campaign['isForcedVariationEnabled']
+          variation = evaluate_whitelisting(
+            user_id,
+            campaign,
+            api_name,
+            campaign_key,
+            variation_targeting_variables,
+            disable_logs
+          )
+          status = if variation
+                     StatusEnum::PASSED
+                   else
+                     StatusEnum::FAILED
+                   end
+
+          @logger.log(
+            LogLevelEnum::INFO,
+            format(
+              LogMessageEnum::InfoMessages::SEGMENTATION_STATUS,
+              file: FILE,
+              campaign_key: campaign_key,
+              user_id: user_id,
+              status: status,
+              custom_variables: variation_targeting_variables ? variation_targeting_variables : {},
+              variation_name: (status == StatusEnum::PASSED && campaign['type'] != CampaignTypes::FEATURE_ROLLOUT) ? "and #{variation['name']} is Assigned" : ' ',
+              segmentation_type: SegmentationTypeEnum::WHITELISTING,
+              api_name: api_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[:is_user_whitelisted] = true
+            @hooks_manager.execute(decision)
+          end
+
+          return variation if variation && variation['name']
+        else
+          @logger.log(
+            LogLevelEnum::INFO,
+            format(
+              LogMessageEnum::InfoMessages::WHITELISTING_SKIPPED,
+              file: FILE,
+              campaign_key: campaign_key,
+              user_id: user_id,
+              api_name: api_name
+            ),
+            disable_logs
+          )
+        end
+        nil
+      end
+
     end
   end
 end