wingify-fme-ruby-sdk 1.50.0

data/lib/wingify/utils/campaign_util.rb

@@ -0,0 +1,284 @@
+# Copyright 2024-2026 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.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require_relative '../constants/constants'
+require_relative '../enums/campaign_type_enum'
+require_relative '../models/campaign/campaign_model'
+require_relative '../models/campaign/feature_model'
+require_relative '../models/campaign/variation_model'
+require_relative '../models/settings/settings_model'
+require_relative '../services/logger_service'
+require_relative '../enums/log_level_enum'
+require_relative '../models/campaign/rule_model'
+
+module CampaignUtil
+  # Sets the variation allocation for a campaign
+  # @param campaign [CampaignModel] The campaign to set the variation allocation for
+  def self.set_variation_allocation(campaign)
+    if [CampaignTypeEnum::ROLLOUT, CampaignTypeEnum::PERSONALIZE].include?(campaign.get_type)
+      handle_rollout_campaign(campaign)
+    else
+      current_allocation = 0
+      campaign.get_variations.each do |variation|
+        step_factor = assign_range_values(variation, current_allocation)
+        current_allocation += step_factor
+
+        LoggerService.log(LogLevelEnum::INFO, "VARIATION_RANGE_ALLOCATION", {
+          variationKey: variation.get_key,
+          campaignKey: campaign.get_key,
+          variationWeight: variation.get_weight,
+          startRange: variation.get_start_range_variation,
+          endRange: variation.get_end_range_variation
+        })
+      end
+    end
+  end
+
+  # Assigns start and end range values to a variation
+  # @param variation [VariationModel] The variation to assign the start and end range values to
+  # @param current_allocation [Integer] The current allocation
+  # @return [Integer] The step factor
+  def self.assign_range_values(variation, current_allocation)
+    step_factor = get_variation_bucket_range(variation.get_weight)
+
+    if step_factor > 0
+      variation.set_start_range(current_allocation + 1)
+      variation.set_end_range(current_allocation + step_factor)
+    else
+      variation.set_start_range(-1)
+      variation.set_end_range(-1)
+    end
+
+    step_factor
+  end
+
+  # Scales variation weights to sum up to 100%
+  # @param variations [Array<VariationModel>] The variations to scale the weights of
+  # @return [Array<VariationModel>] The scaled variations
+  def self.scale_variation_weights(variations)
+    total_weight = variations.sum(&:weight)
+
+    if total_weight.zero?
+      equal_weight = 100.0 / variations.length
+      variations.each { |variation| variation.weight = equal_weight }
+    else
+      variations.each { |variation| variation.weight = (variation.weight / total_weight) * 100 }
+    end
+  end
+
+  # Generates a bucketing seed based on user ID and campaign
+  # @param user_id [String] The ID of the user
+  # @param campaign [CampaignModel] The campaign to generate the bucketing seed for
+  # @param group_id [String] The ID of the group
+  # @return [String] The bucketing seed
+  def self.get_bucketing_seed(user_id, campaign, group_id = nil)
+    return "#{group_id}_#{user_id}" if group_id
+
+    is_rollout_or_personalize = [CampaignTypeEnum::ROLLOUT, CampaignTypeEnum::PERSONALIZE].include?(campaign.get_type)
+    salt = is_rollout_or_personalize ? campaign.get_variations.first.get_salt : campaign.get_salt
+
+    salt ? "#{salt}_#{user_id}" : "#{campaign.get_id}_#{user_id}"
+  end
+
+  # Retrieves variation from campaign key
+  # @param settings [SettingsModel] The settings for the VWO instance
+  # @param campaign_key [String] The key of the campaign
+  # @param variation_id [Integer] The ID of the variation
+  # @return [VariationModel] The variation
+  def self.get_variation_from_campaign_key(settings, campaign_key, variation_id)
+    campaign = settings.get_campaigns.find { |c| c.get_key == campaign_key }
+    return nil unless campaign
+
+    variation = campaign.get_variations.find { |v| v.get_id == variation_id }
+    variation ? VariationModel.new.model_from_dictionary(variation) : nil
+  end
+
+  # Sets campaign allocation ranges
+  # @param campaigns [Array<CampaignModel>] The campaigns to set the allocation ranges for
+  def self.set_campaign_allocation(campaigns)
+    current_allocation = 0
+
+    campaigns.each do |campaign|
+      step_factor = assign_range_values_meg(campaign, current_allocation)
+      current_allocation += step_factor
+    end
+  end
+
+  # Retrieves campaign group details if part of a group
+  # @param settings [SettingsModel] The settings for the VWO instance
+  # @param campaign_id [Integer] The ID of the campaign
+  # @param variation_id [Integer] The ID of the variation
+  # @return [Hash] The group details
+  def self.get_group_details_if_campaign_part_of_it(settings, campaign_id, variation_id = nil)
+    campaign_to_check = variation_id ? "#{campaign_id}_#{variation_id}" : campaign_id.to_s
+
+    if settings.get_campaign_groups.key?(campaign_to_check)
+      group_id = settings.get_campaign_groups[campaign_to_check]
+      { group_id: group_id, group_name: settings.get_groups[group_id.to_s][:name.to_s]}
+    else
+      {}
+    end
+  end
+
+  # Finds groups associated with a feature
+  # @param settings [SettingsModel] The settings for the VWO instance
+  # @param feature_key [String] The key of the feature
+  # @return [Array] The groups associated with the feature
+  def self.find_groups_feature_part_of(settings, feature_key)
+    rule_array = []
+    settings.get_features.each do |feature|
+      if feature.get_key == feature_key
+        rule_array.concat(feature.get_rules)
+      end
+    end
+
+    groups = []
+    rule_array.each do |rule|
+      group = get_group_details_if_campaign_part_of_it(settings, rule.get_campaign_id, rule.get_type == CampaignTypeEnum::PERSONALIZE ? rule.get_variation_id : nil)
+      groups << group unless group.empty? || groups.any? { |g| g[:group_id] == group[:group_id] }
+    end
+
+    groups
+  end
+
+  # Retrieves campaigns by group ID
+  # @param settings [SettingsModel] The settings for the VWO instance
+  # @param group_id [String] The ID of the group
+  # @return [Array] The campaigns associated with the group
+  def self.get_campaigns_by_group_id(settings, group_id)
+    settings.get_groups[group_id.to_s]&.fetch(:campaigns.to_s, []) || []
+  end
+
+  # Retrieves feature keys from campaign IDs
+  # @param settings [SettingsModel] The settings for the VWO instance
+  # @param campaign_ids [Array] The IDs of the campaigns
+  # @return [Array] The feature keys associated with the campaigns
+  def self.get_feature_keys_from_campaign_ids(settings, campaign_ids)
+    feature_keys = []
+
+    campaign_ids.each do |campaign|
+      campaign_id, variation_id = campaign.split('_').map(&:to_i)
+
+      settings.get_features.each do |feature|
+        next if feature_keys.include?(feature.get_key)
+
+        feature.get_rules.each do |rule|
+          if rule.get_campaign_id == campaign_id
+            feature_keys << feature.get_key if variation_id.nil? || rule.get_variation_id == variation_id
+          end
+        end
+      end
+    end
+
+    feature_keys
+  end
+
+  # Retrieves campaign IDs from a feature key
+  # @param settings [SettingsModel] The settings for the VWO instance
+  # @param feature_key [String] The key of the feature
+  # @return [Array] The campaign IDs associated with the feature
+  def self.get_campaign_ids_from_feature_key(settings, feature_key)
+    settings.get_features.each do |feature|
+      return feature.get_rules.map(&:get_campaign_id) if feature.get_key == feature_key
+    end
+    []
+  end
+
+  # Assigns range values to a MEG campaign
+  # @param data [VariationModel] The variation to assign the start and end range values to
+  # @param current_allocation [Integer] The current allocation
+  # @return [Integer] The step factor
+  def self.assign_range_values_meg(data, current_allocation)
+    step_factor = get_variation_bucket_range(data.weight)
+
+    if step_factor > 0
+      data.start_range_variation = current_allocation + 1
+      data.end_range_variation = current_allocation + step_factor
+    else
+      data.start_range_variation = -1
+      data.end_range_variation = -1
+    end
+
+    step_factor
+  end
+
+  # Retrieves the rule type for a given campaign ID from a feature
+  def self.get_rule_type_using_campaign_id_from_feature(feature, campaign_id)
+    rule = feature.get_rules.find { |r| r.get_campaign_id == campaign_id }
+    rule ? rule.get_type : ''
+  end
+
+  # Calculates bucket range for a variation
+  # @param variation_weight [Float] The weight of the variation
+  # @return [Integer] The bucket range
+  def self.get_variation_bucket_range(variation_weight)
+    return 0 unless variation_weight && variation_weight.positive?
+
+    start_range = (variation_weight * 100).ceil
+    [start_range, Constants::MAX_TRAFFIC_VALUE].min
+  end
+
+  # Handles rollout campaign logic
+  # @param campaign [CampaignModel] The campaign to handle the rollout logic for
+  def self.handle_rollout_campaign(campaign)
+    campaign.get_variations.each do |variation|
+      end_range = variation.get_weight * 100
+      variation.set_start_range(1)
+      variation.set_end_range(end_range)
+
+      LoggerService.log(LogLevelEnum::INFO, "VARIATION_RANGE_ALLOCATION", {
+        variationKey: variation.get_key,
+        campaignKey: campaign.get_key,
+        variationWeight: variation.get_weight,
+        startRange: 1,
+        endRange: end_range
+      })
+    end
+  end
+
+  # Retrieves the campaign key from the campaign ID
+  # @param settings [SettingsModel] The settings for the VWO instance
+  # @param campaign_id [Integer] The ID of the campaign
+  # @return [String] The campaign key
+  def self.get_campaign_key_from_campaign_id(settings, campaign_id)
+    settings.get_campaigns.each do |campaign|
+      return campaign.get_key if campaign.get_id == campaign_id
+    end
+    nil
+  end
+
+  # Retrieves the variation name from the campaign ID and variation ID
+  # @param settings [SettingsModel] The settings for the VWO instance
+  # @param campaign_id [Integer] The ID of the campaign
+  # @param variation_id [Integer] The ID of the variation
+  # @return [String] The variation name
+  def self.get_variation_name_from_campaign_id_and_variation_id(settings, campaign_id, variation_id)
+    campaign = settings.get_campaigns.find { |c| c.get_id == campaign_id }
+    return nil unless campaign
+
+    variation = campaign.get_variations.find { |v| v.get_id == variation_id }
+    variation ? variation.get_key : nil
+  end
+
+  # Retrieves the campaign type from the campaign ID
+  # @param settings [SettingsModel] The settings for the VWO instance
+  # @param campaign_id [Integer] The ID of the campaign
+  # @return [String] The campaign type
+  def self.get_campaign_type_from_campaign_id(settings, campaign_id)
+    campaign = settings.get_campaigns.find { |c| c.get_id == campaign_id }
+    return nil unless campaign
+
+    campaign.get_type
+  end
+end

data/lib/wingify/utils/data_type_util.rb

@@ -0,0 +1,105 @@
+# Copyright 2024-2026 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.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module DataTypeUtil
+    # Checks if the value is a Hash (object in JS)
+    def self.is_object(val)
+      val.is_a?(Hash)
+    end
+  
+    # Checks if the value is an Array
+    def self.is_array(val)
+      val.is_a?(Array)
+    end
+  
+    # Checks if the value is nil
+    def self.is_null(val)
+      val.nil?
+    end
+  
+    # Checks if the value is undefined (not applicable in Ruby, so return false)
+    def self.is_undefined(val)
+      false
+    end
+  
+    # Checks if the value is defined (not nil)
+    def self.is_defined(val)
+      !val.nil?
+    end
+  
+    # Checks if the value is a Number (including NaN)
+    def self.is_number(val)
+      val.is_a?(Numeric)
+    end
+  
+    # Checks if the value is a String
+    def self.is_string(val)
+      val.is_a?(String)
+    end
+  
+    # Checks if the value is a Boolean
+    def self.is_boolean(val)
+      val.is_a?(TrueClass) || val.is_a?(FalseClass)
+    end
+  
+    # Checks if the value is NaN (only applicable for Float in Ruby)
+    def self.is_nan(val)
+      val.is_a?(Float) && val.nan?
+    end
+  
+    # Checks if the value is a Date
+    def self.is_date(val)
+      val.is_a?(Date) || val.is_a?(Time) || val.is_a?(DateTime)
+    end
+  
+    # Checks if the value is a Function (Proc or Lambda in Ruby)
+    def self.is_function(val)
+      val.is_a?(Proc) || val.is_a?(Method)
+    end
+  
+    # Checks if the value is a Regular Expression
+    def self.is_regex(val)
+      val.is_a?(Regexp)
+    end
+  
+    # Determines the type of the given value
+    def self.get_type(val)
+      case
+      when is_object(val)
+        "Object"
+      when is_array(val)
+        "Array"
+      when is_null(val)
+        "Null"
+      when is_undefined(val)
+        "Undefined"
+      when is_nan(val)
+        "NaN"
+      when is_number(val)
+        "Number"
+      when is_string(val)
+        "String"
+      when is_boolean(val)
+        "Boolean"
+      when is_date(val)
+        "Date"
+      when is_regex(val)
+        "Regex"
+      when is_function(val)
+        "Function"
+      else
+        "Unknown Type"
+      end
+    end
+  end

data/lib/wingify/utils/debugger_service_util.rb

@@ -0,0 +1,40 @@
+# Copyright 2024-2026 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.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require_relative '../services/logger_service'
+require_relative '../enums/log_level_enum'
+require_relative '../utils/network_util'
+require_relative '../services/batch_event_queue'
+require_relative '../enums/event_enum'
+
+class DebuggerServiceUtil
+  class << self
+    def send_debugger_event(event_props)
+      # get base properties for the event
+      properties = NetworkUtil.get_events_base_properties(EventEnum::DEBUGGER_EVENT)
+
+      # get debugger event payload
+      payload = NetworkUtil.get_debugger_event_payload(event_props)
+
+      # send event
+      if BatchEventsQueue.instance
+        # add the payload to the batch events queue
+        BatchEventsQueue.instance.enqueue(payload)
+      else
+        # Send the prepared payload via POST API request
+        NetworkUtil.send_event(properties, payload)
+      end
+    end
+  end
+end

data/lib/wingify/utils/decision_util.rb

@@ -0,0 +1,259 @@
+# Copyright 2024-2026 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.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require_relative '../enums/campaign_type_enum'
+require_relative '../enums/status_enum'
+require_relative '../models/campaign/campaign_model'
+require_relative '../models/campaign/feature_model'
+require_relative '../models/campaign/variation_model'
+require_relative '../models/settings/settings_model'
+require_relative '../models/user/context_model'
+require_relative '../packages/decision_maker/decision_maker'
+require_relative '../packages/segmentation_evaluator/core/segmentation_manager'
+require_relative '../services/campaign_decision_service'
+require_relative '../services/storage_service'
+require_relative '../utils/data_type_util'
+require_relative '../constants/constants'
+require_relative '../utils/campaign_util'
+require_relative '../utils/function_util'
+require_relative '../utils/meg_util'
+require_relative '../utils/uuid_util'
+require_relative '../decorators/storage_decorator'
+require_relative '../services/logger_service'
+require_relative '../enums/log_level_enum'
+
+class DecisionUtil
+  # Check if the campaign satisfies whitelisting and pre-segmentation
+  # @param settings [SettingsModel] The settings for the VWO instance
+  # @param feature [FeatureModel] The feature to evaluate
+  # @param campaign [CampaignModel] The campaign to evaluate
+  # @param context [ContextModel] The context for the evaluation
+  # @param evaluated_feature_map [Hash] The map of evaluated features
+  # @param meg_group_winner_campaigns [Hash] The map of MEG group winner campaigns
+  def self.check_whitelisting_and_pre_seg(settings, feature, campaign, context, evaluated_feature_map, meg_group_winner_campaigns, storage_service, decision)
+    vwo_user_id = UUIDUtil.get_uuid(context.get_id, settings.get_account_id)
+    campaign_id = campaign.get_id
+
+    if campaign.get_type == CampaignTypeEnum::AB
+      # Set _vwoUserId for variation targeting variables
+      variation_targeting_vars = context.get_variation_targeting_variables || {}
+      variation_targeting_vars["_vwoUserId"] = campaign.get_is_user_list_enabled ? vwo_user_id : context.get_id
+      context.set_variation_targeting_variables(variation_targeting_vars)
+      decision[:variation_targeting_variables] = variation_targeting_vars
+
+      # Check for whitelisting
+      if campaign.get_is_forced_variation_enabled
+        whitelisted_variation = check_campaign_whitelisting(campaign, context)
+        return [true, whitelisted_variation] if whitelisted_variation && !whitelisted_variation.empty?
+      else
+        LoggerService.log(LogLevelEnum::INFO, "WHITELISTING_SKIP", {
+          campaignKey: campaign.get_rule_key,
+          userId: context.get_id
+        })
+      end
+    end
+
+    # User list segment check for campaign pre-segmentation
+    custom_vars = context.get_custom_variables || {}
+    custom_vars["_vwoUserId"] = campaign.get_is_user_list_enabled ? vwo_user_id : context.get_id
+    context.set_custom_variables(custom_vars)
+    decision[:custom_variables] = custom_vars
+
+    # Check if rule belongs to Mutually Exclusive Group (MEG)
+    group_details = CampaignUtil.get_group_details_if_campaign_part_of_it(settings, campaign_id, campaign.get_type == CampaignTypeEnum::PERSONALIZE ? campaign.get_variations[0].get_id : nil)
+    group_id = group_details[:group_id]
+
+    # Check if the group has already been evaluated
+    group_winner_campaign_id = meg_group_winner_campaigns[group_id] if meg_group_winner_campaigns && meg_group_winner_campaigns.key?(group_id)
+    return evaluate_meg_campaign(group_winner_campaign_id, campaign, context, meg_group_winner_campaigns, group_id) if group_winner_campaign_id
+
+    # Check in storage if the group was already evaluated
+    stored_data = StorageDecorator.new.get_feature_from_storage("#{Constants::VWO_META_MEG_KEY}#{group_id}", context, storage_service)
+    if stored_data && stored_data[:experiment_key] && stored_data[:experiment_id]
+      LoggerService.log(LogLevelEnum::INFO, "MEG_CAMPAIGN_FOUND_IN_STORAGE", {
+        campaignKey: stored_data[:experiment_key],
+        userId: context.get_id
+      })
+
+      if stored_data[:experiment_id] == campaign_id
+        return evaluate_meg_personalization(campaign, stored_data, meg_group_winner_campaigns, group_id)
+      end
+      meg_group_winner_campaigns[group_id] = stored_data[:experiment_variation_id] != -1 ? "#{stored_data[:experiment_id]}_#{stored_data[:experiment_variation_id]}" : stored_data[:experiment_id]
+      return [false, nil]
+    end
+
+    # Pre-segmentation check
+    pre_segmentation_passed = CampaignDecisionService.new.get_pre_segmentation_decision(campaign, context)
+
+    if pre_segmentation_passed && group_id
+      winner_campaign = evaluate_groups(settings, feature, group_id, evaluated_feature_map, context, storage_service)
+      return evaluate_meg_campaign_winner(winner_campaign, campaign, context, meg_group_winner_campaigns, group_id)
+    end
+
+    [pre_segmentation_passed, nil]
+  end
+
+  # Evaluate the MEG campaign
+  # @param group_winner_campaign_id [String] The ID of the MEG group winner campaign
+  # @param campaign [CampaignModel] The campaign to evaluate
+  # @param context [ContextModel] The context for the evaluation
+  # @param meg_group_winner_campaigns [Hash] The map of MEG group winner campaigns
+  # @param group_id [String] The ID of the MEG group
+  def self.evaluate_meg_campaign(group_winner_campaign_id, campaign, context, meg_group_winner_campaigns, group_id)
+    if campaign.get_type == CampaignTypeEnum::AB && group_winner_campaign_id == campaign.get_id
+      return [true, nil]
+    elsif campaign.get_type == CampaignTypeEnum::PERSONALIZE && group_winner_campaign_id == "#{campaign.get_id}_#{campaign.get_variations[0].get_id}"
+      return [true, nil]
+    end
+    [false, nil]
+  end
+
+  def self.evaluate_meg_personalization(campaign, stored_data, meg_group_winner_campaigns, group_id)
+    if campaign.get_type == CampaignTypeEnum::PERSONALIZE
+      if stored_data[:experiment_variation_id] == campaign.get_variations[0].get_id
+        return [true, nil]
+      else
+        meg_group_winner_campaigns[group_id] = "#{stored_data[:experiment_id]}_#{stored_data[:experiment_variation_id]}"
+        return [false, nil]
+      end
+    else
+      return [true, nil]
+    end
+  end
+
+  # Evaluate the MEG campaign winner
+  # @param winner_campaign [CampaignModel] The winner campaign
+  # @param campaign [CampaignModel] The campaign to evaluate
+  # @param context [ContextModel] The context for the evaluation
+  # @param meg_group_winner_campaigns [Hash] The map of MEG group winner campaigns
+  # @param group_id [String] The ID of the MEG group
+  def self.evaluate_meg_campaign_winner(winner_campaign, campaign, context, meg_group_winner_campaigns, group_id)
+    if winner_campaign && winner_campaign.get_id == campaign.get_id
+      if winner_campaign.get_type == CampaignTypeEnum::AB
+        return [true, nil]
+      else
+        # if personalise then check if the requested variation is the winner
+        if winner_campaign.get_variations[0].get_id == campaign.get_variations[0].get_id
+          return [true, nil]
+        else
+          meg_group_winner_campaigns[group_id] = "#{winner_campaign.get_id}_#{winner_campaign.get_variations[0].get_id}"
+          return [false, nil]
+        end
+      end
+    elsif winner_campaign
+      if winner_campaign.get_type == CampaignTypeEnum::AB
+        meg_group_winner_campaigns[group_id] = winner_campaign.get_id
+      else
+        meg_group_winner_campaigns[group_id] = "#{winner_campaign.get_id}_#{winner_campaign.get_variations[0].get_id}"
+      end
+      return [false, nil]
+    end
+    
+    meg_group_winner_campaigns[group_id] = -1
+    [false, nil]
+  end
+
+  # Evaluate the traffic and get the variation
+  # @param settings [SettingsModel] The settings for the VWO instance
+  # @param campaign [CampaignModel] The campaign to evaluate
+  # @param user_id [String] The ID of the user
+  def self.evaluate_traffic_and_get_variation(settings, campaign, context)
+    variation = CampaignDecisionService.new.get_variation_alloted(context, settings.get_account_id, campaign)
+
+    user_id = context.get_id
+    bucketing_seed = context.get_bucketing_seed
+    bucketing_id = bucketing_seed || user_id
+    display_user_id = bucketing_id != user_id ? "#{user_id} (Seed: #{bucketing_id})" : user_id
+
+    if variation.nil?
+      LoggerService.log(LogLevelEnum::INFO, "USER_CAMPAIGN_BUCKET_INFO", {
+        campaignKey: campaign.get_type == CampaignTypeEnum::AB ? campaign.get_key : "#{campaign.get_name}_#{campaign.get_rule_key}",
+        userId: display_user_id,
+        status: 'did not get any variation'
+      })
+      return nil
+    end
+    LoggerService.log(LogLevelEnum::INFO, "USER_CAMPAIGN_BUCKET_INFO", {
+      campaignKey: campaign.get_type == CampaignTypeEnum::AB ? campaign.get_key : "#{campaign.get_name}_#{campaign.get_rule_key}",
+      userId: display_user_id,
+      status: "got variation: #{variation.get_key}"
+    })
+    variation
+  end
+
+  # Check if the campaign satisfies whitelisting
+  # @param campaign [CampaignModel] The campaign to evaluate
+  # @param context [ContextModel] The context for the evaluation
+  def self.check_campaign_whitelisting(campaign, context)
+    # Check if the campaign satisfies whitelisting
+    whitelisting_result = evaluate_whitelisting(campaign, context)
+    status = whitelisting_result ? StatusEnum::PASSED : StatusEnum::FAILED
+    variation_string = whitelisting_result ? whitelisting_result[:variation].get_key : ''
+
+    LoggerService.log(LogLevelEnum::INFO, "WHITELISTING_STATUS", {
+      userId: context.get_id,
+      campaignKey: campaign.get_type == CampaignTypeEnum::AB ? campaign.get_key : "#{campaign.get_name}_#{campaign.get_rule_key}",
+      status: status,
+      variationString: variation_string
+    })
+
+    whitelisting_result
+  end
+
+  # Evaluate the whitelisting
+  # @param campaign [CampaignModel] The campaign to evaluate
+  # @param context [ContextModel] The context for the evaluation
+  def self.evaluate_whitelisting(campaign, context)
+    targeted_variations = []
+    
+    campaign.get_variations.each do |variation|
+      next if DataTypeUtil.is_object(variation.get_segments) && variation.get_segments.empty?
+      if DataTypeUtil.is_object(variation.get_segments)
+        segmentation_result = SegmentationManager.instance.validate_segmentation(
+          variation.get_segments,
+          context.get_variation_targeting_variables
+        )
+
+        targeted_variations.push(clone_object(variation)) if segmentation_result
+      end
+    end
+
+    # Determine the whitelisted variation
+    whitelisted_variation = nil
+    if targeted_variations.length > 1
+      scale_variation_weights(targeted_variations)
+      current_allocation = 0
+
+      targeted_variations.each do |variation|
+        step_factor = assign_range_values(variation, current_allocation)
+        current_allocation += step_factor
+      end
+
+      whitelisted_variation = CampaignDecisionService.new.get_variation(
+        targeted_variations,
+        DecisionMaker.new.calculate_bucket_value(CampaignUtil.get_bucketing_seed(context.get_bucketing_seed || context.get_id, campaign, nil))
+      )
+    else
+      whitelisted_variation = targeted_variations.first
+    end
+
+    return nil unless whitelisted_variation
+
+    {
+      variation: whitelisted_variation,
+      variation_name: whitelisted_variation.get_key,
+      variation_id: whitelisted_variation.get_id
+    }
+  end
+end