-
Notifications
You must be signed in to change notification settings - Fork 41
/
experiment.rb
262 lines (212 loc) · 7.87 KB
/
experiment.rb
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
class Experiment < DomainModel
attr_accessor :language, :page_revision_options
has_many :experiment_versions, :order => :id, :dependent => :destroy
has_many :experiment_users
belongs_to :experiment_container, :polymorphic => true
belongs_to :conversion_site_node, :class_name => 'SiteNode'
validates_presence_of :name
validates_presence_of :experiment_container_type
validates_presence_of :experiment_container_id
def num_versions
@num_versions ||= self.min_versions
end
def num_versions=(n)
@num_versions = n >= self.min_versions ? n : self.min_versions
end
def min_versions
return @min_versions if @min_versions
@min_versions = self.started? ? self.versions.size : 2
@min_versions = 2 if @min_versions < 2
@min_versions
end
def max_versions
return @max_versions if @max_versions
@max_versions = self.page_revision_options ? self.page_revision_options.size : self.min_versions
@max_versions = self.min_versions if @max_versions < self.min_versions
@max_versions
end
def finished?
! self.ended_at.blank? && self.ended_at <= Time.now
end
def started?
self.started_at && self.started_at <= Time.now
end
def is_running?
self.started? && ! self.finished?
end
def active?
self.experiment_container && self.id && self.experiment_container.experiment_id == self.id
end
def display_status
if self.finished?
'Finished'.t
elsif self.is_running?
'Running'.t
else
'Not Started'.t
end
end
def page_title
return '' unless self.experiment_container
self.experiment_container.node_path
end
def conversion_title
return nil unless self.conversion_site_node
self.conversion_site_node.node_path
end
def validate
if @versions && @versions.size > 0
if self.total_weight != 100 && self.total_weight != 0
self.errors.add_to_base("Weights must added up to 100")
@versions.each { |v| v.errors.add(:weight, 'is invalid') }
end
@wrong_language = false
@versions.each do |v|
if v.language != self.language
@versions.errors.add(:language, 'is invalid')
@wrong_language = true
end
end
self.errors.add(:language, "is invalid") if @wrong_language
end
end
def start!(start_time=nil)
start_time ||= Time.now
self.update_attribute :started_at, start_time
end
def restart!(end_time=nil, opts={})
if opts[:reset]
self.experiment_users.delete_all
start_time = opts[:start_time] || Time.now
self.update_attributes :started_at => start_time, :ended_at => end_time
else
self.update_attribute :ended_at, end_time
end
end
def end_experiment!(end_time=nil)
end_time ||= Time.now
self.update_attribute :ended_at, end_time
end
def total_weight
self.versions.collect(&:weight).inject(0) { |sum, n| sum + n.to_i }
end
# returns an array of language specific versions
def versions
@versions ||= self.experiment_versions.find(:all, :conditions => {:language => self.language}, :order => :id)
end
def versions=(vers)
@versions = []
vers = vers.sort { |a,b| a[0].to_i <=> b[0].to_i }.collect { |v| v[1] } if vers.is_a?(Hash)
vers.each do |ver|
version = ver[:id] ? self.experiment_versions.find_by_id(ver[:id]) : nil
version ||= ExperimentVersion.new(:experiment_id => self.id, :language => self.language)
if version.id && self.is_running?
version.attributes = ver.slice(:weight)
else
version.attributes = ver.slice(:weight, :revision)
end
@versions << version
end
if self.is_running?
ids = @versions.collect(&:id)
@versions += self.experiment_versions.find(:all, :conditions => {:language => self.language}).select { |ver| ! ids.include?(ver.id) }
end
@versions
end
def after_save
if @versions && self.language
unless self.is_running?
ids = @versions.collect(&:id)
self.experiment_versions.find(:all, :conditions => {:language => self.language}).each do |ver|
ver.destroy unless ids.include?(ver.id)
end
end
auto_set_weight = self.total_weight == 0
weight_per_version = @versions.size > 0 ? 100 / @versions.size : 0
left_over_weight = @versions.size > 0 ? 100 % @versions.size : 0
@versions.each do |ver|
ver.experiment_id = self.id
if auto_set_weight
ver.weight = weight_per_version
ver.weight += 1 if left_over_weight > 0
left_over_weight -= 1
end
ver.save
end
@versions = nil
end
if @old_conversion_site_node_id
old_site_node = SiteNode.find_by_id @old_conversion_site_node_id
self.remove_experiment_conversion_paragraph old_site_node if old_site_node
end
if self.conversion_site_node
if self.finished?
self.remove_experiment_conversion_paragraph self.conversion_site_node
elsif self.started?
self.add_experiment_conversion_paragraph self.conversion_site_node
end
end
end
def get_user(session)
return nil unless session[:domain_log_visitor] && session[:cms_language]
user = self.experiment_users.find_by_domain_log_visitor_id_and_language(session[:domain_log_visitor][:id], session[:cms_language])
user.update_attribute(:end_user_id, session[:domain_log_visitor][:end_user_id]) if user && user.end_user_id.nil? && session[:domain_log_visitor][:end_user_id]
user
end
def get_version(session)
return nil unless self.is_running?
return nil unless session[:domain_log_visitor] && session[:cms_language]
user = self.get_user(session)
return user.experiment_version if user
@versions = nil
self.language = session[:cms_language]
weight_sum = 0
random_weight = rand(self.total_weight)
version = self.versions.find do |v|
weight_sum += v.weight
weight_sum > random_weight
end
return nil unless version
self.experiment_users.create :experiment_version_id => version.id, :domain_log_visitor_id => session[:domain_log_visitor][:id], :language => self.language, :end_user_id => session[:domain_log_visitor][:end_user_id], :domain_log_session_id => session[:domain_log_session][:id]
version
end
def success!(session)
return unless self.is_running?
user = self.get_user(session)
user.success! if user
end
def self.success!(experiment_id, session)
return unless session[:domain_log_visitor] && session[:cms_language]
exp = Experiment.find_by_id experiment_id
exp.success!(session) if exp
end
def conversion_site_node_id=(site_node_id)
@old_conversion_site_node_id = self.conversion_site_node_id
self.write_attribute :conversion_site_node_id, site_node_id
end
def add_experiment_conversion_paragraph(site_node)
return if self.has_experiment_conversion_paragraph?(site_node)
site_node.live_revisions.each do |rv|
exp_para = rv.page_paragraphs.find(:all, :conditions => {:display_type => 'experiment', :display_module => '/editor/action'}).find do |para|
para.data[:experiment_id] == self.id
end
unless exp_para
exp_para = rv.add_paragraph('/editor/action', 'experiment', {:experiment_id => self.id, :type => 'automatic'})
exp_para.save
end
end
end
def remove_experiment_conversion_paragraph(site_node)
return unless self.has_experiment_conversion_paragraph?(site_node)
site_node.live_revisions.each do |rv|
rv.page_paragraphs.find(:all, :conditions => {:display_type => 'experiment', :display_module => '/editor/action'}).each do |para|
para.destroy if para.data[:experiment_id] == self.id
end
end
end
def has_experiment_conversion_paragraph?(site_node)
site_node.live_revisions.first.page_paragraphs.find(:all, :conditions => {:display_type => 'experiment', :display_module => '/editor/action'}).find do |para|
para.data[:experiment_id] == self.id
end
end
end