vwo-sdk 1.36.0 → 1.37.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -33,7 +33,7 @@ class VWO
33
33
  include VWO::CONSTANTS
34
34
  include VWO::Utils::UUID
35
35
 
36
- FILE = FileNameEnum::VariationDecider
36
+ FILE = FileNameEnum::VARIATION_DECIDER
37
37
 
38
38
  # Initializes various services
39
39
  # @param[Hash] - Settings file
@@ -66,43 +66,17 @@ class VWO
66
66
 
67
67
  return unless campaign
68
68
 
69
- is_campaign_part_of_group = @settings_file && is_part_of_group(@settings_file, campaign["id"])
69
+ is_campaign_part_of_group = @settings_file && part_of_group?(@settings_file, campaign['id'])
70
70
 
71
71
  @has_stored_variation = false
72
- decision = {
73
- :campaign_id => campaign['id'],
74
- :campaign_key => campaign_key,
75
- :campaign_type => campaign['type'],
76
- # campaign segmentation conditions
77
- :custom_variables => custom_variables,
78
- # event name
79
- :event => Hooks::DECISION_TYPES['CAMPAIGN_DECISION'],
80
- # goal tracked in case of track API
81
- :goal_identifier => goal_identifier,
82
- # campaign whitelisting flag
83
- :is_forced_variation_enabled => campaign['isForcedVariationEnabled'] ? campaign['isForcedVariationEnabled'] : false,
84
- :sdk_version => SDK_VERSION,
85
- # API name which triggered the event
86
- :source => api_name,
87
- # Passed in API
88
- :user_id => user_id,
89
- # Campaign Whitelisting conditions
90
- :variation_targeting_variables => variation_targeting_variables,
91
- :is_user_whitelisted => false,
92
- :from_user_storage_service => false,
93
- :is_feature_enabled => true,
94
- # VWO generated UUID based on passed UserId and Account ID
95
- :vwo_user_id => generator_for(user_id, @settings_file['accountId'])
96
- }
72
+ decision = initialize_decision_properties(user_id, campaign, api_name, custom_variables, variation_targeting_variables, goal_identifier)
97
73
 
98
- if campaign.has_key?("name")
99
- decision[:campaign_name] = campaign['name']
100
- end
74
+ decision[:campaign_name] = campaign['name'] if campaign.key?('name')
101
75
 
102
76
  if is_campaign_part_of_group
103
- group_id = @settings_file["campaignGroups"][campaign["id"].to_s]
77
+ group_id = @settings_file['campaignGroups'][campaign['id'].to_s]
104
78
  decision[:group_id] = group_id
105
- group_name = @settings_file["groups"][group_id.to_s]["name"]
79
+ group_name = @settings_file['groups'][group_id.to_s]['name']
106
80
  decision[:group_name] = group_name
107
81
  end
108
82
 
@@ -110,21 +84,17 @@ class VWO
110
84
  variation = get_variation_if_whitelisting_passed(user_id, campaign, variation_targeting_variables, api_name, decision, true)
111
85
  return variation if variation && variation['name']
112
86
 
113
- if campaign.has_key?("isAlwaysCheckSegment")
114
- is_presegmentation = check_presegmentation(campaign, user_id, custom_variables, api_name)
115
- return get_variationIfPreSegmentation_applied(is_presegmentation, campaign, user_id, goal_identifier, decision)
87
+ if campaign.key?('isAlwaysCheckSegment')
88
+ is_presegmentation = presegmentation?(campaign, user_id, custom_variables, api_name)
89
+ return get_variation_if_presegmentation_applied(is_presegmentation, campaign, user_id, goal_identifier, decision)
116
90
  else
117
91
  user_campaign_map = get_user_storage(user_id, campaign_key)
118
92
  variation = get_stored_variation(user_id, campaign_key, user_campaign_map) if valid_hash?(user_campaign_map)
119
93
 
94
+ variation = variation.dup if variation # deep copy
95
+
120
96
  if variation
121
- variation = variation.dup # deep copy
122
- end
123
-
124
- if variation
125
- if valid_string?(user_campaign_map['goal_identifier']) && api_name == ApiMethods::TRACK
126
- variation['goal_identifier'] = user_campaign_map['goal_identifier']
127
- end
97
+ variation['goal_identifier'] = user_campaign_map['goal_identifier'] if valid_string?(user_campaign_map['goal_identifier']) && api_name == ApiMethods::TRACK
128
98
  @has_stored_variation = true
129
99
  @logger.log(
130
100
  LogLevelEnum::INFO,
@@ -137,16 +107,8 @@ class VWO
137
107
  }
138
108
  )
139
109
  decision[:from_user_storage_service] = !!variation['name']
140
- if variation
141
- if campaign['type'] == CampaignTypes::VISUAL_AB || campaign['type'] == CampaignTypes::FEATURE_TEST
142
- decision[:variation_name] = variation['name']
143
- decision[:variation_id] = variation['id']
144
- if campaign['type'] == CampaignTypes::FEATURE_TEST
145
- decision[:is_feature_enabled] = variation['isFeatureEnabled']
146
- end
147
- end
148
- @hooks_manager.execute(decision)
149
- end
110
+ decision = add_variation_to_decision_properties(decision, campaign, variation)
111
+ @hooks_manager.execute(decision)
150
112
  return variation
151
113
  else
152
114
  @logger.log(
@@ -158,48 +120,20 @@ class VWO
158
120
  '{userId}' => user_id
159
121
  }
160
122
  )
161
-
162
- if ([ApiMethods::TRACK, ApiMethods::GET_VARIATION_NAME, ApiMethods::GET_FEATURE_VARIABLE_VALUE].include? api_name) && @user_storage_service
163
- @logger.log(
164
- LogLevelEnum::WARNING,
165
- 'CAMPAIGN_NOT_ACTIVATED',
166
- {
167
- '{file}' => FILE,
168
- '{campaignKey}' => campaign_key,
169
- '{userId}' => user_id,
170
- '{api}' => api_name
171
- }
172
- )
173
-
174
- @logger.log(
175
- LogLevelEnum::INFO,
176
- 'CAMPAIGN_NOT_ACTIVATED',
177
- {
178
- '{file}' => FILE,
179
- '{campaignKey}' => campaign_key,
180
- '{userId}' => user_id,
181
- '{reason}' => api_name == ApiMethods::TRACK ? 'track it' : 'get the decision/value'
182
- }
183
- )
184
- return
185
- end
123
+
124
+ return if campaign_not_activated?(user_id, campaign_key, api_name)
186
125
  end
187
126
  end
188
127
 
189
-
190
-
191
128
  # Pre-segmentation
192
- is_presegmentation = check_presegmentation(campaign, user_id, custom_variables, api_name)
129
+ is_presegmentation = presegmentation?(campaign, user_id, custom_variables, api_name)
193
130
  is_presegmentation_and_traffic_passed = is_presegmentation && @bucketer.user_part_of_campaign?(user_id, campaign)
194
- unless is_presegmentation_and_traffic_passed
195
- return nil
196
- end
131
+ return nil unless is_presegmentation_and_traffic_passed
197
132
 
198
133
  if is_presegmentation_and_traffic_passed && is_campaign_part_of_group
199
134
  group_campaigns = get_group_campaigns(@settings_file, group_id)
200
135
  if group_campaigns
201
- is_any_campaign_whitelisted_or_stored = check_whitelisting_or_storage_for_grouped_campaigns(user_id, campaign, group_campaigns, group_name, variation_targeting_variables, true)
202
- if is_any_campaign_whitelisted_or_stored
136
+ if whitelisting_or_storage_for_grouped_campaigns?(user_id, campaign, group_campaigns, group_name, variation_targeting_variables, true)
203
137
  @logger.log(
204
138
  LogLevelEnum::INFO,
205
139
  'MEG_CALLED_CAMPAIGN_NOT_WINNER',
@@ -207,7 +141,7 @@ class VWO
207
141
  '{file}' => FILE,
208
142
  '{campaignKey}' => campaign_key,
209
143
  '{userId}' => user_id,
210
- '{groupName}' => group_name,
144
+ '{groupName}' => group_name
211
145
  }
212
146
  )
213
147
  return nil
@@ -220,8 +154,8 @@ class VWO
220
154
  {
221
155
  '{file}' => FILE,
222
156
  '{userId}' => user_id,
223
- '{eligibleCampaignKeys}' => get_eligible_campaigns_key(eligible_campaigns).join(","),
224
- '{inEligibleText}' => non_eligible_campaigns_key ? ("campaigns:" + non_eligible_campaigns_key.join("'")) : "no campaigns",
157
+ '{eligibleCampaignKeys}' => get_eligible_campaigns_key(eligible_campaigns).join(','),
158
+ '{inEligibleText}' => non_eligible_campaigns_key ? "campaigns: + #{non_eligible_campaigns_key.join("'")}" : 'no campaigns',
225
159
  '{groupName}' => group_name
226
160
  }
227
161
  )
@@ -245,47 +179,123 @@ class VWO
245
179
  {
246
180
  '{file}' => FILE,
247
181
  '{userId}' => user_id,
248
- '{campaignKey}' => winner_campaign["key"],
249
- '{groupName}' => group_name,
182
+ '{campaignKey}' => winner_campaign['key'],
183
+ '{groupName}' => group_name
250
184
  }
251
185
  )
252
186
 
253
- if winner_campaign && winner_campaign["id"] == campaign["id"]
254
- variation = get_variation_allotted(user_id, campaign, true)
255
- if variation && variation['name']
256
- save_user_storage(user_id, campaign_key, campaign['type'], variation['name'], goal_identifier, true) if variation['name']
257
- else
258
- return nil
259
- end
260
- else
261
- @logger.log(
262
- LogLevelEnum::INFO,
263
- 'MEG_CALLED_CAMPAIGN_NOT_WINNER',
264
- {
265
- '{file}' => FILE,
266
- '{campaignKey}' => campaign_key,
267
- '{userId}' => user_id,
268
- '{groupName}' => group_name,
269
- }
270
- )
271
- return nil
272
- end
187
+ return if meg_called_campaign_not_winner?(user_id, group_name, campaign, winner_campaign)
188
+
189
+ variation = get_variation_allotted(user_id, campaign, true)
190
+ return nil unless variation && variation['name']
191
+
192
+ save_user_storage(user_id, campaign_key, campaign['type'], variation['name'], goal_identifier, true) if variation['name']
273
193
  end
274
194
  end
275
195
 
276
- if variation
277
- if campaign['type'] == CampaignTypes::VISUAL_AB || campaign['type'] == CampaignTypes::FEATURE_TEST
278
- decision[:variation_name] = variation['name']
279
- decision[:variation_id] = variation['id']
280
- if campaign['type'] == CampaignTypes::FEATURE_TEST
281
- decision[:is_feature_enabled] = variation['isFeatureEnabled']
282
- end
283
- end
284
- @hooks_manager.execute(decision)
285
- return variation
196
+ variation ||= get_variation_if_presegmentation_applied(is_presegmentation, campaign, user_id, goal_identifier, decision)
197
+ return unless variation
198
+
199
+ decision = add_variation_to_decision_properties(decision, campaign, variation)
200
+ @hooks_manager.execute(decision)
201
+ variation
202
+ end
203
+
204
+ def campaign_not_activated?(user_id, campaign_key, api_name)
205
+ if ([ApiMethods::TRACK, ApiMethods::GET_VARIATION_NAME, ApiMethods::GET_FEATURE_VARIABLE_VALUE].include? api_name) && @user_storage_service
206
+ @logger.log(
207
+ LogLevelEnum::WARNING,
208
+ 'CAMPAIGN_NOT_ACTIVATED',
209
+ {
210
+ '{file}' => FILE,
211
+ '{campaignKey}' => campaign_key,
212
+ '{userId}' => user_id,
213
+ '{api}' => api_name
214
+ }
215
+ )
216
+
217
+ @logger.log(
218
+ LogLevelEnum::INFO,
219
+ 'CAMPAIGN_NOT_ACTIVATED',
220
+ {
221
+ '{file}' => FILE,
222
+ '{campaignKey}' => campaign_key,
223
+ '{userId}' => user_id,
224
+ '{reason}' => api_name == ApiMethods::TRACK ? 'track it' : 'get the decision/value'
225
+ }
226
+ )
227
+ return true
228
+ end
229
+ false
230
+ end
231
+
232
+ def meg_called_campaign_not_winner?(user_id, group_name, campaign, winner_campaign)
233
+ unless winner_campaign && winner_campaign['id'] == campaign['id']
234
+ @logger.log(
235
+ LogLevelEnum::INFO,
236
+ 'MEG_CALLED_CAMPAIGN_NOT_WINNER',
237
+ {
238
+ '{file}' => FILE,
239
+ '{campaignKey}' => campaign['key'],
240
+ '{userId}' => user_id,
241
+ '{groupName}' => group_name
242
+ }
243
+ )
244
+ return true
286
245
  end
246
+ false
247
+ end
287
248
 
288
- return get_variationIfPreSegmentation_applied(is_presegmentation, campaign, user_id, goal_identifier, decision)
249
+ # Intitialize decision properties for hook manager
250
+ #
251
+ # @param[String] :user_id The unique ID assigned to User
252
+ # @param[Hash] :campaign Campaign hash itself
253
+ # @param[String] :api_name Name of the current api call
254
+ # @param[String] :goal_identifier The unique campaign's goal identifier
255
+ # @param[Hash] :custom_variables Key/value pair for segmentation
256
+ # @param[Hash] :variation_targeting_variables Key/value pair for whitelisting
257
+ # @return[Hash] Decision properties for the callback by hook manager
258
+ def initialize_decision_properties(user_id, campaign, api_name, custom_variables = {}, variation_targeting_variables = {}, goal_identifier = '')
259
+ {
260
+ campaign_id: campaign['id'],
261
+ campaign_key: campaign['key'],
262
+ campaign_type: campaign['type'],
263
+ # campaign segmentation conditions
264
+ custom_variables: custom_variables,
265
+ # event name
266
+ event: Hooks::DECISION_TYPES['CAMPAIGN_DECISION'],
267
+ # goal tracked in case of track API
268
+ goal_identifier: goal_identifier,
269
+ # campaign whitelisting flag
270
+ is_forced_variation_enabled: campaign['isForcedVariationEnabled'] || false,
271
+ sdk_version: SDK_VERSION,
272
+ # API name which triggered the event
273
+ source: api_name,
274
+ # Passed in API
275
+ user_id: user_id,
276
+ # Campaign Whitelisting conditions
277
+ variation_targeting_variables: variation_targeting_variables,
278
+ is_user_whitelisted: false,
279
+ from_user_storage_service: false,
280
+ is_feature_enabled: true,
281
+ # VWO generated UUID based on passed UserId and Account ID
282
+ vwo_user_id: generator_for(user_id, @settings_file['accountId'])
283
+ }
284
+ end
285
+
286
+ # Add variation details to decision properties for hook manager
287
+ #
288
+ # @param[Hash] :campaign Campaign details
289
+ # @param[Hash] :variation Variation assigned to user
290
+ # @param[Hash] :decision Decision properties
291
+ # @return[Hash] :decision Decision properties
292
+ def add_variation_to_decision_properties(decision, campaign, variation)
293
+ if campaign['type'] == CampaignTypes::VISUAL_AB || campaign['type'] == CampaignTypes::FEATURE_TEST
294
+ decision[:variation_name] = variation['name']
295
+ decision[:variation_id] = variation['id']
296
+ end
297
+ decision[:is_feature_enabled] = variation['isFeatureEnabled'] if campaign['type'] == CampaignTypes::FEATURE_TEST
298
+ decision
289
299
  end
290
300
 
291
301
  # Get variation by murmur logic if pre segmentation pass
@@ -297,10 +307,9 @@ class VWO
297
307
  # @param[Hash] :decision data containing campaign info passed to hooks manager
298
308
  #
299
309
  # @return[Hash]
300
- def get_variationIfPreSegmentation_applied(is_presegmentation, campaign, user_id, goal_identifier, decision)
301
- unless is_presegmentation
302
- return nil
303
- end
310
+ def get_variation_if_presegmentation_applied(is_presegmentation, campaign, user_id, goal_identifier, decision)
311
+ return nil unless is_presegmentation
312
+
304
313
  campaign_key = campaign['key']
305
314
  variation = get_variation_allotted(user_id, campaign)
306
315
  if variation && variation['name']
@@ -318,13 +327,7 @@ class VWO
318
327
  end
319
328
 
320
329
  if variation
321
- if campaign['type'] == CampaignTypes::VISUAL_AB || campaign['type'] == CampaignTypes::FEATURE_TEST
322
- decision[:variation_name] = variation['name']
323
- decision[:variation_id] = variation['id']
324
- if campaign['type'] == CampaignTypes::FEATURE_TEST
325
- decision[:is_feature_enabled] = variation['isFeatureEnabled']
326
- end
327
- end
330
+ decision = add_variation_to_decision_properties(decision, campaign, variation)
328
331
  @hooks_manager.execute(decision)
329
332
  end
330
333
  variation
@@ -352,8 +355,8 @@ class VWO
352
355
  end
353
356
 
354
357
  if @bucketer.user_part_of_campaign?(user_id, campaign, true)
355
- variation = get_variation_of_campaign_for_user(user_id, campaign, disable_logs)
356
- variation
358
+ get_variation_of_campaign_for_user(user_id, campaign, disable_logs)
359
+
357
360
  else
358
361
  # not part of campaign
359
362
  @logger.log(
@@ -385,7 +388,7 @@ class VWO
385
388
  'USER_VARIATION_ALLOCATION_STATUS',
386
389
  {
387
390
  '{file}' => FILE,
388
- '{status}' => variation ? 'got variation:' + variation['name'] : 'did not get any variation',
391
+ '{status}' => variation ? "got variation: + #{variation['name']}" : 'did not get any variation',
389
392
  '{userId}' => user_id,
390
393
  '{campaignKey}' => campaign['key']
391
394
  },
@@ -418,12 +421,12 @@ class VWO
418
421
  # @param[Boolean] :disable_logs optional: disable logs if True
419
422
  # @return[Boolean] true if found otherwise false
420
423
 
421
- def save_user_storage(user_id, campaign_key, campaign_type, variation_name, goal_identifier, disable_logs = false)
424
+ def save_user_storage(user_id, campaign_key, _campaign_type, variation_name, goal_identifier, disable_logs = false)
422
425
  unless @user_storage_service
423
426
  @logger.log(
424
427
  LogLevelEnum::DEBUG,
425
428
  'USER_STORAGE_SERVICE_NOT_CONFIGURED',
426
- {'{file}' => FILE},
429
+ { '{file}' => FILE },
427
430
  disable_logs
428
431
  )
429
432
  return false
@@ -432,9 +435,7 @@ class VWO
432
435
  new_campaign_user_mapping['campaign_key'] = campaign_key
433
436
  new_campaign_user_mapping['user_id'] = user_id
434
437
  new_campaign_user_mapping['variation_name'] = variation_name
435
- if !goal_identifier.empty?
436
- new_campaign_user_mapping['goal_identifier'] = goal_identifier
437
- end
438
+ new_campaign_user_mapping['goal_identifier'] = goal_identifier unless goal_identifier.empty?
438
439
 
439
440
  @user_storage_service.set(new_campaign_user_mapping)
440
441
 
@@ -463,6 +464,12 @@ class VWO
463
464
  false
464
465
  end
465
466
 
467
+ def update_goal_identifier(user_id, campaign, variation, goal_identifier)
468
+ updated_goal_identifier = variation['goal_identifier']
469
+ updated_goal_identifier += VWO_DELIMITER + goal_identifier
470
+ save_user_storage(user_id, campaign['key'], campaign['name'], variation['name'], updated_goal_identifier) if variation['name']
471
+ end
472
+
466
473
  private
467
474
 
468
475
  # Evaluate all the variations in the campaign to find
@@ -476,20 +483,18 @@ class VWO
476
483
  #
477
484
  # @return[Hash]
478
485
 
479
- def evaluate_whitelisting(user_id, campaign, api_name, campaign_key, variation_targeting_variables = {}, disable_logs = false)
480
- if campaign.key?('isUserListEnabled') && campaign["isUserListEnabled"]
486
+ def evaluate_whitelisting(user_id, campaign, _api_name, campaign_key, variation_targeting_variables = {}, disable_logs = false)
487
+ if campaign.key?('isUserListEnabled') && campaign['isUserListEnabled']
481
488
  vwo_user_id = generator_for(user_id, @settings_file['accountId'], true)
482
489
  if variation_targeting_variables.nil?
483
490
  variation_targeting_variables = { _vwo_user_id: vwo_user_id }
484
491
  else
485
492
  variation_targeting_variables[:_vwo_user_id] = vwo_user_id
486
493
  end
494
+ elsif variation_targeting_variables.nil?
495
+ variation_targeting_variables = { _vwo_user_id: user_id }
487
496
  else
488
- if variation_targeting_variables.nil?
489
- variation_targeting_variables = { _vwo_user_id: user_id }
490
- else
491
- variation_targeting_variables[:_vwo_user_id] = user_id
492
- end
497
+ variation_targeting_variables[:_vwo_user_id] = user_id
493
498
  end
494
499
  targeted_variations = []
495
500
 
@@ -513,7 +518,11 @@ class VWO
513
518
  '{customVariables}' => variation_targeting_variables,
514
519
  '{status}' => status,
515
520
  '{segmentationType}' => SegmentationTypeEnum::WHITELISTING,
516
- '{variation}' => status == StatusEnum::PASSED ? (campaign['type'] == CampaignTypes::FEATURE_ROLLOUT ? 'and hence becomes part of the rollout' : variation['name'] + ' and hence becomes part of the rollout') : '',
521
+ '{variation}' => if status == StatusEnum::PASSED
522
+ campaign['type'] == CampaignTypes::FEATURE_ROLLOUT ? 'and hence becomes part of the rollout' : "#{variation['name']} and hence becomes part of the rollout"
523
+ else
524
+ ''
525
+ end
517
526
  },
518
527
  disable_logs
519
528
  )
@@ -525,7 +534,7 @@ class VWO
525
534
  '{file}' => FILE,
526
535
  '{campaignKey}' => campaign_key,
527
536
  '{userId}' => user_id,
528
- '{variation}' => campaign['type'] == CampaignTypes::FEATURE_ROLLOUT ? '' : 'for variation:' + variation['name']
537
+ '{variation}' => campaign['type'] == CampaignTypes::FEATURE_ROLLOUT ? '' : "for variation:#{variation['name']}"
529
538
  },
530
539
  disable_logs
531
540
  )
@@ -582,7 +591,7 @@ class VWO
582
591
  end
583
592
 
584
593
  def scale_campaigns_weight(campaigns)
585
- normalize_weight = 100/campaigns.length
594
+ normalize_weight = 100 / campaigns.length
586
595
  campaigns.each do |campaign|
587
596
  campaign['weight'] = normalize_weight
588
597
  end
@@ -600,7 +609,7 @@ class VWO
600
609
  @logger.log(
601
610
  LogLevelEnum::DEBUG,
602
611
  'USER_STORAGE_SERVICE_NOT_CONFIGURED',
603
- {'{file}' => FILE},
612
+ { '{file}' => FILE },
604
613
  disable_logs
605
614
  )
606
615
  return false
@@ -643,7 +652,7 @@ class VWO
643
652
  #
644
653
  # @return[Object, nil] if found then variation settings object otherwise None
645
654
 
646
- def get_stored_variation(user_id, campaign_key, user_campaign_map, disable_logs = false)
655
+ def get_stored_variation(_user_id, campaign_key, user_campaign_map, _disable_logs = false)
647
656
  return unless user_campaign_map['campaign_key'] == campaign_key
648
657
 
649
658
  variation_name = user_campaign_map['variation_name']
@@ -664,15 +673,13 @@ class VWO
664
673
  # @param[Boolean] :disable_logs optional: disable logs if True
665
674
  #
666
675
  # @return[Boolean]
667
- def check_presegmentation(campaign, user_id, custom_variables, api_name, disable_logs = false)
676
+ def presegmentation?(campaign, user_id, custom_variables, _api_name, disable_logs = false)
668
677
  campaign_key = campaign['key']
669
678
  segments = get_segments(campaign)
670
679
  is_valid_segments = valid_value?(segments)
671
680
 
672
681
  if is_valid_segments
673
- unless custom_variables
674
- custom_variables = {}
675
- end
682
+ custom_variables ||= {}
676
683
  response = @segment_evaluator.evaluate(campaign_key, user_id, segments, custom_variables, disable_logs)
677
684
  @logger.log(
678
685
  LogLevelEnum::INFO,
@@ -732,11 +739,11 @@ class VWO
732
739
  eligible_campaigns = []
733
740
 
734
741
  group_campaigns.each do |campaign|
735
- if called_campaign["id"] == campaign["id"] || check_presegmentation(campaign, user_id, custom_variables, '', true) && @bucketer.user_part_of_campaign?(user_id, campaign, true)
742
+ if called_campaign['id'] == campaign['id'] || presegmentation?(campaign, user_id, custom_variables, '', true) && @bucketer.user_part_of_campaign?(user_id, campaign, true)
736
743
  eligible_campaigns.push(campaign)
737
744
  end
738
745
  end
739
- return eligible_campaigns
746
+ eligible_campaigns
740
747
  end
741
748
 
742
749
  # Finds and returns the winner campaign from eligible_campaigns list.
@@ -746,14 +753,12 @@ class VWO
746
753
  #
747
754
  # @return[Hash]
748
755
  def get_winner_campaign(user_id, eligible_campaigns, group_id)
749
- if eligible_campaigns.length == 1
750
- return eligible_campaigns[0]
751
- end
756
+ return eligible_campaigns[0] if eligible_campaigns.length == 1
752
757
 
753
758
  eligible_campaigns = scale_campaigns_weight(eligible_campaigns)
754
759
  eligible_campaigns = set_campaign_allocation(eligible_campaigns)
755
760
  bucket_value = @bucketer.get_bucket_value_for_user(user_id, {}, group_id, true)
756
- return @bucketer.get_campaign_using_range(bucket_value, eligible_campaigns)
761
+ @bucketer.get_campaign_using_range(bucket_value, eligible_campaigns)
757
762
  end
758
763
 
759
764
  # Get campaign keys of all eligible Campaigns.
@@ -764,7 +769,7 @@ class VWO
764
769
  def get_eligible_campaigns_key(eligible_campaigns)
765
770
  eligible_campaigns_key = []
766
771
  eligible_campaigns.each do |campaign|
767
- eligible_campaigns_key.push(campaign["key"])
772
+ eligible_campaigns_key.push(campaign['key'])
768
773
  end
769
774
  eligible_campaigns_key
770
775
  end
@@ -778,9 +783,7 @@ class VWO
778
783
  def get_non_eligible_campaigns_key(eligible_campaigns, group_campaigns)
779
784
  non_eligible_campaigns_key = []
780
785
  group_campaigns.each do |campaign|
781
- unless eligible_campaigns.include? campaign
782
- non_eligible_campaigns_key.push(campaign["key"])
783
- end
786
+ non_eligible_campaigns_key.push(campaign['key']) unless eligible_campaigns.include? campaign
784
787
  end
785
788
  non_eligible_campaigns_key
786
789
  end
@@ -795,54 +798,54 @@ class VWO
795
798
  # @param[Boolean] :disable_logs optional: disable logs if True
796
799
  # @return[Boolean]
797
800
 
798
- def check_whitelisting_or_storage_for_grouped_campaigns(user_id, called_campaign, group_campaigns, group_name, variation_targeting_variables, disable_logs = false)
801
+ def whitelisting_or_storage_for_grouped_campaigns?(user_id, called_campaign, group_campaigns, group_name, variation_targeting_variables, disable_logs = false)
799
802
  group_campaigns.each do |campaign|
800
- if called_campaign["id"] != campaign["id"]
801
- targeted_variation = evaluate_whitelisting(
802
- user_id,
803
- campaign,
804
- '',
805
- campaign["key"],
806
- variation_targeting_variables,
807
- true
808
- )
809
- if targeted_variation
810
- @logger.log(
811
- LogLevelEnum::INFO,
812
- 'OTHER_CAMPAIGN_SATISFIES_WHITELISTING_STORAGE',
813
- {
814
- '{file}' => FILE,
815
- '{campaignKey}' => campaign["key"],
816
- '{userId}' => user_id,
817
- '{groupName}' => group_name,
818
- '{type}' => "whitelisting"
819
- },
820
- disable_logs
821
- )
822
- return true
823
- end
824
- end
803
+ next unless called_campaign['id'] != campaign['id']
804
+
805
+ targeted_variation = evaluate_whitelisting(
806
+ user_id,
807
+ campaign,
808
+ '',
809
+ campaign['key'],
810
+ variation_targeting_variables,
811
+ true
812
+ )
813
+ next unless targeted_variation
814
+
815
+ @logger.log(
816
+ LogLevelEnum::INFO,
817
+ 'OTHER_CAMPAIGN_SATISFIES_WHITELISTING_STORAGE',
818
+ {
819
+ '{file}' => FILE,
820
+ '{campaignKey}' => campaign['key'],
821
+ '{userId}' => user_id,
822
+ '{groupName}' => group_name,
823
+ '{type}' => 'whitelisting'
824
+ },
825
+ disable_logs
826
+ )
827
+ return true
825
828
  end
826
829
 
827
830
  group_campaigns.each do |campaign|
828
- if called_campaign["id"] != campaign["id"]
829
- user_storage_data = get_user_storage(user_id, campaign["key"], true)
830
- if user_storage_data
831
- @logger.log(
832
- LogLevelEnum::INFO,
833
- 'OTHER_CAMPAIGN_SATISFIES_WHITELISTING_STORAGE',
834
- {
835
- '{file}' => FILE,
836
- '{campaignKey}' => campaign["key"],
837
- '{userId}' => user_id,
838
- '{groupName}' => group_name,
839
- '{type}' => "user storag"
840
- },
841
- disable_logs
842
- )
843
- return true
844
- end
845
- end
831
+ next unless called_campaign['id'] != campaign['id']
832
+
833
+ user_storage_data = get_user_storage(user_id, campaign['key'], true)
834
+ next unless user_storage_data
835
+
836
+ @logger.log(
837
+ LogLevelEnum::INFO,
838
+ 'OTHER_CAMPAIGN_SATISFIES_WHITELISTING_STORAGE',
839
+ {
840
+ '{file}' => FILE,
841
+ '{campaignKey}' => campaign['key'],
842
+ '{userId}' => user_id,
843
+ '{groupName}' => group_name,
844
+ '{type}' => 'user storag'
845
+ },
846
+ disable_logs
847
+ )
848
+ return true
846
849
  end
847
850
  false
848
851
  end
@@ -880,22 +883,16 @@ class VWO
880
883
  '{file}' => FILE,
881
884
  '{campaignKey}' => campaign_key,
882
885
  '{userId}' => user_id,
883
- '{customVariables}' => variation_targeting_variables ? variation_targeting_variables : {},
886
+ '{customVariables}' => variation_targeting_variables || {},
884
887
  '{status}' => status,
885
888
  '{segmentationType}' => SegmentationTypeEnum::WHITELISTING,
886
- '{variation}' => (status == StatusEnum::PASSED && campaign['type'] != CampaignTypes::FEATURE_ROLLOUT) ? "for variation:#{variation['name']}" : ' '
889
+ '{variation}' => status == StatusEnum::PASSED && campaign['type'] != CampaignTypes::FEATURE_ROLLOUT ? "for variation:#{variation['name']}" : ' '
887
890
  },
888
891
  disable_logs
889
892
  )
890
893
 
891
894
  if variation
892
- if campaign['type'] == CampaignTypes::VISUAL_AB || campaign['type'] == CampaignTypes::FEATURE_TEST
893
- decision[:variation_name] = variation['name']
894
- decision[:variation_id] = variation['id']
895
- if campaign['type'] == CampaignTypes::FEATURE_TEST
896
- decision[:is_feature_enabled] = variation['isFeatureEnabled']
897
- end
898
- end
895
+ decision = add_variation_to_decision_properties(decision, campaign, variation)
899
896
  decision[:is_user_whitelisted] = true
900
897
  @hooks_manager.execute(decision)
901
898
  end
@@ -917,7 +914,6 @@ class VWO
917
914
  end
918
915
  nil
919
916
  end
920
-
921
917
  end
922
918
  end
923
919
  end