Class: Auth::System::Merger

Inherits:
Object
  • Object
show all
Includes:
Mongoid::Document
Defined in:
app/models/auth/system/merger.rb

Instance Method Summary collapse

Instance Method Details

#add_query_result(query_result, query_id, target_query_id, location_applicability_hash, min_addition, max_addition) ⇒ Object

@param query_result : the array of the query results. @param query_id : the query_id of the current query. @param target_query_id : an earlier query that you are targeting. @param location_applicability_hash : the hash which contains which location is applicable to which location eg : =>

indices_of_applicable_location_ids_from_the_result 



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
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
 
# File 'app/models/auth/system/merger.rb', line 79

def add_query_result(query_result,query_id,target_query_id,location_applicability_hash,min_addition,max_addition)

	query_result = query_result.to_a

	h = query_result_to_hash(query_result)
	range_start = h.keys[0] - min_addition
	range_end = h.keys[1] - max_addition

	query_id = query_id.to_sym
	target_query_id = target_query_id.to_sym
	location_applicability_hash.deep_symbolize_keys!

	## what is the range of applicable minutes?
	## first minute - minimum
	## last minute - maximum

	minutes_to_delete_for_query_id = []

	## at the end we have only 
	## okay its time to abort this, and finish the test object, guidelines, b2b, chat, ui frontend api, and video and image synchronization.
	## can i find a simplified solution for this ?
	## 
=begin
## STRUCTURE OF COMBINATIONS TO INSERT : 
{
	minute : {
		query_id : {
			location : {
				combinations : []
			}
		}
	}
}
=end

	combinations_to_insert = {}

=begin
{
	running_combinations : 
	{
			location_id : 
			[
				combination_one : closes_at_minute
				combination_two : closes_at_minute
			],
			location_id_2 :
			[
				combination_three : closes_at_minute
				combination_four : closes_at_minute
			]
	},
	combinations_to_close : {
		minute : {location_id => [combinations_ids..]}
	}

	## how to handle 
	## if a combination opens up, then we have to add it to this.
	## and if we encounter the minute where the combination closes, then we have to remove it at that time.
	## how to know we are iterating a combination ?
	## if that combination is encountered.
	## in the merger hash, at that minute, then it is open.
	## what will it have
	## for eg :
	## [1,2,3,4], and it will have a point where that combination closes.
	## so that minute will also be defined.
	## so how will the merger has look at a particular location at a particular minute ? 
	## it just has a hash of combinations.
	## and where it ends.
	## thats; all.
	## so let us give it a key, like 
}
=end
		open_combinations_hash = {
			:running_combinations => {}
		}


		## how does it work
		## take the result
		## take each minute
		## merger hash get minutes applicable
		## if minute has query id
		## check if it has any of the locations, otherwise delete it.
		## if it has, then check if applicable, otherwise move on
		## rebuild the query result first
		## get it by minute.
		## we actually just want the minutes
		## and the locations.
		## nothing else.
		## that can be easily done


		self.merger_hash.each_key do |minute|
			
			## everytime you do a new minute, clear the open_combinations hsh.
			open_combinations_hash = {:running_combinations => {}}
			if merger_hash[minute].key? target_query_id
				merger_hash[minute][target_query_id].each_key do |location_id|
					if location_applicability_hash.key? location_id
						## add open combinations.
						if combinations_hash = merger_hash[minute][target_query_id][location_id][:combinations]

							open_combinations_hash[:running_combinations][location_id] = {} unless open_combinations_hash[:running_combinations][location_id]

							combinations_hash.each_key do |combination|
								open_combinations_hash[:running_combinations][location_id][combination] = combinations_hash[combination]
							
							end

						end

						## close the open combinations that no longer apply.
						## where do we close the combinations ?
						## exactly ?
						## when are combinations no longer applicable ?
						## 

						## now comes the part where we actually write forward.
						## these values, 
						location_applicability_hash[location_id].each do |index_in_result|
							## here we need only the first and last minute.
							## here we need the first minute within range.
							## and also the last minute.
							start_search = minute.to_s.to_i + min_addition
							end_search = minute.to_s.to_i + max_addition
							start_minute = nil
							end_minute = nil
							

							location_id_of_result_location = query_result[index_in_result]["_id"]

							
							query_result[index_in_result]["minutes"].each do |result_minute|

								puts "start search is: #{start_search}"
								puts "end search is  : #{end_search}"
								puts "root minute is :#{minute}"
								puts "start minute is: #{start_minute}"
								puts "end minute is: #{end_minute}"
								puts "Result minute is:"
								puts result_minute["minute"]
								puts "------------------------------"
								## why does 1 -> 218?

								if ((result_minute["minute"] >= start_search) && (result_minute["minute"] <= end_search))
									if start_minute.nil?
										start_minute = result_minute["minute"]
									else
										end_minute = result_minute["minute"]
									end
								else
									## TODO : test this.
									break
								end
							end
							
							puts "open combination hash is:"
							puts JSON.pretty_generate(open_combinations_hash)

							## if we only have a start minute, then the end minute equals to it.
							end_minute = start_minute unless end_minute

							if start_minute && end_minute
								puts "start minute: #{start_minute} and end_minute: #{end_minute}:"

								open_combinations_hash[:running_combinations][location_id].each_key do |combi|

									combinations_to_insert = combinations_to_insert.deep_merge({
										start_minute.to_s.to_sym =>
										{
											query_id.to_sym => {
												 location_id_of_result_location.to_s.to_sym => {
												 	:combinations => {
												 		(combi.to_s + "_" + location_id_of_result_location.to_s + "_" + start_minute.to_s).to_sym => end_minute
												 	}
												 }
											}
										}
									})

									puts "after merging it becomes:"
									puts JSON.pretty_generate(combinations_to_insert)

								end
							end
						end
					end 
				end
			else
				#puts "target query id is not a key of this minute."
			end
		end
	
	#puts "the combinations to insert are:"
	#puts JSON.pretty_generate(combinations_to_insert)
	self.merger_hash = self.merger_hash.deep_merge(combinations_to_insert)

	

end

#populate_merger_hash_for_the_first_time(query_result, query_id) ⇒ Object

the query result for a given query. the query_id.



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
 
# File 'app/models/auth/system/merger.rb', line 22

def populate_merger_hash_for_the_first_time(query_result,query_id)

	query_result.each do |location|
			
		location_id = location["_id"].to_s
		
		minutes = location["minutes"]
		
		minutes = minutes.map{|c| c = Auth.configuration.minute_class.constantize.new(c)}
		
		minutes.each do |minute|
			
			min = minute.minute.to_s
			

			#puts "came to minute."
			self.merger_hash.deep_merge!({
				min.to_sym => {
					query_id.to_sym => {
						location_id.to_sym => {
							:combinations => {
								(location_id.to_s + "_" + min).to_sym => min 
							}
						}
					}
				}
			})

			
		end

	end

end

#query_result_to_hash(query_result) ⇒ Object 



57
58
59
60
61
62
63
64
65
66
67
68
69
 
# File 'app/models/auth/system/merger.rb', line 57

def query_result_to_hash(query_result)
	h = {}
	query_result.each_key do |location|
		location["minutes"].map{|c| c = c["minute"]}.each do |minute|
			build = {minute.to_sym => {}}
			location["applicable_to_locations"].each do |_id|
				build[minute_to_sym][_id] = true
			end
			h.deep_merge!(build)
		end
	end
	h
end