vwo-sdk 1.3.0 → 1.14.1

data/lib/vwo/constants.rb

@@ -1,4 +1,4 @@
-# Copyright 2019 Wingify Software Pvt. Ltd.
+# Copyright 2019-2021 Wingify Software Pvt. Ltd.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -12,8 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-# frozen_string_literal: true
-
 class VWO
   module CONSTANTS
     API_VERSION = 1
@@ -22,23 +20,35 @@ class VWO
     MAX_TRAFFIC_PERCENT = 100
     MAX_TRAFFIC_VALUE = 10_000
     STATUS_RUNNING = 'RUNNING'
+    # rubocop:disable Style/ExpandPathArguments
     LIBRARY_PATH =  File.expand_path('../..', __FILE__)
+    # rubocop:enable Style/ExpandPathArguments
     HTTP_PROTOCOL = 'http://'
     HTTPS_PROTOCOL = 'https://'
     URL_NAMESPACE = '6ba7b811-9dad-11d1-80b4-00c04fd430c8'
-    SDK_VERSION = '1.3.0'
+    SDK_VERSION = '1.14.1'
     SDK_NAME = 'ruby'
+    VWO_DELIMITER = '_vwo_'
+    MAX_EVENTS_PER_REQUEST = 5000
+    MIN_EVENTS_PER_REQUEST = 1
+    DEFAULT_EVENTS_PER_REQUEST = 100
+    DEFAULT_REQUEST_TIME_INTERVAL = 600 # 10 * 60(secs) = 600 secs i.e. 10 minutes
+    MIN_REQUEST_TIME_INTERVAL = 2
 
     module ENDPOINTS
       BASE_URL = 'dev.visualwebsiteoptimizer.com'
-      ACCOUNT_SETTINGS = '/server-side/settings'
+      SETTINGS_URL = '/server-side/settings'
+      WEBHOOK_SETTINGS_URL = '/server-side/pull'
       TRACK_USER = '/server-side/track-user'
       TRACK_GOAL = '/server-side/track-goal'
+      PUSH = '/server-side/push'
+      BATCH_EVENTS = '/server-side/batch-events'
     end
 
     module EVENTS
       TRACK_USER = 'track-user'
       TRACK_GOAL = 'track-goal'
+      PUSH = 'push'
     end
 
     module DATATYPE
@@ -48,16 +58,57 @@ class VWO
       BOOLEAN = 'boolean'
     end
 
-    module APIMETHODS
-      CREATE_INSTANCE = 'CREATE_INSTANCE'
-      ACTIVATE = 'ACTIVATE'
-      GET_VARIATION = 'GET_VARIATION'
-      TRACK = 'TRACK'
-    end
-
-    module GOALTYPES
+    module GoalTypes
       REVENUE = 'REVENUE_TRACKING'
       CUSTOM = 'CUSTOM_GOAL'
     end
+
+    module VariableTypes
+      STRING = 'string'
+      INTEGER = 'integer'
+      DOUBLE = 'double'
+      BOOLEAN = 'boolean'
+    end
+
+    module Hooks
+      DECISION_TYPES = {
+        'CAMPAIGN_DECISION' => 'CAMPAIGN_DECISION'
+      }
+    end
+
+    RUBY_VARIABLE_TYPES = {
+      'string' => [String],
+      'integer' => [Integer],
+      'double' => [Float],
+      'boolean' => [TrueClass, FalseClass]
+    }
+
+    GOAL_TYPES = {
+      'REVENUE' => 'REVENUE_TRACKING',
+      'CUSTOM' => 'CUSTOM_GOAL',
+      'ALL' => 'ALL'
+    }
+
+    module ApiMethods
+      ACTIVATE = 'activate'
+      GET_VARIATION_NAME = 'get_variation_name'
+      TRACK = 'track'
+      IS_FEATURE_ENABLED = 'is_feature_enabled'
+      GET_FEATURE_VARIABLE_VALUE = 'get_feature_variable_value'
+      PUSH = 'push'
+      GET_AND_UPDATE_SETTINGS_FILE = 'get_and_update_settings_file'
+      FLUSH_EVENTS = 'flush_events'
+    end
+
+    module PushApi
+      TAG_VALUE_LENGTH = 255
+      TAG_KEY_LENGTH = 255
+    end
+
+    module CampaignTypes
+      VISUAL_AB = 'VISUAL_AB'
+      FEATURE_TEST = 'FEATURE_TEST'
+      FEATURE_ROLLOUT = 'FEATURE_ROLLOUT'
+    end
   end
 end

data/lib/vwo/core/bucketer.rb

@@ -1,4 +1,4 @@
-# Copyright 2019 Wingify Software Pvt. Ltd.
+# Copyright 2019-2021 Wingify Software Pvt. Ltd.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -12,8 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-# frozen_string_literal: true
-
 require 'murmurhash3'
 require_relative '../logger'
 require_relative '../enums'
@@ -43,7 +41,7 @@ class VWO
       # @param[String]         :user_id     The unique ID assigned to a user
       # @param[Dict]           :campaign    For getting traffic allotted to the campaign
       # @return[Boolean]                    If User is a part of Campaign or not
-      #
+
       def user_part_of_campaign?(user_id, campaign)
         unless valid_value?(user_id)
           @logger.log(
@@ -62,7 +60,6 @@ class VWO
         end
 
         traffic_allocation = campaign['percentTraffic']
-
         value_assigned_to_user = get_bucket_value_for_user(user_id)
         is_user_part = (value_assigned_to_user != 0) && value_assigned_to_user <= traffic_allocation
         @logger.log(
@@ -98,9 +95,9 @@ class VWO
         end
 
         hash_value = MurmurHash3::V32.str_hash(user_id, SEED_VALUE) & U_MAX_32_BIT
-        normalize = MAX_TRAFFIC_VALUE / campaign['percentTraffic']
+        normalize = MAX_TRAFFIC_VALUE.to_f / campaign['percentTraffic']
         multiplier = normalize / 100
-        bucket_value = generate_bucket_value(
+        bucket_value = get_bucket_value(
           hash_value,
           MAX_TRAFFIC_VALUE,
           multiplier
@@ -118,10 +115,9 @@ class VWO
             hash_value: hash_value
           )
         )
-        get_variation(campaign, bucket_value)
-      end
 
-      private
+        get_variation(campaign['variations'], bucket_value)
+      end
 
       # Returns the Variation by checking the Start and End
       # Bucket Allocations of each Variation
@@ -130,8 +126,8 @@ class VWO
       # @param[Integer]     :bucket_value   The bucket Value of the user
       # @return[Hash|nil]                   Variation data allotted to the user or None if not
       #
-      def get_variation(campaign, bucket_value)
-        campaign['variations'].find do |variation|
+      def get_variation(variations, bucket_value)
+        variations.find do |variation|
           (variation['start_variation_allocation']..variation['end_variation_allocation']).cover?(bucket_value)
         end
       end
@@ -144,7 +140,7 @@ class VWO
       #                               (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
-        bucket_value = generate_bucket_value(hash_value, MAX_TRAFFIC_PERCENT)
+        bucket_value = get_bucket_value(hash_value, MAX_TRAFFIC_PERCENT)
 
         @logger.log(
           LogLevelEnum::DEBUG,
@@ -167,7 +163,7 @@ class VWO
       # @param[Integer]             :multiplier
       # @return[Integer]                          Bucket Value of the User
       #
-      def generate_bucket_value(hash_value, max_value, multiplier = 1)
+      def get_bucket_value(hash_value, max_value, multiplier = 1)
         ratio = hash_value.to_f / MAX_HASH_VALUE
         multiplied_value = (max_value * ratio + 1) * multiplier
         multiplied_value.to_i

data/lib/vwo/core/variation_decider.rb

@@ -1,4 +1,4 @@
-# Copyright 2019 Wingify Software Pvt. Ltd.
+# Copyright 2019-2021 Wingify Software Pvt. Ltd.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -12,22 +12,26 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-# frozen_string_literal: true
-
 require_relative '../logger'
 require_relative '../enums'
 require_relative '../utils/campaign'
+require_relative '../services/segment_evaluator'
 require_relative '../utils/validations'
 require_relative 'bucketer'
+require_relative '../constants'
+require_relative '../services/hooks_manager'
+require_relative '../utils/uuid'
 
 class VWO
   module Core
     class VariationDecider
-      attr_reader :user_storage_service
+      attr_reader :user_storage_service, :has_stored_variation, :hooks_manager
 
       include VWO::Enums
       include VWO::Utils::Campaign
       include VWO::Utils::Validations
+      include VWO::CONSTANTS
+      include VWO::Utils::UUID
 
       FILE = FileNameEnum::VariationDecider
 
@@ -35,34 +39,125 @@ class VWO
       # @param[Hash] -   Settings file
       # @param[Class] -  Class instance having the capability of
       #                  get and save.
-      def initialize(settings_file, user_storage_service = nil)
+      def initialize(settings_file, user_storage_service = nil, options = {})
         @logger = VWO::Logger.get_instance
         @user_storage_service = user_storage_service
-        # Check if user_storage_service provided is valid or not
-        @user_storage_service = user_storage_service
         @bucketer = VWO::Core::Bucketer.new
         @settings_file = settings_file
+        @segment_evaluator = VWO::Services::SegmentEvaluator.new
+        @hooks_manager = VWO::Services::HooksManager.new(options)
       end
 
       # Returns variation for the user for the passed campaign-key
+      # Check if Whitelisting is applicable, evaluate it, if any eligible variation is found,return, otherwise skip it
       # Check in User Storage, if user found, validate variation and return
       # Otherwise, proceed with variation assignment logic
       #
       #
       # @param[String]          :user_id             The unique ID assigned to User
-      # @param[Hash]            :campaign            Campaign hash itslef
+      # @param[Hash]            :campaign            Campaign hash itself
+      # @param[String]          :campaign_key        The unique ID of the campaign passed
+      # @param[String]          :goal_identifier     The unique campaign's goal identifier
       # @return[String,String]                       ({variation_id, variation_name}|Nil): Tuple of
       #                                              variation_id and variation_name if variation allotted, else nil
 
-      def get_variation(user_id, campaign)
-        if campaign
-          campaign_key = campaign['key']
+      def get_variation(user_id, campaign, api_name, campaign_key, custom_variables = {}, variation_targeting_variables = {}, goal_identifier = '')
+        campaign_key ||= campaign['key']
+
+        return unless campaign
+
+        @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'])
+        }
+
+        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
+            )
+          )
         end
 
         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
+          if valid_string?(user_campaign_map['goal_identifier']) && api_name == ApiMethods::TRACK
+            variation['goal_identifier'] = user_campaign_map['goal_identifier']
+          end
+          @has_stored_variation = true
           @logger.log(
             LogLevelEnum::INFO,
             format(
@@ -73,13 +168,117 @@ class VWO
               variation_name: variation['name']
             )
           )
-          return variation['id'], variation['name']
+          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
+          return variation
+        else
+          @logger.log(
+            LogLevelEnum::DEBUG,
+            format(
+              LogMessageEnum::DebugMessages::NO_STORED_VARIATION,
+              file: FILE,
+              campaign_key: campaign_key,
+              user_id: user_id
+            )
+          )
+
+          if ([ApiMethods::TRACK, ApiMethods::GET_VARIATION_NAME, ApiMethods::GET_FEATURE_VARIABLE_VALUE].include? api_name) &&
+            @user_storage_service && campaign['type'] != CampaignTypes::FEATURE_ROLLOUT
+            @logger.log(
+              LogLevelEnum::DEBUG,
+              format(
+                LogMessageEnum::DebugMessages::CAMPAIGN_NOT_ACTIVATED,
+                file: FILE,
+                campaign_key: campaign_key,
+                user_id: user_id,
+                api_name: api_name
+              )
+            )
+
+            @logger.log(
+              LogLevelEnum::INFO,
+              format(
+                LogMessageEnum::InfoMessages::CAMPAIGN_NOT_ACTIVATED,
+                file: FILE,
+                campaign_key: campaign_key,
+                user_id: user_id,
+                api_name: api_name,
+                reason: api_name == ApiMethods::TRACK ? 'track it' : 'get the decision/value'
+              )
+            )
+            return
+          end
+        end
+
+        # Pre-segmentation
+
+        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
+              )
+            )
+            custom_variables = {}
+          end
+          unless @segment_evaluator.evaluate(campaign_key, user_id, segments, custom_variables)
+            @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
+              )
+            )
+            return
+          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_id, variation_name = get_variation_allotted(user_id, campaign)
+        variation = get_variation_allotted(user_id, campaign)
 
-        if variation_name
-          save_user_storage(user_id, campaign_key, variation_name) if variation_name
+        if variation && variation['name']
+          save_user_storage(user_id, campaign_key, variation['name'], goal_identifier) if variation['name']
 
           @logger.log(
             LogLevelEnum::INFO,
@@ -88,7 +287,8 @@ class VWO
               file: FILE,
               campaign_key: campaign_key,
               user_id: user_id,
-              variation_name: variation_name
+              variation_name: variation['name'],
+              campaign_type: campaign['type']
             )
           )
         else
@@ -97,39 +297,50 @@ class VWO
             format(LogMessageEnum::InfoMessages::NO_VARIATION_ALLOCATED, file: FILE, campaign_key: campaign_key, user_id: user_id)
           )
         end
-        [variation_id, 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
+        variation
       end
 
       # Returns the Variation Alloted for required campaign
       #
-      # @param[String]  :user_id      The unique ID assigned to User
+      # @param[String]  :user_id      The unique key assigned to User
       # @param[Hash]    :campaign     Campaign hash for Unique campaign key
       #
       # @return[Hash]
 
       def get_variation_allotted(user_id, campaign)
-        variation_id, variation_name = nil
         unless valid_value?(user_id)
           @logger.log(
             LogLevelEnum::ERROR,
             format(LogMessageEnum::ErrorMessages::INVALID_USER_ID, file: FILE, user_id: user_id, method: 'get_variation_alloted')
           )
-          return variation_id, variation_name
+          return
         end
 
         if @bucketer.user_part_of_campaign?(user_id, campaign)
-          variation_id, variation_name = get_variation_of_campaign_for_user(user_id, campaign)
+          variation = get_variation_of_campaign_for_user(user_id, campaign)
           @logger.log(
             LogLevelEnum::DEBUG,
             format(
               LogMessageEnum::DebugMessages::GOT_VARIATION_FOR_USER,
               file: FILE,
-              variation_name: variation_name,
+              variation_name: variation['name'],
               user_id: user_id,
               campaign_key: campaign['key'],
               method: 'get_variation_allotted'
             )
           )
+          variation
         else
           # not part of campaign
           @logger.log(
@@ -142,8 +353,8 @@ class VWO
               method: 'get_variation_allotted'
             )
           )
+          nil
         end
-        [variation_id, variation_name]
       end
 
       # Assigns variation to a particular user depending on the campaign PercentTraffic.
@@ -151,6 +362,7 @@ class VWO
       # @param[String]              :user_id      The unique ID assigned to a user
       # @param[Hash]                :campaign     The Campaign of which user is to be made a part of
       # @return[Hash]                         Variation allotted to User
+
       def get_variation_of_campaign_for_user(user_id, campaign)
         unless campaign
           @logger.log(
@@ -161,7 +373,7 @@ class VWO
               method: 'get_variation_of_campaign_for_user'
             )
           )
-          return nil, nil
+          return nil
         end
 
         variation = @bucketer.bucket_user_to_variation(user_id, campaign)
@@ -177,7 +389,7 @@ class VWO
               campaign_key: campaign['key']
             )
           )
-          return variation['id'], variation['name']
+          return variation
         end
 
         @logger.log(
@@ -189,11 +401,155 @@ class VWO
             campaign_key: campaign['key']
           )
         )
-        [nil, nil]
+        nil
+      end
+
+      # If UserStorageService is provided, save the assigned variation
+      #
+      # @param[String]              :user_id            Unique user identifier
+      # @param[String]              :campaign_key       Unique campaign identifier
+      # @param[String]              :variation_name     Variation identifier
+      # @param[String]              :goal_identifier    The unique campaign's goal identifier
+      # @return[Boolean]                                true if found otherwise false
+
+      def save_user_storage(user_id, campaign_key, variation_name, goal_identifier)
+        unless @user_storage_service
+          @logger.log(
+            LogLevelEnum::DEBUG,
+            format(LogMessageEnum::DebugMessages::NO_USER_STORAGE_SERVICE_SAVE, file: FILE)
+          )
+          return false
+        end
+        new_campaign_user_mapping = {}
+        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
+
+        @user_storage_service.set(new_campaign_user_mapping)
+
+        @logger.log(
+          LogLevelEnum::INFO,
+          format(LogMessageEnum::InfoMessages::SAVING_DATA_USER_STORAGE_SERVICE, file: FILE, user_id: user_id)
+        )
+        true
+      rescue StandardError
+        @logger.log(
+          LogLevelEnum::ERROR,
+          format(LogMessageEnum::ErrorMessages::SAVE_USER_STORAGE_SERVICE_FAILED, file: FILE, user_id: user_id)
+        )
+        false
       end
 
       private
 
+      # Evaluate all the variations in the campaign to find
+      #
+      # @param[String]  :user_id                            The unique key assigned to User
+      # @param[Hash]    :campaign                           Campaign hash for Unique campaign key
+      # @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
+      #
+      # @return[Hash]
+
+      def evaluate_whitelisting(user_id, campaign, api_name, campaign_key, variation_targeting_variables = {})
+        if variation_targeting_variables.nil?
+          variation_targeting_variables = { '_vwo_user_id' => user_id }
+        else
+          variation_targeting_variables['_vwo_user_id'] = user_id
+        end
+        targeted_variations = []
+
+        campaign['variations'].each do |variation|
+          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)
+              targeted_variations.push(variation)
+              status = StatusEnum::PASSED
+            else
+              status = StatusEnum::FAILED
+            end
+            @logger.log(
+              LogLevelEnum::DEBUG,
+              format(
+                LogMessageEnum::DebugMessages::SEGMENTATION_STATUS,
+                file: FILE,
+                campaign_key: campaign_key,
+                user_id: user_id,
+                status: status,
+                custom_variables: variation_targeting_variables,
+                variation_name: variation['name'],
+                segmentation_type: SegmentationTypeEnum::WHITELISTING,
+                api_name: api_name
+              )
+            )
+          else
+            @logger.log(
+              LogLevelEnum::DEBUG,
+              format(
+                LogMessageEnum::InfoMessages::SKIPPING_SEGMENTATION,
+                file: FILE,
+                campaign_key: campaign_key,
+                user_id: user_id,
+                api_name: api_name,
+                variation: variation['name']
+              )
+            )
+          end
+        end
+
+        if targeted_variations.length > 1
+          targeted_variations_deep_clone = Marshal.load(Marshal.dump(targeted_variations))
+          scale_variation_weights(targeted_variations_deep_clone)
+          current_allocation = 0
+          targeted_variations_deep_clone.each do |variation|
+            step_factor = get_variation_bucketing_range(variation['weight'])
+            if step_factor > 0
+              start_range = current_allocation + 1
+              end_range = current_allocation + step_factor
+              variation['start_variation_allocation'] = start_range
+              variation['end_variation_allocation'] = end_range
+              current_allocation += step_factor
+            else
+              variation['start_variation_allocation'] = -1
+              variation['end_variation_allocation'] = -1
+            end
+          end
+          whitelisted_variation = @bucketer.get_variation(
+            targeted_variations_deep_clone,
+            @bucketer.get_bucket_value_for_user(
+              user_id
+            )
+          )
+        else
+          whitelisted_variation = targeted_variations[0]
+        end
+        whitelisted_variation
+      end
+
+      # It extracts the weights from all the variations inside the campaign
+      # and scales them so that the total sum of eligible variations' weights become 100%
+      #
+      # 1. variations
+
+      def scale_variation_weights(variations)
+        total_weight = variations.reduce(0) { |final_weight, variation| final_weight + variation['weight'].to_f }
+        if total_weight == 0
+          weight = 100 / variations.length
+          variations.each do |variation|
+            variation['weight'] = weight
+          end
+        else
+          variations.each do |variation|
+            variation['weight'] = (variation['weight'] / total_weight) * 100
+          end
+        end
+      end
+
       # Get the UserStorageData after looking up into get method
       # Being provided via UserStorageService
       #
@@ -238,70 +594,25 @@ class VWO
       # @return[Object, nil]      if found then variation settings object otherwise None
 
       def get_stored_variation(user_id, campaign_key, user_campaign_map)
-        if user_campaign_map[campaign_key] == campaign_key
-          variation_name = user_campaign_map[:variationName]
-          @logger.log(
-            LogLevelEnum::DEBUG,
-            format(
-              LogMessageEnum::DebugMessages::GETTING_STORED_VARIATION,
-              file: FILE,
-              campaign_key: campaign_key,
-              user_id: user_id,
-              variation_name: variation_name
-            )
-          )
-          return get_campaign_variation(
-            @settings_file,
-            campaign_key,
-            variation_name
-          )
-        end
+        return unless user_campaign_map['campaign_key'] == campaign_key
 
+        variation_name = user_campaign_map['variation_name']
         @logger.log(
           LogLevelEnum::DEBUG,
           format(
-            LogMessageEnum::DebugMessages::NO_STORED_VARIATION,
+            LogMessageEnum::DebugMessages::GETTING_STORED_VARIATION,
             file: FILE,
             campaign_key: campaign_key,
-            user_id: user_id
+            user_id: user_id,
+            variation_name: variation_name
           )
         )
-        nil
-      end
 
-      # If UserStorageService is provided, save the assigned variation
-      #
-      # @param[String]              :user_id            Unique user identifier
-      # @param[String]              :campaign_key       Unique campaign identifier
-      # @param[String]              :variation_name     Variation identifier
-      # @return[Boolean]                                true if found otherwise false
-
-      def save_user_storage(user_id, campaign_key, variation_name)
-        unless @user_storage_service
-          @logger.log(
-            LogLevelEnum::DEBUG,
-            format(LogMessageEnum::DebugMessages::NO_USER_STORAGE_SERVICE_SAVE, file: FILE)
-          )
-          return false
-        end
-        new_campaign_user_mapping = {}
-        new_campaign_user_mapping['campaign_key'] = campaign_key
-        new_campaign_user_mapping['user_id'] = user_id
-        new_campaign_user_mapping['variation_name'] = variation_name
-
-        @user_storage_service.set(new_campaign_user_mapping)
-
-        @logger.log(
-          LogLevelEnum::INFO,
-          format(LogMessageEnum::InfoMessages::SAVING_DATA_USER_STORAGE_SERVICE, file: FILE, user_id: user_id)
-        )
-        true
-      rescue StandardError
-        @logger.log(
-          LogLevelEnum::ERROR,
-          format(LogMessageEnum::ErrorMessages::SAVE_USER_STORAGE_SERVICE_FAILED, file: FILE, user_id: user_id)
+        get_campaign_variation(
+          @settings_file,
+          campaign_key,
+          variation_name
         )
-        false
       end
     end
   end