vwo-sdk 1.14.0 → 1.22.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 53bc0be49f50d280aac4478d6879a31dce269ed69596e5ff2d04b51cbcacbcbd
-  data.tar.gz: f28c84dc2ace873bf1c5fd748568d06c16583b466240df54fcf9dbd5dffec888
+  metadata.gz: 84d01560f605a69e8ed011a19ba4e3aae0f67341fd653a562d817801d6a55073
+  data.tar.gz: b1355bef1b2b095774c702a6757c1a7141e2cf9758d0a1b8a0510111a8ee597a
 SHA512:
-  metadata.gz: 63bf38a8c25c69e01cf7cbfdad204379c0dd03621e947c1848a1fdf24b432bd26672a8d3cb9efded0e45582208a73a0c69142911c900e53e477e06b2d06a069e
-  data.tar.gz: 0b9d9165ca2ae918a048537097f2de775fe13d35547c341aa45c7edc42206273775f18120c10ca06fc02821c24652bd25e513a05989889664285210b6fd57f02
+  metadata.gz: cc2c8a411e3c0a674ab2bc00e540b3e49a8dd943ec50aa04fba04839ef6f3e255fc275529f872aa5ca73dfe893cb43e8853a0875cc3dda9330554b6491590947
+  data.tar.gz: 5482e79564a365ec8fe4012b25997096352129e915daca28774c790c416a528302ea1f0bb685ef559b9ee0846b0229957a8f6ab77008f4e48222a7cae5892699

data/lib/abc.txt

@@ -0,0 +1,28 @@
+{"user_id"=>"Ashley", "variation_name"=>"Control", "campaign_key"=>"DEV_TEST_162"}
+GOT_ELIGIBLE_CAMPAIGNS
+{"user_id"=>"Ashley", "variation_name"=>"Control", "campaign_key"=>"DEV_TEST_162"}
+GOT_ELIGIBLE_CAMPAIGNS
+{"user_id"=>"Ashley", "variation_name"=>"Control", "campaign_key"=>"DEV_TEST_162"}
+GOT_ELIGIBLE_CAMPAIGNS
+{"user_id"=>"Ashley", "variation_name"=>"Control", "campaign_key"=>"DEV_TEST_162"}
+GOT_ELIGIBLE_CAMPAIGNS
+{"user_id"=>"Ashley", "variation_name"=>"Control", "campaign_key"=>"DEV_TEST_162"}
+GOT_ELIGIBLE_CAMPAIGNS
+{"user_id"=>"Ashley", "variation_name"=>"Control", "campaign_key"=>"DEV_TEST_162"}
+GOT_ELIGIBLE_CAMPAIGNS
+{"user_id"=>"Ashley", "variation_name"=>"Control", "campaign_key"=>"DEV_TEST_162"}
+GOT_ELIGIBLE_CAMPAIGNS
+{"user_id"=>"Ashley", "variation_name"=>"Control", "campaign_key"=>"DEV_TEST_162"}
+GOT_ELIGIBLE_CAMPAIGNS
+{"user_id"=>"Ashley", "variation_name"=>"Control", "campaign_key"=>"DEV_TEST_162"}
+GOT_ELIGIBLE_CAMPAIGNS
+{"user_id"=>"Ashley", "variation_name"=>"Control", "campaign_key"=>"DEV_TEST_162"}
+GOT_ELIGIBLE_CAMPAIGNS
+{"user_id"=>"Ashley", "variation_name"=>"Control", "campaign_key"=>"DEV_TEST_162"}
+GOT_ELIGIBLE_CAMPAIGNS
+{"user_id"=>"Ashley", "variation_name"=>"Control", "campaign_key"=>"DEV_TEST_162"}
+GOT_ELIGIBLE_CAMPAIGNS
+{"user_id"=>"Ashley", "variation_name"=>"Control", "campaign_key"=>"DEV_TEST_162"}
+GOT_ELIGIBLE_CAMPAIGNS
+{"user_id"=>"Ashley", "variation_name"=>"Control", "campaign_key"=>"DEV_TEST_162"}
+GOT_ELIGIBLE_CAMPAIGNS

data/lib/vwo/constants.rb

@@ -19,6 +19,7 @@ class VWO
     SEED_VALUE = 1
     MAX_TRAFFIC_PERCENT = 100
     MAX_TRAFFIC_VALUE = 10_000
+    MAX_RANGE = 10000
     STATUS_RUNNING = 'RUNNING'
     # rubocop:disable Style/ExpandPathArguments
     LIBRARY_PATH =  File.expand_path('../..', __FILE__)
@@ -26,7 +27,7 @@ class VWO
     HTTP_PROTOCOL = 'http://'
     HTTPS_PROTOCOL = 'https://'
     URL_NAMESPACE = '6ba7b811-9dad-11d1-80b4-00c04fd430c8'
-    SDK_VERSION = '1.14.0'
+    SDK_VERSION = '1.22.0'
     SDK_NAME = 'ruby'
     VWO_DELIMITER = '_vwo_'
     MAX_EVENTS_PER_REQUEST = 5000
@@ -68,6 +69,7 @@ class VWO
       INTEGER = 'integer'
       DOUBLE = 'double'
       BOOLEAN = 'boolean'
+      JSON = 'json'
     end
 
     module Hooks
@@ -80,7 +82,8 @@ class VWO
       'string' => [String],
       'integer' => [Integer],
       'double' => [Float],
-      'boolean' => [TrueClass, FalseClass]
+      'boolean' => [TrueClass, FalseClass],
+      'json' => [Hash]
     }
 
     GOAL_TYPES = {

data/lib/vwo/core/bucketer.rb

@@ -60,7 +60,7 @@ class VWO
         end
 
         traffic_allocation = campaign['percentTraffic']
-        value_assigned_to_user = get_bucket_value_for_user(user_id)
+        value_assigned_to_user = get_bucket_value_for_user(user_id, campaign)
         is_user_part = (value_assigned_to_user != 0) && value_assigned_to_user <= traffic_allocation
         @logger.log(
           LogLevelEnum::INFO,
@@ -94,7 +94,11 @@ class VWO
           return
         end
 
-        hash_value = MurmurHash3::V32.str_hash(user_id, SEED_VALUE) & U_MAX_32_BIT
+        user_id_for_hash_value = user_id
+        if campaign[:isBucketingSeedEnabled]
+          user_id_for_hash_value = campaign[:id].to_s + "_" + user_id
+        end
+        hash_value = MurmurHash3::V32.str_hash(user_id_for_hash_value, SEED_VALUE) & U_MAX_32_BIT
         normalize = MAX_TRAFFIC_VALUE.to_f / campaign['percentTraffic']
         multiplier = normalize / 100
         bucket_value = get_bucket_value(
@@ -136,10 +140,17 @@ class VWO
       # User by hashing the userId by murmurHash and scaling it down.
       #
       # @param[String]    :user_id    The unique ID assigned to User
+      # @param[String]    :campaign   Campaign data
       # @return[Integer]              The bucket Value allotted to User
       #                               (between 1 to $this->$MAX_TRAFFIC_PERCENT)
-      def get_bucket_value_for_user(user_id)
-        hash_value = MurmurHash3::V32.str_hash(user_id, SEED_VALUE) & U_MAX_32_BIT
+      def get_bucket_value_for_user(user_id, campaign = {}, group_id = nil, disable_logs = false)
+        user_id_for_hash_value = user_id
+        if group_id
+          user_id_for_hash_value = group_id.to_s + "_" + user_id
+        elsif campaign[:isBucketingSeedEnabled]
+          user_id_for_hash_value = campaign[:id].to_s + "_" + user_id
+        end
+        hash_value = MurmurHash3::V32.str_hash(user_id_for_hash_value, SEED_VALUE) & U_MAX_32_BIT
         bucket_value = get_bucket_value(hash_value, MAX_TRAFFIC_PERCENT)
 
         @logger.log(
@@ -150,7 +161,8 @@ class VWO
             hash_value: hash_value,
             bucket_value: bucket_value,
             user_id: user_id
-          )
+          ),
+          disable_logs
         )
         bucket_value
       end
@@ -168,6 +180,22 @@ class VWO
         multiplied_value = (max_value * ratio + 1) * multiplier
         multiplied_value.to_i
       end
+
+      # Returns a campaign by checking the Start and End Bucket Allocations of each campaign.
+      #
+      # @param[Integer]     :range_for_campaigns       the bucket value of the user
+      # @param[Hash]        :campaigns                 The bucket Value of the user
+      # @return[Hash|nil]
+      #
+      def get_campaign_using_range(range_for_campaigns, campaigns)
+        range_for_campaigns = range_for_campaigns * 100
+        campaigns.each do |campaign|
+          if campaign["max_range"] && campaign["max_range"] >= range_for_campaigns && campaign["min_range"] <= range_for_campaigns
+            return campaign
+          end
+        end
+        nil
+      end
     end
   end
 end

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,65 +95,23 @@ 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)
-        variation = variation.dup  # deep copy
+
+        if variation
+          variation = variation.dup  # deep copy
+        end
 
         if variation
           if valid_string?(user_campaign_map['goal_identifier']) && api_name == ApiMethods::TRACK
@@ -191,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(
@@ -220,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 && variation['name']
-          save_user_storage(user_id, campaign_key, variation['name'], goal_identifier) if variation['name']
+        if variation.nil?
+          variation = get_variation_allotted(user_id, campaign)
 
-          @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
@@ -318,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,
@@ -338,7 +321,8 @@ class VWO
               user_id: user_id,
               campaign_key: campaign['key'],
               method: 'get_variation_allotted'
-            )
+            ),
+            disable_logs
           )
           variation
         else
@@ -351,7 +335,8 @@ class VWO
               user_id: user_id,
               campaign_key: nil,
               method: 'get_variation_allotted'
-            )
+            ),
+            disable_logs
           )
           nil
         end
@@ -410,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
@@ -432,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
@@ -452,10 +454,11 @@ 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 }
         else
@@ -467,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,7 +488,8 @@ class VWO
                 variation_name: variation['name'],
                 segmentation_type: SegmentationTypeEnum::WHITELISTING,
                 api_name: api_name
-              )
+              ),
+              disable_logs
             )
           else
             @logger.log(
@@ -497,7 +501,8 @@ class VWO
                 user_id: user_id,
                 api_name: api_name,
                 variation: variation['name']
-              )
+              ),
+              disable_logs
             )
           end
         end
@@ -522,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
@@ -550,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
@@ -574,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
@@ -590,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']
@@ -605,7 +622,8 @@ class VWO
             campaign_key: campaign_key,
             user_id: user_id,
             variation_name: variation_name
-          )
+          ),
+          disable_logs
         )
 
         get_campaign_variation(
@@ -614,6 +632,277 @@ 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.append(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.append(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.append(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_name: status == StatusEnum::PASSED ? "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']
+              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
+            ),
+            disable_logs
+          )
+        end
+        nil
+      end
+
     end
   end
 end