Completed
Push — master ( a946bc...2f49c6 )
by Yannick
07:55
created

Spotter::countAllHoursByRegistration()   B

Complexity

Conditions 4
Paths 8

Size

Total Lines 40
Code Lines 21

Duplication

Lines 0
Ratio 0 %

Importance

Changes 0
Metric Value
cc 4
eloc 21
nc 8
nop 1
dl 0
loc 40
rs 8.5806
c 0
b 0
f 0
1
<?php
2
require_once(dirname(__FILE__).'/class.Scheduler.php');
3
require_once(dirname(__FILE__).'/class.ACARS.php');
4
require_once(dirname(__FILE__).'/class.Image.php');
5
$global_query = "SELECT spotter_output.* FROM spotter_output";
6
7
class Spotter{
8
	public $db;
9
	
10
	public function __construct($dbc = null) {
11
		$Connection = new Connection($dbc);
12
		$this->db = $Connection->db();
13
	}
14
	
15
	/**
16
	* Executes the SQL statements to get the spotter information
17
	*
18
	* @param String $query the SQL query
19
	* @param Array $params parameter of the query
20
	* @param String $limitQuery the limit query
21
	* @return Array the spotter information
22
	*
23
	*/
24
	public function getDataFromDB($query, $params = array(), $limitQuery = '')
25
	{
26
		global $globalSquawkCountry, $globalIVAO, $globalVATSIM, $globalphpVMS;
27
		$Image = new Image($this->db);
28
		$Schedule = new Schedule($this->db);
29
		$ACARS = new ACARS($this->db);
30
		if (!isset($globalIVAO)) $globalIVAO = FALSE;
31
		if (!isset($globalVATSIM)) $globalVATSIM = FALSE;
32
		if (!isset($globalphpVMS)) $globalphpVMS = FALSE;
33
		date_default_timezone_set('UTC');
34
		
35
		if (!is_string($query))
36
		{
37
			return false;
38
		}
39
		
40
		if ($limitQuery != "")
41
		{
42
			if (!is_string($limitQuery))
43
			{
44
				return false;
45
			}
46
		}
47
48
		
49
		try {
50
			$sth = $this->db->prepare($query.$limitQuery);
51
			$sth->execute($params);
52
		} catch (PDOException $e) {
53
			printf("Invalid query : %s\nWhole query: %s\n",$e->getMessage(), $query.$limitQuery);
54
			exit();
55
		}
56
		
57
	//	$num_rows = count($sth->fetchAll());
58
		$num_rows = 0;
59
60
		$spotter_array = array();
61
		
62
63
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
64
		{
65
			$num_rows++;
66
			$temp_array = array();
67
			if (isset($row['spotter_live_id'])) {
68
				//$temp_array['spotter_id'] = $row['spotter_live_id'];
69
				$temp_array['spotter_id'] = $this->getSpotterIDBasedOnFlightAwareID($row['flightaware_id']);
70
			} elseif (isset($row['spotter_archive_id'])) {
71
				$temp_array['spotter_id'] = $row['spotter_archive_id'];
72
			} elseif (isset($row['spotter_archive_output_id'])) {
73
				$temp_array['spotter_id'] = $row['spotter_archive_output_id'];
74
			} elseif (isset($row['spotter_id'])) {
75
				$temp_array['spotter_id'] = $row['spotter_id'];
76
			} else {
77
				$temp_array['spotter_id'] = '';
78
			}
79
			$temp_array['flightaware_id'] = $row['flightaware_id'];
80
			if (isset($row['modes'])) $temp_array['modes'] = $row['modes'];
81
			$temp_array['ident'] = $row['ident'];
82
			if (isset($row['registration']) && $row['registration'] != '') {
83
				$temp_array['registration'] = $row['registration'];
84
			} elseif (isset($temp_array['modes'])) {
85
				$temp_array['registration'] = $this->getAircraftRegistrationBymodeS($temp_array['modes']);
86
			} else $temp_array['registration'] = '';
87
			$temp_array['aircraft_type'] = $row['aircraft_icao'];
88
			
89
			$temp_array['departure_airport'] = $row['departure_airport_icao'];
90
			$temp_array['arrival_airport'] = $row['arrival_airport_icao'];
91
			if (isset($row['real_arrival_airport_icao']) && $row['real_arrival_airport_icao'] != NULL) $temp_array['real_arrival_airport'] = $row['real_arrival_airport_icao'];
92
			$temp_array['latitude'] = $row['latitude'];
93
			$temp_array['longitude'] = $row['longitude'];
94
			/*
95
			if (Connection->tableExists('countries')) {
96
				$country_info = $this->getCountryFromLatitudeLongitude($temp_array['latitude'],$temp_array['longitude']);
97
				if (is_array($country_info) && isset($country_info['name']) && isset($country_info['iso2'])) {
98
				    $temp_array['country'] = $country_info['name'];
99
				    $temp_array['country_iso2'] = $country_info['iso2'];
100
				}
101
			}
102
			*/
103
			$temp_array['waypoints'] = $row['waypoints'];
104
			$temp_array['format_source'] = $row['format_source'];
105
			if (isset($row['route_stop'])) {
106
				$temp_array['route_stop'] = $row['route_stop'];
107
				if ($row['route_stop'] != '') {
108
					$allroute = explode(' ',$row['route_stop']);
109
			
110
					foreach ($allroute as $route) {
111
						$route_airport_array = $this->getAllAirportInfo($route);
112
						if (isset($route_airport_array[0]['name'])) {
113
							$route_stop_details = array();
114
							$route_stop_details['airport_name'] = $route_airport_array[0]['name'];
115
							$route_stop_details['airport_city'] = $route_airport_array[0]['city'];
116
							$route_stop_details['airport_country'] = $route_airport_array[0]['country'];
117
							$route_stop_details['airport_icao'] = $route_airport_array[0]['icao'];
118
							$temp_array['route_stop_details'][] = $route_stop_details;
119
						}
120
					}
121
				}
122
			}
123
			$temp_array['altitude'] = $row['altitude'];
124
			$temp_array['heading'] = $row['heading'];
125
			$heading_direction = $this->parseDirection($row['heading']);
126
			if (isset($heading_direction[0]['direction_fullname'])) $temp_array['heading_name'] = $heading_direction[0]['direction_fullname'];
127
			$temp_array['ground_speed'] = $row['ground_speed'];
128
			$temp_array['image'] = "";
129
			$temp_array['image_thumbnail'] = "";
130
			$temp_array['image_source'] = "";
131
			$temp_array['image_copyright'] = "";
132
 
133
			if (isset($row['highlight'])) {
134
				$temp_array['highlight'] = $row['highlight'];
135
			} else $temp_array['highlight'] = '';
136
			
137
			$dateArray = $this->parseDateString($row['date']);
138
			if ($dateArray['seconds'] < 10)
139
			{
140
				$temp_array['date'] = "a few seconds ago";
141
			} elseif ($dateArray['seconds'] >= 5 && $dateArray['seconds'] < 30)
142
			{
143
				$temp_array['date'] = "half a minute ago";
144
			} elseif ($dateArray['seconds'] >= 30 && $dateArray['seconds'] < 60)
145
			{
146
				$temp_array['date'] = "about a minute ago";
147
			} elseif ($dateArray['minutes'] < 5)
148
			{
149
				$temp_array['date'] = "a few minutes ago";
150
			} elseif ($dateArray['minutes'] >= 5 && $dateArray['minutes'] < 60)
151
			{
152
				$temp_array['date'] = "about ".$dateArray['minutes']." minutes ago";
153
			} elseif ($dateArray['hours'] < 2)
154
			{
155
				$temp_array['date'] = "about an hour ago";
156
			} elseif ($dateArray['hours'] >= 2 && $dateArray['hours'] < 24)
157
			{
158
				$temp_array['date'] = "about ".$dateArray['hours']." hours ago";
159
			} else {
160
				$temp_array['date'] = date("M j Y, g:i a",strtotime($row['date']." UTC"));
161
			}
162
			$temp_array['date_minutes_past'] = $dateArray['minutes'];
163
			$temp_array['date_iso_8601'] = date("c",strtotime($row['date']." UTC"));
164
			$temp_array['date_rfc_2822'] = date("r",strtotime($row['date']." UTC"));
165
			$temp_array['date_unix'] = strtotime($row['date']." UTC");
166
			
167
			if (isset($row['aircraft_name']) && $row['aircraft_name'] != '' && isset($row['aircraft_shadow']) && $row['aircraft_shadow'] != '') {
168
				$temp_array['aircraft_name'] = $row['aircraft_name'];
169
				$temp_array['aircraft_manufacturer'] = $row['aircraft_manufacturer'];
170
				if (isset($row['aircraft_shadow'])) {
171
					$temp_array['aircraft_shadow'] = $row['aircraft_shadow'];
172
				}
173
			} else {
174
				$aircraft_array = $this->getAllAircraftInfo($row['aircraft_icao']);
175
				if (count($aircraft_array) > 0) {
176
					$temp_array['aircraft_name'] = $aircraft_array[0]['type'];
177
					$temp_array['aircraft_manufacturer'] = $aircraft_array[0]['manufacturer'];
178
				
179
					if ($aircraft_array[0]['aircraft_shadow'] != NULL) {
180
						$temp_array['aircraft_shadow'] = $aircraft_array[0]['aircraft_shadow'];
181
					} else $temp_array['aircraft_shadow'] = 'default.png';
182
                                } else {
183
                            		$temp_array['aircraft_shadow'] = 'default.png';
184
					$temp_array['aircraft_name'] = 'N/A';
185
					$temp_array['aircraft_manufacturer'] = 'N/A';
186
                            	}
187
			}
188
			if (!isset($row['airline_name']) || $row['airline_name'] == '') {
189
				if (!is_numeric(substr($row['ident'], 0, 3))) {
190
					if (is_numeric(substr($row['ident'], 2, 1))) {
191
						$airline_array = $this->getAllAirlineInfo(substr($row['ident'], 0, 2));
192
					} elseif (is_numeric(substr($row['ident'], 3, 1))) {
193
						$airline_array = $this->getAllAirlineInfo(substr($row['ident'], 0, 3));
194
					} else {
195
						$airline_array = $this->getAllAirlineInfo('NA');
196
					}
197
				} else {
198
					$airline_array = $this->getAllAirlineInfo('NA');
199
				}
200
				if (count($airline_array) > 0) {
201
					$temp_array['airline_icao'] = $airline_array[0]['icao'];
202
					$temp_array['airline_iata'] = $airline_array[0]['iata'];
203
					$temp_array['airline_name'] = $airline_array[0]['name'];
204
					$temp_array['airline_country'] = $airline_array[0]['country'];
205
					$temp_array['airline_callsign'] = $airline_array[0]['callsign'];
206
					$temp_array['airline_type'] = $airline_array[0]['type'];
207
				}
208
			} else {
209
				$temp_array['airline_icao'] = $row['airline_icao'];
210
				if (isset($row['airline_iata'])) $temp_array['airline_iata'] = $row['airline_iata'];
211
				else $temp_array['airline_iata'] = '';
212
				$temp_array['airline_name'] = $row['airline_name'];
213
				$temp_array['airline_country'] = $row['airline_country'];
214
				if (isset($row['airline_callsign'])) $temp_array['airline_callsign'] = $row['airline_callsign'];
215
				else $temp_array['airline_callsign'] = 'N/A';
216
				$temp_array['airline_type'] = $row['airline_type'];
217
			}
218
			if (isset($temp_array['airline_iata']) && $temp_array['airline_iata'] != '') {
219
				$acars_array = $ACARS->getLiveAcarsData($temp_array['airline_iata'].substr($temp_array['ident'],3));
220
				//$acars_array = ACARS->getLiveAcarsData('BA40YL');
221
				if (count($acars_array) > 0) {
222
					$temp_array['acars'] = $acars_array;
223
					//print_r($acars_array);
224
				}
225
			}
226
			if (isset($row['owner_name']) && $row['owner_name'] != '' && $row['owner_name'] != NULL) {
227
				$temp_array['aircraft_owner'] = $row['owner_name'];
228
			}
229
			if ($temp_array['registration'] != "" && !$globalIVAO && !$globalVATSIM && !$globalphpVMS && !isset($temp_array['aircraft_owner'])) {
230
				$owner_info = $this->getAircraftOwnerByRegistration($temp_array['registration']);
231
				if ($owner_info['owner'] != '') $temp_array['aircraft_owner'] = ucwords(strtolower($owner_info['owner']));
232
				$temp_array['aircraft_base'] = $owner_info['base'];
233
				$temp_array['aircraft_date_first_reg'] = $owner_info['date_first_reg'];
234
			}
235
236
			if($temp_array['registration'] != "" || ($globalIVAO && $temp_array['aircraft_type'] != ''))
237
			{
238
				if ($globalIVAO) {
239
					if (isset($temp_array['airline_icao']))	$image_array = $Image->getSpotterImage('',$temp_array['aircraft_type'],$temp_array['airline_icao']);
240
					else $image_array = $Image->getSpotterImage('',$temp_array['aircraft_type']);
241
				} else $image_array = $Image->getSpotterImage($temp_array['registration']);
242
				if (count($image_array) > 0) {
243
					$temp_array['image'] = $image_array[0]['image'];
244
					$temp_array['image_thumbnail'] = $image_array[0]['image_thumbnail'];
245
					$temp_array['image_source'] = $image_array[0]['image_source'];
246
					$temp_array['image_source_website'] = $image_array[0]['image_source_website'];
247
					if ($temp_array['image_source_website'] == '' && $temp_array['image_source'] == 'planespotters') {
248
						$planespotter_url_array = explode("_", $temp_array['image']);
249
						$planespotter_id = str_replace(".jpg", "", $planespotter_url_array[1]);
250
						$temp_array['image_source_website'] = 'http://www.planespotters.net/Aviation_Photos/photo.show?id='.$planespotter_id;
251
					 }
252
					$temp_array['image_copyright'] = $image_array[0]['image_copyright'];
253
				}
254
			}
255
256
257
			if (isset($row['departure_airport_time']) && $row['departure_airport_time'] != '') {
258
				$temp_array['departure_airport_time'] = $row['departure_airport_time'];
259
			}
260
			if (isset($row['arrival_airport_time']) && $row['arrival_airport_time'] != '') {
261
				$temp_array['arrival_airport_time'] = $row['arrival_airport_time'];
262
			}
263
			if ((!isset($globalIVAO) || ! $globalIVAO) && (!isset($globalVATSIM) || !$globalVATSIM) && (!isset($globalphpVMS) || !$globalphpVMS)) {
264
				$schedule_array = $Schedule->getSchedule($temp_array['ident']);
265
				//print_r($schedule_array);
266
				if (count($schedule_array) > 0) {
267
					if ($schedule_array['departure_airport_icao'] != '') {
268
						$row['departure_airport_icao'] = $schedule_array['departure_airport_icao'];
269
						 $temp_array['departure_airport'] = $row['departure_airport_icao'];
270
					}
271
					if ($schedule_array['arrival_airport_icao'] != '') {
272
						$row['arrival_airport_icao'] = $schedule_array['arrival_airport_icao'];
273
						$temp_array['arrival_airport'] = $row['arrival_airport_icao'];
274
					}
275
276
					$temp_array['departure_airport_time'] = $schedule_array['departure_airport_time'];
277
					$temp_array['arrival_airport_time'] = $schedule_array['arrival_airport_time'];
278
				}
279
			} else {
280
				if (isset($row['real_departure_airport_time']) && $row['real_departure_airport_time'] != '') {
281
					$temp_array['departure_airport_time'] = $row['real_departure_airport_time'];
282
				}
283
				if (isset($row['real_arrival_airport_time']) && $row['real_arrival_airport_time'] != '') {
284
					$temp_array['real_arrival_airport_time'] = $row['real_arrival_airport_time'];
285
				}
286
			}
287
			
288
			//if ($row['departure_airport_icao'] != '' && $row['departure_airport_name'] == '') {
289
			if ($row['departure_airport_icao'] != '') {
290
				$departure_airport_array = $this->getAllAirportInfo($row['departure_airport_icao']);
291
				if (!isset($departure_airport_array[0]['name'])) $departure_airport_array = $this->getAllAirportInfo('NA');
292
			/*
293
			} elseif ($row['departure_airport_name'] != '') {
294
				$temp_array['departure_airport_name'] = $row['departure_airport_name'];
295
				$temp_array['departure_airport_city'] = $row['departure_airport_city'];
296
				$temp_array['departure_airport_country'] = $row['departure_airport_country'];
297
				$temp_array['departure_airport_icao'] = $row['departure_airport_icao'];
298
			*/
299
			} else $departure_airport_array = $this->getAllAirportInfo('NA');
300
			if (isset($departure_airport_array[0]['name'])) {
301
				$temp_array['departure_airport_name'] = $departure_airport_array[0]['name'];
302
				$temp_array['departure_airport_city'] = $departure_airport_array[0]['city'];
303
				$temp_array['departure_airport_country'] = $departure_airport_array[0]['country'];
304
				$temp_array['departure_airport_iata'] = $departure_airport_array[0]['iata'];
305
				$temp_array['departure_airport_icao'] = $departure_airport_array[0]['icao'];
306
				$temp_array['departure_airport_latitude'] = $departure_airport_array[0]['latitude'];
307
				$temp_array['departure_airport_longitude'] = $departure_airport_array[0]['longitude'];
308
				$temp_array['departure_airport_altitude'] = $departure_airport_array[0]['altitude'];
309
			}
310
311
			/*
312
			if (isset($row['departure_airport_time'])) {
313
				$temp_array['departure_airport_time'] = $row['departure_airport_time'];
314
			}
315
			*/
316
			
317
			if ($row['arrival_airport_icao'] != '') {
318
				$arrival_airport_array = $this->getAllAirportInfo($row['arrival_airport_icao']);
319
				if (count($arrival_airport_array) == 0) $arrival_airport_array = $this->getAllAirportInfo('NA');
320
			} else $arrival_airport_array = $this->getAllAirportInfo('NA');
321
			if (isset($arrival_airport_array[0]['name'])) {
322
				$temp_array['arrival_airport_name'] = $arrival_airport_array[0]['name'];
323
				$temp_array['arrival_airport_city'] = $arrival_airport_array[0]['city'];
324
				$temp_array['arrival_airport_country'] = $arrival_airport_array[0]['country'];
325
				$temp_array['arrival_airport_iata'] = $arrival_airport_array[0]['iata'];
326
				$temp_array['arrival_airport_icao'] = $arrival_airport_array[0]['icao'];
327
				$temp_array['arrival_airport_latitude'] = $arrival_airport_array[0]['latitude'];
328
				$temp_array['arrival_airport_longitude'] = $arrival_airport_array[0]['longitude'];
329
				$temp_array['arrival_airport_altitude'] = $arrival_airport_array[0]['altitude'];
330
			}
331
			/*
332
			if (isset($row['arrival_airport_time'])) {
333
				$temp_array['arrival_airport_time'] = $row['arrival_airport_time'];
334
			}
335
			*/
336
			if (isset($row['pilot_id']) && $row['pilot_id'] != '') $temp_array['pilot_id'] = $row['pilot_id'];
337
			if (isset($row['pilot_name']) && $row['pilot_name'] != '') $temp_array['pilot_name'] = $row['pilot_name'];
338
			if (isset($row['source_name']) && $row['source_name'] != '') $temp_array['source_name'] = $row['source_name'];
339
			if (isset($row['over_country']) && $row['over_country'] != '') $temp_array['over_country'] = $row['over_country'];
340
			if (isset($row['distance']) && $row['distance'] != '') $temp_array['distance'] = $row['distance'];
341
			if (isset($row['squawk'])) {
342
				$temp_array['squawk'] = $row['squawk'];
343
				if ($row['squawk'] != '' && isset($temp_array['country_iso2'])) {
344
					$temp_array['squawk_usage'] = $this->getSquawkUsage($row['squawk'],$temp_array['country_iso2']);
345
					if ($temp_array['squawk_usage'] == '' && isset($globalSquawkCountry)) $temp_array['squawk_usage'] = $this->getSquawkUsage($row['squawk'],$globalSquawkCountry);
346
				} elseif ($row['squawk'] != '' && isset($temp_array['over_country'])) {
347
					$temp_array['squawk_usage'] = $this->getSquawkUsage($row['squawk'],$temp_array['over_country']);
348
					if ($temp_array['squawk_usage'] == '' && isset($globalSquawkCountry)) $temp_array['squawk_usage'] = $this->getSquawkUsage($row['squawk'],$globalSquawkCountry);
349
				} elseif ($row['squawk'] != '' && isset($globalSquawkCountry)) $temp_array['squawk_usage'] = $this->getSquawkUsage($row['squawk'],$globalSquawkCountry);
350
			}
351
    			
352
			$temp_array['query_number_rows'] = $num_rows;
353
			
354
			$spotter_array[] = $temp_array;
355
		}
356
		if ($num_rows == 0) return array();
357
		$spotter_array[0]['query_number_rows'] = $num_rows;
358
		return $spotter_array;
359
	}	
360
	
361
	
362
	/**
363
	* Gets all the spotter information
364
	*
365
	* @return Array the spotter information
366
	*
367
	*/
368
	public function searchSpotterData($q = '', $registration = '', $aircraft_icao = '', $aircraft_manufacturer = '', $highlights = '', $airline_icao = '', $airline_country = '', $airline_type = '', $airport = '', $airport_country = '', $callsign = '', $departure_airport_route = '', $arrival_airport_route = '', $owner = '',$pilot_id = '',$pilot_name = '',$altitude = '', $date_posted = '', $limit = '', $sort = '', $includegeodata = '',$origLat = '',$origLon = '',$dist = '')
369
	{
370
		global $globalTimezone, $globalDBdriver;
371
		require_once(dirname(__FILE__).'/class.Translation.php');
372
		$Translation = new Translation();
373
374
		date_default_timezone_set('UTC');
375
376
		$query_values = array();
377
		$additional_query = '';
378
		if ($q != "")
379
		{
380
			if (!is_string($q))
381
			{
382
				return false;
383
			} else {
384
				$q_array = explode(" ", $q);
385
				foreach ($q_array as $q_item){
386
					$q_item = filter_var($q_item,FILTER_SANITIZE_STRING);
387
					$additional_query .= " AND (";
388
					if (is_int($q_item)) $additional_query .= "(spotter_output.spotter_id like '%".$q_item."%') OR ";
389
					$additional_query .= "(spotter_output.aircraft_icao like '%".$q_item."%') OR ";
390
					$additional_query .= "(spotter_output.aircraft_name like '%".$q_item."%') OR ";
391
					$additional_query .= "(spotter_output.aircraft_manufacturer like '%".$q_item."%') OR ";
392
					$additional_query .= "(spotter_output.airline_icao like '%".$q_item."%') OR ";
393
					$additional_query .= "(spotter_output.airline_name like '%".$q_item."%') OR ";
394
					$additional_query .= "(spotter_output.airline_country like '%".$q_item."%') OR ";
395
					$additional_query .= "(spotter_output.departure_airport_icao like '%".$q_item."%') OR ";
396
					$additional_query .= "(spotter_output.departure_airport_name like '%".$q_item."%') OR ";
397
					$additional_query .= "(spotter_output.departure_airport_city like '%".$q_item."%') OR ";
398
					$additional_query .= "(spotter_output.departure_airport_country like '%".$q_item."%') OR ";
399
					$additional_query .= "(spotter_output.arrival_airport_icao like '%".$q_item."%') OR ";
400
					$additional_query .= "(spotter_output.arrival_airport_name like '%".$q_item."%') OR ";
401
					$additional_query .= "(spotter_output.arrival_airport_city like '%".$q_item."%') OR ";
402
					$additional_query .= "(spotter_output.arrival_airport_country like '%".$q_item."%') OR ";
403
					$additional_query .= "(spotter_output.registration like '%".$q_item."%') OR ";
404
					$additional_query .= "(spotter_output.owner_name like '%".$q_item."%') OR ";
405
					$additional_query .= "(spotter_output.pilot_id like '%".$q_item."%') OR ";
406
					$additional_query .= "(spotter_output.pilot_name like '%".$q_item."%') OR ";
407
					$additional_query .= "(spotter_output.ident like '%".$q_item."%') OR ";
408
					$translate = $Translation->ident2icao($q_item);
409
					if ($translate != $q_item) $additional_query .= "(spotter_output.ident like '%".$translate."%') OR ";
410
					$additional_query .= "(spotter_output.highlight like '%".$q_item."%')";
411
					$additional_query .= ")";
412
				}
413
			}
414
		}
415
416
		if ($registration != "")
417
		{
418
			$registration = filter_var($registration,FILTER_SANITIZE_STRING);
419
			if (!is_string($registration))
420
			{
421
				return false;
422
			} else {
423
				$additional_query .= " AND spotter_output.registration = :registration";
424
				$query_values = array_merge($query_values,array(':registration' => $registration));
425
			}
426
		}
427
428
		if ($aircraft_icao != "")
429
		{
430
			$aircraft_icao = filter_var($aircraft_icao,FILTER_SANITIZE_STRING);
431
			if (!is_string($aircraft_icao))
432
			{
433
				return false;
434
			} else {
435
				$additional_query .= " AND spotter_output.aircraft_icao = :aircraft_icao";
436
				$query_values = array_merge($query_values,array(':aircraft_icao' => $aircraft_icao));
437
			}
438
		}
439
440
		if ($aircraft_manufacturer != "")
441
		{
442
			$aircraft_manufacturer = filter_var($aircraft_manufacturer,FILTER_SANITIZE_STRING);
443
			if (!is_string($aircraft_manufacturer))
444
			{
445
				return false;
446
			} else {
447
				$additional_query .= " AND spotter_output.aircraft_manufacturer = :aircraft_manufacturer";
448
				$query_values = array_merge($query_values,array(':aircraft_manufacturer' => $aircraft_manufacturer));
449
			}
450
		}
451
452
		if ($highlights == "true")
453
		{
454
			if (!is_string($highlights))
455
			{
456
				return false;
457
			} else {
458
				$additional_query .= " AND (spotter_output.highlight <> '')";
459
			}
460
		}
461
462
		if ($airline_icao != "")
463
		{
464
			$airline_icao = filter_var($airline_icao,FILTER_SANITIZE_STRING);
465
			if (!is_string($airline_icao))
466
			{
467
				return false;
468
			} else {
469
				$additional_query .= " AND spotter_output.airline_icao = :airline_icao";
470
				$query_values = array_merge($query_values,array(':airline_icao' => $airline_icao));
471
			}
472
		}
473
474
		if ($airline_country != "")
475
		{
476
			$airline_country = filter_var($airline_country,FILTER_SANITIZE_STRING);
477
			if (!is_string($airline_country))
478
			{
479
				return false;
480
			} else {
481
				$additional_query .= " AND spotter_output.airline_country = :airline_country";
482
				$query_values = array_merge($query_values,array(':airline_country' => $airline_country));
483
			}
484
		}
485
486
		if ($airline_type != "")
487
		{
488
			if (!is_string($airline_type))
489
			{
490
				return false;
491
			} else {
492
				if ($airline_type == "passenger")
493
				{
494
					$additional_query .= " AND (spotter_output.airline_type = 'passenger')";
495
				}
496
				if ($airline_type == "cargo")
497
				{
498
					$additional_query .= " AND (spotter_output.airline_type = 'cargo')";
499
				}
500
				if ($airline_type == "military")
501
				{
502
					$additional_query .= " AND (spotter_output.airline_type = 'military')";
503
				}
504
			}
505
		}
506
507
		if ($airport != "")
508
		{
509
			$airport = filter_var($airport,FILTER_SANITIZE_STRING);
510
			if (!is_string($airport))
511
			{
512
				return false;
513
			} else {
514
				$additional_query .= " AND (spotter_output.departure_airport_icao = :airport OR spotter_output.arrival_airport_icao = :airport)";
515
				$query_values = array_merge($query_values,array(':airport' => $airport));
516
			}
517
		}
518
519
		if ($airport_country != "")
520
		{
521
			$airport_country = filter_var($airport_country,FILTER_SANITIZE_STRING);
522
			if (!is_string($airport_country))
523
			{
524
				return false;
525
			} else {
526
				$additional_query .= " AND (spotter_output.departure_airport_country = :airport_country OR spotter_output.arrival_airport_country = :airport_country)";
527
				$query_values = array_merge($query_values,array(':airport_country' => $airport_country));
528
			}
529
		}
530
    
531
		if ($callsign != "")
532
		{
533
			$callsign = filter_var($callsign,FILTER_SANITIZE_STRING);
534
			if (!is_string($callsign))
535
			{
536
				return false;
537
			} else {
538
				$translate = $Translation->ident2icao($callsign);
539
				if ($translate != $callsign) {
540
					$additional_query .= " AND (spotter_output.ident = :callsign OR spotter_output.ident = :translate)";
541
					$query_values = array_merge($query_values,array(':callsign' => $callsign,':translate' => $translate));
542
				} else {
543
					$additional_query .= " AND spotter_output.ident = :callsign";
544
					$query_values = array_merge($query_values,array(':callsign' => $callsign));
545
				}
546
			}
547
		}
548
549
		if ($owner != "")
550
		{
551
			$owner = filter_var($owner,FILTER_SANITIZE_STRING);
552
			if (!is_string($owner))
553
			{
554
				return false;
555
			} else {
556
				$additional_query .= " AND spotter_output.owner_name = :owner";
557
				$query_values = array_merge($query_values,array(':owner' => $owner));
558
			}
559
		}
560
561
		if ($pilot_name != "")
562
		{
563
			$pilot_name = filter_var($pilot_name,FILTER_SANITIZE_STRING);
564
			if (!is_string($pilot_name))
565
			{
566
				return false;
567
			} else {
568
				$additional_query .= " AND spotter_output.pilot_name = :pilot_name";
569
				$query_values = array_merge($query_values,array(':pilot_name' => $pilot_name));
570
			}
571
		}
572
573
		if ($pilot_id != "")
574
		{
575
			$pilot_id = filter_var($pilot_id,FILTER_SANITIZE_NUMBER_INT);
576
			if (!is_string($pilot_id))
577
			{
578
				return false;
579
			} else {
580
				$additional_query .= " AND spotter_output.pilot_id = :pilot_id";
581
				$query_values = array_merge($query_values,array(':pilot_id' => $pilot_id));
582
			}
583
		}
584
585
		if ($departure_airport_route != "")
586
		{
587
			$departure_airport_route = filter_var($departure_airport_route,FILTER_SANITIZE_STRING);
588
			if (!is_string($departure_airport_route))
589
			{
590
				return false;
591
			} else {
592
				$additional_query .= " AND spotter_output.departure_airport_icao = :departure_airport_route";
593
				$query_values = array_merge($query_values,array(':departure_airport_route' => $departure_airport_route));
594
			}
595
		}
596
597
		if ($arrival_airport_route != "")
598
		{
599
			$arrival_airport_route = filter_var($arrival_airport_route,FILTER_SANITIZE_STRING);
600
			if (!is_string($arrival_airport_route))
601
			{
602
				return false;
603
			} else {
604
				$additional_query .= " AND spotter_output.arrival_airport_icao = :arrival_airport_route";
605
				$query_values = array_merge($query_values,array(':arrival_airport_route' => $arrival_airport_route));
606
			}
607
		}
608
609
		if ($altitude != "")
610
		{
611
			$altitude_array = explode(",", $altitude);
612
			$altitude_array[0] = filter_var($altitude_array[0],FILTER_SANITIZE_NUMBER_FLOAT,FILTER_FLAG_ALLOW_FRACTION);
613
			$altitude_array[1] = filter_var($altitude_array[1],FILTER_SANITIZE_NUMBER_FLOAT,FILTER_FLAG_ALLOW_FRACTION);
614
615
			if ($altitude_array[1] != "")
616
			{                
617
				$altitude_array[0] = substr($altitude_array[0], 0, -2);
618
				$altitude_array[1] = substr($altitude_array[1], 0, -2);
619
				$additional_query .= " AND altitude BETWEEN '".$altitude_array[0]."' AND '".$altitude_array[1]."' ";
620
			} else {
621
				$altitude_array[0] = substr($altitude_array[0], 0, -2);
622
				$additional_query .= " AND altitude <= '".$altitude_array[0]."' ";
623
			}
624
		}
625
626
		if ($date_posted != "")
627
		{
628
			$date_array = explode(",", $date_posted);
629
			$date_array[0] = filter_var($date_array[0],FILTER_SANITIZE_STRING);
630
			$date_array[1] = filter_var($date_array[1],FILTER_SANITIZE_STRING);
631
632
			if ($globalTimezone != '') {
633
				date_default_timezone_set($globalTimezone);
634
				$datetime = new DateTime();
635
				$offset = $datetime->format('P');
636
			} else $offset = '+00:00';
637
638
			if ($date_array[1] != "")
639
			{
640
				$date_array[0] = date("Y-m-d H:i:s", strtotime($date_array[0]));
641
				$date_array[1] = date("Y-m-d H:i:s", strtotime($date_array[1]));
642
				if ($globalDBdriver == 'mysql') {
643
					$additional_query .= " AND TIMESTAMP(CONVERT_TZ(spotter_output.date,'+00:00', '".$offset."')) >= '".$date_array[0]."' AND TIMESTAMP(CONVERT_TZ(spotter_output.date,'+00:00', '".$offset."')) <= '".$date_array[1]."' ";
644
				} else {
645
					$additional_query .= " AND CAST(spotter_output.date AT TIME ZONE INTERVAL ".$offset." AS TIMESTAMP) >= '".$date_array[0]."' AND CAST(spotter_output.date AT TIME ZONE INTERVAL ".$offset." AS TIMESTAMP) <= '".$date_array[1]."' ";
646
				}
647
			} else {
648
				$date_array[0] = date("Y-m-d H:i:s", strtotime($date_array[0]));
649
				if ($globalDBdriver == 'mysql') {
650
					$additional_query .= " AND TIMESTAMP(CONVERT_TZ(spotter_output.date,'+00:00', '".$offset."')) >= '".$date_array[0]."' ";
651
				} else {
652
					$additional_query .= " AND CAST(spotter_output.date AT TIME ZONE INTERVAL ".$offset." AS TIMESTAMP) >= '".$date_array[0]."' ";
653
				}
654
			}
655
		}
656
657
		if ($limit != "")
658
		{
659
			$limit_array = explode(",", $limit);
660
			
661
			$limit_array[0] = filter_var($limit_array[0],FILTER_SANITIZE_NUMBER_INT);
662
			$limit_array[1] = filter_var($limit_array[1],FILTER_SANITIZE_NUMBER_INT);
663
			
664
			if ($limit_array[0] >= 0 && $limit_array[1] >= 0)
665
			{
666
				//$limit_query = " LIMIT ".$limit_array[0].",".$limit_array[1];
667
				$limit_query = " LIMIT ".$limit_array[1]." OFFSET ".$limit_array[0];
668
			} else $limit_query = "";
669
		} else $limit_query = "";
670
671
672
		if ($sort != "")
673
		{
674
			$search_orderby_array = $this->getOrderBy();
675
			$orderby_query = $search_orderby_array[$sort]['sql'];
676
		} else {
677
			if ($origLat != "" && $origLon != "" && $dist != "") {
678
				$orderby_query = "  ORDER BY distance ASC";
679
			} else {
680
				$orderby_query = " ORDER BY spotter_output.date DESC";
681
			}
682
		}
683
684
		if ($includegeodata == "true")
685
		{
686
			$additional_query .= " AND spotter_output.waypoints <> ''";
687
		}
688
689
690
		if ($origLat != "" && $origLon != "" && $dist != "") {
691
			$dist = number_format($dist*0.621371,2,'.',''); // convert km to mile
692
693
			if ($globalDBdriver == 'mysql') {
694
				$query="SELECT spotter_output.*, 1.60935*3956 * 2 * ASIN(SQRT( POWER(SIN(($origLat - spotter_archive.latitude)*pi()/180/2),2)+COS( $origLat *pi()/180)*COS(spotter_archive.latitude*pi()/180)*POWER(SIN(($origLon-spotter_archive.longitude)*pi()/180/2),2))) as distance 
695
						FROM spotter_output, spotter_archive WHERE spotter_output.flightaware_id = spotter_archive.flightaware_id AND spotter_output.ident <> '' ".$additional_query."AND spotter_archive.longitude between ($origLon-$dist/cos(radians($origLat))*69) and ($origLon+$dist/cos(radians($origLat)*69)) and spotter_archive.latitude between ($origLat-($dist/69)) and ($origLat+($dist/69)) 
696
						AND (3956 * 2 * ASIN(SQRT( POWER(SIN(($origLat - spotter_archive.latitude)*pi()/180/2),2)+COS( $origLat *pi()/180)*COS(spotter_archive.latitude*pi()/180)*POWER(SIN(($origLon-spotter_archive.longitude)*pi()/180/2),2)))) < $dist".$orderby_query;
697
			} else {
698
				$query="SELECT spotter_output.*, 1.60935 * 3956 * 2 * ASIN(SQRT( POWER(SIN(($origLat - CAST(spotter_archive.latitude as double precision))*pi()/180/2),2)+COS( $origLat *pi()/180)*COS(CAST(spotter_archive.latitude as double precision)*pi()/180)*POWER(SIN(($origLon-CAST(spotter_archive.longitude as double precision))*pi()/180/2),2))) as distance 
699
						FROM spotter_output, spotter_archive WHERE spotter_output.flightaware_id = spotter_archive.flightaware_id AND spotter_output.ident <> '' ".$additional_query."AND CAST(spotter_archive.longitude as double precision) between ($origLon-$dist/cos(radians($origLat))*69) and ($origLon+$dist/cos(radians($origLat))*69) and CAST(spotter_archive.latitude as double precision) between ($origLat-($dist/69)) and ($origLat+($dist/69)) 
700
						AND (3956 * 2 * ASIN(SQRT( POWER(SIN(($origLat - CAST(spotter_archive.latitude as double precision))*pi()/180/2),2)+COS( $origLat *pi()/180)*COS(CAST(spotter_archive.latitude as double precision)*pi()/180)*POWER(SIN(($origLon-CAST(spotter_archive.longitude as double precision))*pi()/180/2),2)))) < $dist".$orderby_query;
701
			}
702
		} else {		
703
			$query  = "SELECT spotter_output.* FROM spotter_output 
704
					WHERE spotter_output.ident <> '' 
705
					".$additional_query."
706
					".$orderby_query;
707
		}
708
		$spotter_array = $this->getDataFromDB($query, $query_values,$limit_query);
709
		return $spotter_array;
710
	}
711
	
712
	
713
	/**
714
	* Gets all the spotter information based on the latest data entry
715
	*
716
	* @return Array the spotter information
717
	*
718
	*/
719
	public function getLatestSpotterData($limit = '', $sort = '')
720
	{
721
		global $global_query;
722
		
723
		date_default_timezone_set('UTC');
724
		
725
		if ($limit != "")
726
		{
727
			$limit_array = explode(",", $limit);
728
			
729
			$limit_array[0] = filter_var($limit_array[0],FILTER_SANITIZE_NUMBER_INT);
730
			$limit_array[1] = filter_var($limit_array[1],FILTER_SANITIZE_NUMBER_INT);
731
			
732
			if ($limit_array[0] >= 0 && $limit_array[1] >= 0)
733
			{
734
				//$limit_query = " LIMIT ".$limit_array[0].",".$limit_array[1];
735
				$limit_query = " LIMIT ".$limit_array[1]." OFFSET ".$limit_array[0];
736
			} else $limit_query = "";
737
		} else $limit_query = "";
738
		
739
		if ($sort != "")
740
		{
741
			$search_orderby_array = $this->getOrderBy();
742
			$orderby_query = $search_orderby_array[$sort]['sql'];
743
		} else {
744
			$orderby_query = " ORDER BY spotter_output.date DESC";
745
		}
746
747
		$query  = $global_query." ".$orderby_query;
748
749
		$spotter_array = $this->getDataFromDB($query, array(),$limit_query);
750
751
		return $spotter_array;
752
	}
753
    
754
    
755
    /**
756
	* Gets all the spotter information based on a user's latitude and longitude
757
	*
758
	* @return Array the spotter information
759
	*
760
	*/
761
	public function getLatestSpotterForLayar($lat, $lng, $radius, $interval)
762
	{
763
		date_default_timezone_set('UTC');
764
		$limit_query = '';
765
		if ($lat != "")
766
		{
767
			if (!is_numeric($lat))
768
			{
769
				return false;
770
			}
771
		}
772
        
773
		if ($lng != "")
774
		{
775
			if (!is_numeric($lng))
776
			{
777
				return false;
778
			}
779
		}
780
		
781
		if ($radius != "")
782
		{
783
			if (!is_numeric($radius))
784
			{
785
				return false;
786
			}
787
		}
788
    		$additional_query = '';
789
		if ($interval != "")
790
		{
791
			if (!is_string($interval))
792
			{
793
				return false;
794
			} else {
795
				if ($interval == "30m"){
796
					$additional_query = ' AND DATE_SUB(UTC_TIMESTAMP(),INTERVAL 30 MINUTE) <= $this_output.date ';
797
				} else if ($interval == "1h"){
798
					$additional_query = ' AND DATE_SUB(UTC_TIMESTAMP(),INTERVAL 1 HOUR) <= $this_output.date ';
799
				} else if ($interval == "3h"){
800
					$additional_query = ' AND DATE_SUB(UTC_TIMESTAMP(),INTERVAL 3 HOUR) <= $this_output.date ';
801
				} else if ($interval == "6h"){
802
					$additional_query = ' AND DATE_SUB(UTC_TIMESTAMP(),INTERVAL 6 HOUR) <= $this_output.date ';
803
				} else if ($interval == "12h"){
804
					$additional_query = ' AND DATE_SUB(UTC_TIMESTAMP(),INTERVAL 12 HOUR) <= $this_output.date ';
805
				} else if ($interval == "24h"){
806
					$additional_query = ' AND DATE_SUB(UTC_TIMESTAMP(),INTERVAL 24 HOUR) <= $this_output.date ';
807
				} else if ($interval == "7d"){
808
					$additional_query = ' AND DATE_SUB(UTC_TIMESTAMP(),INTERVAL 7 DAY) <= $this_output.date ';
809
				} else if ($interval == "30d"){
810
					$additional_query = ' AND DATE_SUB(UTC_TIMESTAMP(),INTERVAL 30 DAY) <= $this_output.date ';
811
				} 
812
			}
813
		}
814
815
		$query  = "SELECT spotter_output.*, ( 6371 * acos( cos( radians($lat) ) * cos( radians( latitude ) ) * cos( radians( longitude ) - radians($lng) ) + sin( radians($lat) ) * sin( radians( latitude ) ) ) ) AS distance FROM spotter_output 
816
                   WHERE spotter_output.latitude <> '' 
817
				   AND spotter_output.longitude <> '' 
818
                   ".$additional_query."
819
                   HAVING distance < :radius  
820
				   ORDER BY distance";
821
822
		$spotter_array = $this->getDataFromDB($query, array(':radius' => $radius),$limit_query);
823
824
		return $spotter_array;
825
	}
826
    
827
    
828
    /**
829
	* Gets all the spotter information sorted by the newest aircraft type
830
	*
831
	* @return Array the spotter information
832
	*
833
	*/
834
	public function getNewestSpotterDataSortedByAircraftType($limit = '', $sort = '')
835
	{
836
		global $global_query;
837
		
838
		date_default_timezone_set('UTC');
839
		$limit_query = '';
840
		if ($limit != "")
841
		{
842
			$limit_array = explode(",", $limit);
843
			
844
			$limit_array[0] = filter_var($limit_array[0],FILTER_SANITIZE_NUMBER_INT);
845
			$limit_array[1] = filter_var($limit_array[1],FILTER_SANITIZE_NUMBER_INT);
846
			
847
			if ($limit_array[0] >= 0 && $limit_array[1] >= 0)
848
			{
849
				//$limit_query = " LIMIT ".$limit_array[0].",".$limit_array[1];
850
				$limit_query = " LIMIT ".$limit_array[1]." OFFSET ".$limit_array[0];
851
			}
852
		}
853
		
854
		if ($sort != "")
855
		{
856
			$search_orderby_array = $this->getOrderBy();
857
			$orderby_query = $search_orderby_array[$sort]['sql'];
858
		} else {
859
			$orderby_query = " ORDER BY spotter_output.date DESC ";
860
		}
861
862
		$query  = $global_query." WHERE spotter_output.aircraft_name <> '' GROUP BY spotter_output.aircraft_icao,spotter_output.ident,spotter_output.spotter_id, spotter_output.flightaware_id, spotter_output.registration,spotter_output.airline_name,spotter_output.airline_icao,spotter_output.airline_country,spotter_output.airline_type,spotter_output.aircraft_icao,spotter_output.aircraft_name,spotter_output.aircraft_manufacturer,spotter_output.departure_airport_icao,spotter_output.departure_airport_name,spotter_output.departure_airport_city,spotter_output.departure_airport_country,spotter_output.departure_airport_time,spotter_output.arrival_airport_icao,spotter_output.arrival_airport_name,spotter_output.arrival_airport_city,spotter_output.arrival_airport_country,spotter_output.arrival_airport_time,spotter_output.route_stop,spotter_output.date,spotter_output.latitude,spotter_output.longitude,spotter_output.waypoints,spotter_output.altitude,spotter_output.heading,spotter_output.ground_speed,spotter_output.highlight,spotter_output.squawk,spotter_output.ModeS,spotter_output.pilot_id,spotter_output.pilot_name,spotter_output.verticalrate,spotter_output.owner_name,spotter_output.format_source,spotter_output.source_name,spotter_output.ground,spotter_output.last_ground,spotter_output.last_seen,spotter_output.last_latitude,spotter_output.last_longitude,spotter_output.last_altitude,spotter_output.last_ground_speed,spotter_output.real_arrival_airport_icao,spotter_output.real_arrival_airport_time ".$orderby_query;
863
864
		$spotter_array = $this->getDataFromDB($query, array(), $limit_query);
865
866
		return $spotter_array;
867
	}
868
    
869
    
870
    /**
871
	* Gets all the spotter information sorted by the newest aircraft registration
872
	*
873
	* @return Array the spotter information
874
	*
875
	*/
876
	public function getNewestSpotterDataSortedByAircraftRegistration($limit = '', $sort = '')
877
	{
878
		global $global_query;
879
		
880
		date_default_timezone_set('UTC');
881
		$limit_query = '';
882
		
883
		if ($limit != "")
884
		{
885
			$limit_array = explode(",", $limit);
886
			
887
			$limit_array[0] = filter_var($limit_array[0],FILTER_SANITIZE_NUMBER_INT);
888
			$limit_array[1] = filter_var($limit_array[1],FILTER_SANITIZE_NUMBER_INT);
889
			
890
			if ($limit_array[0] >= 0 && $limit_array[1] >= 0)
891
			{
892
				//$limit_query = " LIMIT ".$limit_array[0].",".$limit_array[1];
893
				$limit_query = " LIMIT ".$limit_array[1]." OFFSET ".$limit_array[0];
894
			}
895
		}
896
		
897
		if ($sort != "")
898
		{
899
			$search_orderby_array = $this->getOrderBy();
900
			$orderby_query = $search_orderby_array[$sort]['sql'];
901
		} else {
902
			$orderby_query = " ORDER BY spotter_output.date DESC ";
903
		}
904
905
		$query  = $global_query." WHERE spotter_output.registration <> '' GROUP BY spotter_output.registration,spotter_output.ident,spotter_output.spotter_id, spotter_output.flightaware_id, spotter_output.registration,spotter_output.airline_name,spotter_output.airline_icao,spotter_output.airline_country,spotter_output.airline_type,spotter_output.aircraft_icao,spotter_output.aircraft_name,spotter_output.aircraft_manufacturer,spotter_output.departure_airport_icao,spotter_output.departure_airport_name,spotter_output.departure_airport_city,spotter_output.departure_airport_country,spotter_output.departure_airport_time,spotter_output.arrival_airport_icao,spotter_output.arrival_airport_name,spotter_output.arrival_airport_city,spotter_output.arrival_airport_country,spotter_output.arrival_airport_time,spotter_output.route_stop,spotter_output.date,spotter_output.latitude,spotter_output.longitude,spotter_output.waypoints,spotter_output.altitude,spotter_output.heading,spotter_output.ground_speed,spotter_output.highlight,spotter_output.squawk,spotter_output.ModeS,spotter_output.pilot_id,spotter_output.pilot_name,spotter_output.verticalrate,spotter_output.owner_name,spotter_output.format_source,spotter_output.source_name,spotter_output.ground,spotter_output.last_ground,spotter_output.last_seen,spotter_output.last_latitude,spotter_output.last_longitude,spotter_output.last_altitude,spotter_output.last_ground_speed,spotter_output.real_arrival_airport_icao,spotter_output.real_arrival_airport_time ".$orderby_query;
906
907
		$spotter_array = $this->getDataFromDB($query, array(), $limit_query);
908
909
		return $spotter_array;
910
	}
911
    
912
    
913
    /**
914
	* Gets all the spotter information sorted by the newest airline
915
	*
916
	* @return Array the spotter information
917
	*
918
	*/
919
	public function getNewestSpotterDataSortedByAirline($limit = '', $sort = '')
920
	{
921
		global $global_query;
922
		
923
		date_default_timezone_set('UTC');
924
		$limit_query = '';
925
		if ($limit != "")
926
		{
927
			$limit_array = explode(",", $limit);
928
			
929
			$limit_array[0] = filter_var($limit_array[0],FILTER_SANITIZE_NUMBER_INT);
930
			$limit_array[1] = filter_var($limit_array[1],FILTER_SANITIZE_NUMBER_INT);
931
			
932
			if ($limit_array[0] >= 0 && $limit_array[1] >= 0)
933
			{
934
				//$limit_query = " LIMIT ".$limit_array[0].",".$limit_array[1];
935
				$limit_query = " LIMIT ".$limit_array[1]." OFFSET ".$limit_array[0];
936
			}
937
		}
938
		
939
		if ($sort != "")
940
		{
941
			$search_orderby_array = $this->getOrderBy();
942
			$orderby_query = $search_orderby_array[$sort]['sql'];
943
		} else {
944
			$orderby_query = " ORDER BY spotter_output.date DESC ";
945
		}
946
947
		$query  = $global_query." WHERE spotter_output.airline_name <> '' GROUP BY spotter_output.airline_icao,spotter_output.ident,spotter_output.spotter_id, spotter_output.flightaware_id, spotter_output.registration,spotter_output.airline_name,spotter_output.airline_icao,spotter_output.airline_country,spotter_output.airline_type,spotter_output.aircraft_icao,spotter_output.aircraft_name,spotter_output.aircraft_manufacturer,spotter_output.departure_airport_icao,spotter_output.departure_airport_name,spotter_output.departure_airport_city,spotter_output.departure_airport_country,spotter_output.departure_airport_time,spotter_output.arrival_airport_icao,spotter_output.arrival_airport_name,spotter_output.arrival_airport_city,spotter_output.arrival_airport_country,spotter_output.arrival_airport_time,spotter_output.route_stop,spotter_output.date,spotter_output.latitude,spotter_output.longitude,spotter_output.waypoints,spotter_output.altitude,spotter_output.heading,spotter_output.ground_speed,spotter_output.highlight,spotter_output.squawk,spotter_output.ModeS,spotter_output.pilot_id,spotter_output.pilot_name,spotter_output.verticalrate,spotter_output.owner_name,spotter_output.format_source,spotter_output.source_name,spotter_output.ground,spotter_output.last_ground,spotter_output.last_seen,spotter_output.last_latitude,spotter_output.last_longitude,spotter_output.last_altitude,spotter_output.last_ground_speed,spotter_output.real_arrival_airport_icao,spotter_output.real_arrival_airport_time ".$orderby_query;
948
949
		$spotter_array = $this->getDataFromDB($query, array(), $limit_query);
950
951
		return $spotter_array;
952
	}
953
    
954
    
955
    /**
956
	* Gets all the spotter information sorted by the newest departure airport
957
	*
958
	* @return Array the spotter information
959
	*
960
	*/
961
	public function getNewestSpotterDataSortedByDepartureAirport($limit = '', $sort = '')
962
	{
963
		global $global_query;
964
		
965
		date_default_timezone_set('UTC');
966
		$limit_query = '';
967
		
968
		if ($limit != "")
969
		{
970
			$limit_array = explode(",", $limit);
971
			
972
			$limit_array[0] = filter_var($limit_array[0],FILTER_SANITIZE_NUMBER_INT);
973
			$limit_array[1] = filter_var($limit_array[1],FILTER_SANITIZE_NUMBER_INT);
974
			
975
			if ($limit_array[0] >= 0 && $limit_array[1] >= 0)
976
			{
977
				//$limit_query = " LIMIT ".$limit_array[0].",".$limit_array[1];
978
				$limit_query = " LIMIT ".$limit_array[1]." OFFSET ".$limit_array[0];
979
			}
980
		}
981
		
982
		if ($sort != "")
983
		{
984
			$search_orderby_array = $this->getOrderBy();
985
			$orderby_query = $search_orderby_array[$sort]['sql'];
986
		} else {
987
			$orderby_query = " ORDER BY spotter_output.date DESC ";
988
		}
989
990
		$query  = $global_query." WHERE spotter_output.departure_airport_name <> '' AND spotter_output.departure_airport_icao <> 'NA' GROUP BY spotter_output.departure_airport_icao,spotter_output.ident,spotter_output.spotter_id, spotter_output.flightaware_id, spotter_output.registration,spotter_output.airline_name,spotter_output.airline_icao,spotter_output.airline_country,spotter_output.airline_type,spotter_output.aircraft_icao,spotter_output.aircraft_name,spotter_output.aircraft_manufacturer,spotter_output.departure_airport_icao,spotter_output.departure_airport_name,spotter_output.departure_airport_city,spotter_output.departure_airport_country,spotter_output.departure_airport_time,spotter_output.arrival_airport_icao,spotter_output.arrival_airport_name,spotter_output.arrival_airport_city,spotter_output.arrival_airport_country,spotter_output.arrival_airport_time,spotter_output.route_stop,spotter_output.date,spotter_output.latitude,spotter_output.longitude,spotter_output.waypoints,spotter_output.altitude,spotter_output.heading,spotter_output.ground_speed,spotter_output.highlight,spotter_output.squawk,spotter_output.ModeS,spotter_output.pilot_id,spotter_output.pilot_name,spotter_output.verticalrate,spotter_output.owner_name,spotter_output.format_source,spotter_output.source_name,spotter_output.ground,spotter_output.last_ground,spotter_output.last_seen,spotter_output.last_latitude,spotter_output.last_longitude,spotter_output.last_altitude,spotter_output.last_ground_speed,spotter_output.real_arrival_airport_icao,spotter_output.real_arrival_airport_time ".$orderby_query;
991
992
		$spotter_array = $this->getDataFromDB($query, array(), $limit_query);
993
994
		return $spotter_array;
995
	}
996
    
997
    
998
    /**
999
	* Gets all the spotter information sorted by the newest arrival airport
1000
	*
1001
	* @return Array the spotter information
1002
	*
1003
	*/
1004
	public function getNewestSpotterDataSortedByArrivalAirport($limit = '', $sort = '')
1005
	{
1006
		global $global_query;
1007
		
1008
		date_default_timezone_set('UTC');
1009
		$limit_query = '';
1010
		
1011
		if ($limit != "")
1012
		{
1013
			$limit_array = explode(",", $limit);
1014
			
1015
			$limit_array[0] = filter_var($limit_array[0],FILTER_SANITIZE_NUMBER_INT);
1016
			$limit_array[1] = filter_var($limit_array[1],FILTER_SANITIZE_NUMBER_INT);
1017
			
1018
			if ($limit_array[0] >= 0 && $limit_array[1] >= 0)
1019
			{
1020
				//$limit_query = " LIMIT ".$limit_array[0].",".$limit_array[1];
1021
				$limit_query = " LIMIT ".$limit_array[1]." OFFSET ".$limit_array[0];
1022
			}
1023
		}
1024
		
1025
		if ($sort != "")
1026
		{
1027
			$search_orderby_array = $this->getOrderBy();
1028
			$orderby_query = $search_orderby_array[$sort]['sql'];
1029
		} else {
1030
			$orderby_query = " ORDER BY spotter_output.date DESC ";
1031
		}
1032
1033
		$query  = $global_query." WHERE spotter_output.arrival_airport_name <> '' AND spotter_output.arrival_airport_icao <> 'NA' GROUP BY spotter_output.arrival_airport_icao,spotter_output.ident,spotter_output.spotter_id, spotter_output.flightaware_id, spotter_output.registration,spotter_output.airline_name,spotter_output.airline_icao,spotter_output.airline_country,spotter_output.airline_type,spotter_output.aircraft_icao,spotter_output.aircraft_name,spotter_output.aircraft_manufacturer,spotter_output.departure_airport_icao,spotter_output.departure_airport_name,spotter_output.departure_airport_city,spotter_output.departure_airport_country,spotter_output.departure_airport_time,spotter_output.arrival_airport_icao,spotter_output.arrival_airport_name,spotter_output.arrival_airport_city,spotter_output.arrival_airport_country,spotter_output.arrival_airport_time,spotter_output.route_stop,spotter_output.date,spotter_output.latitude,spotter_output.longitude,spotter_output.waypoints,spotter_output.altitude,spotter_output.heading,spotter_output.ground_speed,spotter_output.highlight,spotter_output.squawk,spotter_output.ModeS,spotter_output.pilot_id,spotter_output.pilot_name,spotter_output.verticalrate,spotter_output.owner_name,spotter_output.format_source,spotter_output.source_name,spotter_output.ground,spotter_output.last_ground,spotter_output.last_seen,spotter_output.last_latitude,spotter_output.last_longitude,spotter_output.last_altitude,spotter_output.last_ground_speed,spotter_output.real_arrival_airport_icao,spotter_output.real_arrival_airport_time ".$orderby_query;
1034
1035
		$spotter_array = $this->getDataFromDB($query, array(), $limit_query);
1036
1037
		return $spotter_array;
1038
	}
1039
	
1040
1041
	/**
1042
	* Gets all the spotter information based on the spotter id
1043
	*
1044
	* @return Array the spotter information
1045
	*
1046
	*/
1047
	public function getSpotterDataByID($id = '')
1048
	{
1049
		global $global_query;
1050
		
1051
		date_default_timezone_set('UTC');
1052
		$query_values = array();
0 ignored issues
show
Unused Code introduced by
$query_values is not used, you could remove the assignment.

This check looks for variable assignements that are either overwritten by other assignments or where the variable is not used subsequently.

$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}

Both the $myVar assignment in line 1 and the $higher assignment in line 2 are dead. The first because $myVar is never used and the second because $higher is always overwritten for every possible time line.

Loading history...
1053
		$additional_query = '';
0 ignored issues
show
Unused Code introduced by
$additional_query is not used, you could remove the assignment.

This check looks for variable assignements that are either overwritten by other assignments or where the variable is not used subsequently.

$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}

Both the $myVar assignment in line 1 and the $higher assignment in line 2 are dead. The first because $myVar is never used and the second because $higher is always overwritten for every possible time line.

Loading history...
1054
		if ($id == '') return array();
1055
		$additional_query = "spotter_output.spotter_id = :id";
1056
		$query_values = array(':id' => $id);
1057
1058
		//$query  = $global_query." WHERE spotter_output.ident <> '' ".$additional_query." ";
1059
		$query  = $global_query." WHERE ".$additional_query." ";
1060
1061
		$spotter_array = $this->getDataFromDB($query,$query_values);
1062
1063
		return $spotter_array;
1064
	}
1065
1066
	
1067
	
1068
	
1069
	/**
1070
	* Gets all the spotter information based on the callsign
1071
	*
1072
	* @return Array the spotter information
1073
	*
1074
	*/
1075
	public function getSpotterDataByIdent($ident = '', $limit = '', $sort = '')
1076
	{
1077
		global $global_query;
1078
		
1079
		date_default_timezone_set('UTC');
1080
		
1081
		$query_values = array();
1082
		$limit_query = '';
1083
		$additional_query = '';
1084
		if ($ident != "")
1085
		{
1086
			if (!is_string($ident))
1087
			{
1088
				return false;
1089
			} else {
1090
				$additional_query = " AND (spotter_output.ident = :ident)";
1091
				$query_values = array(':ident' => $ident);
1092
			}
1093
		}
1094
		
1095
		if ($limit != "")
1096
		{
1097
			$limit_array = explode(",", $limit);
1098
			
1099
			$limit_array[0] = filter_var($limit_array[0],FILTER_SANITIZE_NUMBER_INT);
1100
			$limit_array[1] = filter_var($limit_array[1],FILTER_SANITIZE_NUMBER_INT);
1101
			
1102
			if ($limit_array[0] >= 0 && $limit_array[1] >= 0)
1103
			{
1104
				//$limit_query = " LIMIT ".$limit_array[0].",".$limit_array[1];
1105
				$limit_query = " LIMIT ".$limit_array[1]." OFFSET ".$limit_array[0];
1106
			}
1107
		}
1108
1109
		if ($sort != "")
1110
		{
1111
			$search_orderby_array = $this->getOrderBy();
1112
			$orderby_query = $search_orderby_array[$sort]['sql'];
1113
		} else {
1114
			$orderby_query = " ORDER BY spotter_output.date DESC";
1115
		}
1116
1117
		$query = $global_query." WHERE spotter_output.ident <> '' ".$additional_query." ".$orderby_query;
1118
1119
		$spotter_array = $this->getDataFromDB($query, $query_values, $limit_query);
1120
1121
		return $spotter_array;
1122
	}
1123
	
1124
	
1125
	
1126
	/**
1127
	* Gets all the spotter information based on the aircraft type
1128
	*
1129
	* @return Array the spotter information
1130
	*
1131
	*/
1132
	public function getSpotterDataByAircraft($aircraft_type = '', $limit = '', $sort = '')
1133
	{
1134
		global $global_query;
1135
		
1136
		date_default_timezone_set('UTC');
1137
		
1138
		$query_values = array();
1139
		$limit_query = '';
1140
		$additional_query = '';
1141
		
1142
		if ($aircraft_type != "")
1143
		{
1144
			if (!is_string($aircraft_type))
1145
			{
1146
				return false;
1147
			} else {
1148
				$additional_query = " AND (spotter_output.aircraft_icao = :aircraft_type)";
1149
				$query_values = array(':aircraft_type' => $aircraft_type);
1150
			}
1151
		}
1152
		
1153
		if ($limit != "")
1154
		{
1155
			$limit_array = explode(",", $limit);
1156
			
1157
			$limit_array[0] = filter_var($limit_array[0],FILTER_SANITIZE_NUMBER_INT);
1158
			$limit_array[1] = filter_var($limit_array[1],FILTER_SANITIZE_NUMBER_INT);
1159
			
1160
			if ($limit_array[0] >= 0 && $limit_array[1] >= 0)
1161
			{
1162
				//$limit_query = " LIMIT ".$limit_array[0].",".$limit_array[1];
1163
				$limit_query = " LIMIT ".$limit_array[1]." OFFSET ".$limit_array[0];
1164
			}
1165
		}
1166
1167
		if ($sort != "")
1168
		{
1169
			$search_orderby_array = $this->getOrderBy();
1170
			$orderby_query = $search_orderby_array[$sort]['sql'];
1171
		} else {
1172
			$orderby_query = " ORDER BY spotter_output.date DESC";
1173
		}
1174
1175
		$query = $global_query." WHERE spotter_output.ident <> '' ".$additional_query." ".$orderby_query;
1176
1177
		$spotter_array = $this->getDataFromDB($query, $query_values, $limit_query);
1178
1179
		return $spotter_array;
1180
	}
1181
	
1182
	
1183
	/**
1184
	* Gets all the spotter information based on the aircraft registration
1185
	*
1186
	* @return Array the spotter information
1187
	*
1188
	*/
1189
	public function getSpotterDataByRegistration($registration = '', $limit = '', $sort = '')
1190
	{
1191
		global $global_query;
1192
		
1193
		date_default_timezone_set('UTC');
1194
		
1195
		$query_values = array();
1196
		$limit_query = '';
1197
		$additional_query = '';
1198
		
1199
		if ($registration != "")
1200
		{
1201
			if (!is_string($registration))
1202
			{
1203
				return false;
1204
			} else {
1205
				$additional_query = " AND (spotter_output.registration = :registration)";
1206
				$query_values = array(':registration' => $registration);
1207
			}
1208
		}
1209
		
1210
		if ($limit != "")
1211
		{
1212
			$limit_array = explode(",", $limit);
1213
			
1214
			$limit_array[0] = filter_var($limit_array[0],FILTER_SANITIZE_NUMBER_INT);
1215
			$limit_array[1] = filter_var($limit_array[1],FILTER_SANITIZE_NUMBER_INT);
1216
			
1217
			if ($limit_array[0] >= 0 && $limit_array[1] >= 0)
1218
			{
1219
				//$limit_query = " LIMIT ".$limit_array[0].",".$limit_array[1];
1220
				$limit_query = " LIMIT ".$limit_array[1]." OFFSET ".$limit_array[0];
1221
			}
1222
		}
1223
1224
		if ($sort != "")
1225
		{
1226
			$search_orderby_array = $this->getOrderBy();
1227
			$orderby_query = $search_orderby_array[$sort]['sql'];
1228
		} else {
1229
			$orderby_query = " ORDER BY spotter_output.date DESC";
1230
		}
1231
1232
		$query = $global_query." WHERE spotter_output.ident <> '' ".$additional_query." ".$orderby_query;
1233
1234
		$spotter_array = $this->getDataFromDB($query, $query_values, $limit_query);
1235
1236
		return $spotter_array;
1237
	}
1238
1239
	
1240
	
1241
	
1242
	/**
1243
	* Gets all the spotter information based on the airline
1244
	*
1245
	* @return Array the spotter information
1246
	*
1247
	*/
1248
	public function getSpotterDataByAirline($airline = '', $limit = '', $sort = '')
1249
	{
1250
		global $global_query;
1251
		
1252
		date_default_timezone_set('UTC');
1253
1254
		$query_values = array();
1255
		$limit_query = '';
1256
		$additional_query = '';
1257
		
1258
		if ($airline != "")
1259
		{
1260
			if (!is_string($airline))
1261
			{
1262
				return false;
1263
			} else {
1264
				$additional_query = " AND (spotter_output.airline_icao = :airline)";
1265
				$query_values = array(':airline' => $airline);
1266
			}
1267
		}
1268
		
1269
		if ($limit != "")
1270
		{
1271
			$limit_array = explode(",", $limit);
1272
			
1273
			$limit_array[0] = filter_var($limit_array[0],FILTER_SANITIZE_NUMBER_INT);
1274
			$limit_array[1] = filter_var($limit_array[1],FILTER_SANITIZE_NUMBER_INT);
1275
			
1276
			if ($limit_array[0] >= 0 && $limit_array[1] >= 0)
1277
			{
1278
				//$limit_query = " LIMIT ".$limit_array[0].",".$limit_array[1];
1279
				$limit_query = " LIMIT ".$limit_array[1]." OFFSET ".$limit_array[0];
1280
			}
1281
		}
1282
		
1283
		if ($sort != "")
1284
		{
1285
			$search_orderby_array = $this->getOrderBy();
1286
			$orderby_query = $search_orderby_array[$sort]['sql'];
1287
		} else {
1288
			$orderby_query = " ORDER BY spotter_output.date DESC";
1289
		}
1290
1291
		$query = $global_query." WHERE spotter_output.ident <> '' ".$additional_query." ".$orderby_query;
1292
		$spotter_array = $this->getDataFromDB($query, $query_values, $limit_query);
1293
1294
		return $spotter_array;
1295
	}
1296
	
1297
	
1298
	/**
1299
	* Gets all the spotter information based on the airport
1300
	*
1301
	* @return Array the spotter information
1302
	*
1303
	*/
1304
	public function getSpotterDataByAirport($airport = '', $limit = '', $sort = '')
1305
	{
1306
		global $global_query;
1307
		
1308
		date_default_timezone_set('UTC');
1309
		$query_values = array();
1310
		$limit_query = '';
1311
		$additional_query = '';
1312
		
1313
		if ($airport != "")
1314
		{
1315
			if (!is_string($airport))
1316
			{
1317
				return false;
1318
			} else {
1319
				$additional_query .= " AND ((spotter_output.departure_airport_icao = :airport) OR (spotter_output.arrival_airport_icao = :airport))";
1320
				$query_values = array(':airport' => $airport);
1321
			}
1322
		}
1323
		
1324
		if ($limit != "")
1325
		{
1326
			$limit_array = explode(",", $limit);
1327
			
1328
			$limit_array[0] = filter_var($limit_array[0],FILTER_SANITIZE_NUMBER_INT);
1329
			$limit_array[1] = filter_var($limit_array[1],FILTER_SANITIZE_NUMBER_INT);
1330
			
1331
			if ($limit_array[0] >= 0 && $limit_array[1] >= 0)
1332
			{
1333
				//$limit_query = " LIMIT ".$limit_array[0].",".$limit_array[1];
1334
				$limit_query = " LIMIT ".$limit_array[1]." OFFSET ".$limit_array[0];
1335
			}
1336
		}
1337
		
1338
		if ($sort != "")
1339
		{
1340
			$search_orderby_array = $this->getOrderBy();
1341
			$orderby_query = $search_orderby_array[$sort]['sql'];
1342
		} else {
1343
			$orderby_query = " ORDER BY spotter_output.date DESC";
1344
		}
1345
1346
		$query = $global_query." WHERE spotter_output.ident <> '' ".$additional_query." AND ((spotter_output.departure_airport_icao <> 'NA') AND (spotter_output.arrival_airport_icao <> 'NA')) ".$orderby_query;
1347
1348
		$spotter_array = $this->getDataFromDB($query, $query_values, $limit_query);
1349
1350
		return $spotter_array;
1351
	}
1352
1353
1354
1355
	/**
1356
	* Gets all the spotter information based on the date
1357
	*
1358
	* @return Array the spotter information
1359
	*
1360
	*/
1361
	public function getSpotterDataByDate($date = '', $limit = '', $sort = '')
1362
	{
1363
		global $global_query, $globalTimezone, $globalDBdriver;
1364
		
1365
		$query_values = array();
1366
		$limit_query = '';
1367
		$additional_query = '';
1368
		
1369
		if ($date != "")
1370
		{
1371
			if ($globalTimezone != '') {
1372
				date_default_timezone_set($globalTimezone);
1373
				$datetime = new DateTime($date);
1374
				$offset = $datetime->format('P');
1375
			} else {
1376
				date_default_timezone_set('UTC');
1377
				$datetime = new DateTime($date);
1378
				$offset = '+00:00';
1379
			}
1380
			if ($globalDBdriver == 'mysql') {
1381
				$additional_query = " AND DATE(CONVERT_TZ(spotter_output.date,'+00:00', :offset)) = :date ";
1382
				$query_values = array(':date' => $datetime->format('Y-m-d'), ':offset' => $offset);
1383
			} elseif ($globalDBdriver == 'pgsql') {
1384
				$additional_query = " AND spotter_output.date AT TIME ZONE :timezone = :date ";
1385
				$query_values = array(':date' => $datetime->format('Y-m-d'), ':timezone' => $globalTimezone);
1386
			}
1387
		}
1388
		
1389
		if ($limit != "")
1390
		{
1391
			$limit_array = explode(",", $limit);
1392
			
1393
			$limit_array[0] = filter_var($limit_array[0],FILTER_SANITIZE_NUMBER_INT);
1394
			$limit_array[1] = filter_var($limit_array[1],FILTER_SANITIZE_NUMBER_INT);
1395
			
1396
			if ($limit_array[0] >= 0 && $limit_array[1] >= 0)
1397
			{
1398
				//$limit_query = " LIMIT ".$limit_array[0].",".$limit_array[1];
1399
				$limit_query = " LIMIT ".$limit_array[1]." OFFSET ".$limit_array[0];
1400
			}
1401
		}
1402
1403
		if ($sort != "")
1404
		{
1405
			$search_orderby_array = $this->getOrderBy();
1406
			$orderby_query = $search_orderby_array[$sort]['sql'];
1407
		} else {
1408
			$orderby_query = " ORDER BY spotter_output.date DESC";
1409
		}
1410
1411
		$query = $global_query." WHERE spotter_output.ident <> '' ".$additional_query." ".$orderby_query;
1412
		
1413
		$spotter_array = $this->getDataFromDB($query, $query_values, $limit_query);
1414
1415
		return $spotter_array;
1416
	}
1417
1418
1419
1420
	/**
1421
	* Gets all the spotter information based on the country name
1422
	*
1423
	* @return Array the spotter information
1424
	*
1425
	*/
1426
	public function getSpotterDataByCountry($country = '', $limit = '', $sort = '')
1427
	{
1428
		global $global_query;
1429
		
1430
		date_default_timezone_set('UTC');
1431
		
1432
		$query_values = array();
1433
		$limit_query = '';
1434
		$additional_query = '';
1435
		if ($country != "")
1436
		{
1437
			if (!is_string($country))
1438
			{
1439
				return false;
1440
			} else {
1441
				$additional_query .= " AND ((spotter_output.departure_airport_country = :country) OR (spotter_output.arrival_airport_country = :country))";
1442
				$additional_query .= " OR spotter_output.airline_country = :country";
1443
				$query_values = array(':country' => $country);
1444
			}
1445
		}
1446
		
1447
		if ($limit != "")
1448
		{
1449
			$limit_array = explode(",", $limit);
1450
			
1451
			$limit_array[0] = filter_var($limit_array[0],FILTER_SANITIZE_NUMBER_INT);
1452
			$limit_array[1] = filter_var($limit_array[1],FILTER_SANITIZE_NUMBER_INT);
1453
			
1454
			if ($limit_array[0] >= 0 && $limit_array[1] >= 0)
1455
			{
1456
				//$limit_query = " LIMIT ".$limit_array[0].",".$limit_array[1];
1457
				$limit_query = " LIMIT ".$limit_array[1]." OFFSET ".$limit_array[0];
1458
			}
1459
		}
1460
					
1461
		if ($sort != "")
1462
		{
1463
			$search_orderby_array = $this->getOrderBy();
1464
			$orderby_query = $search_orderby_array[$sort]['sql'];
1465
		} else {
1466
			$orderby_query = " ORDER BY spotter_output.date DESC";
1467
		}
1468
1469
		$query = $global_query." WHERE spotter_output.ident <> '' ".$additional_query." ".$orderby_query;
1470
1471
		$spotter_array = $this->getDataFromDB($query, $query_values, $limit_query);
1472
1473
		return $spotter_array;
1474
	}	
1475
	
1476
	
1477
	/**
1478
	* Gets all the spotter information based on the manufacturer name
1479
	*
1480
	* @return Array the spotter information
1481
	*
1482
	*/
1483
	public function getSpotterDataByManufacturer($aircraft_manufacturer = '', $limit = '', $sort = '')
1484
	{
1485
		global $global_query;
1486
		
1487
		date_default_timezone_set('UTC');
1488
		
1489
		$query_values = array();
1490
		$additional_query = '';
1491
		$limit_query = '';
1492
		
1493
		if ($aircraft_manufacturer != "")
1494
		{
1495
			if (!is_string($aircraft_manufacturer))
1496
			{
1497
				return false;
1498
			} else {
1499
				$additional_query .= " AND (spotter_output.aircraft_manufacturer = :aircraft_manufacturer)";
1500
				$query_values = array(':aircraft_manufacturer' => $aircraft_manufacturer);
1501
			}
1502
		}
1503
		
1504
		if ($limit != "")
1505
		{
1506
			$limit_array = explode(",", $limit);
1507
			
1508
			$limit_array[0] = filter_var($limit_array[0],FILTER_SANITIZE_NUMBER_INT);
1509
			$limit_array[1] = filter_var($limit_array[1],FILTER_SANITIZE_NUMBER_INT);
1510
			
1511
			if ($limit_array[0] >= 0 && $limit_array[1] >= 0)
1512
			{
1513
				//$limit_query = " LIMIT ".$limit_array[0].",".$limit_array[1];
1514
				$limit_query = " LIMIT ".$limit_array[1]." OFFSET ".$limit_array[0];
1515
			}
1516
		}
1517
1518
		if ($sort != "")
1519
		{
1520
			$search_orderby_array = $this->getOrderBy();
1521
			$orderby_query = $search_orderby_array[$sort]['sql'];
1522
		} else {
1523
			$orderby_query = " ORDER BY spotter_output.date DESC";
1524
		}
1525
1526
		$query = $global_query." WHERE spotter_output.ident <> '' ".$additional_query." ".$orderby_query;
1527
1528
		$spotter_array = $this->getDataFromDB($query, $query_values, $limit_query);
1529
1530
		return $spotter_array;
1531
	}
1532
1533
1534
  
1535
  
1536
	/**
1537
	* Gets a list of all aircraft that take a route
1538
	*
1539
	* @param String $departure_airport_icao ICAO code of departure airport
1540
	* @param String $arrival_airport_icao ICAO code of arrival airport
1541
	* @return Array the spotter information
1542
	*
1543
	*/
1544
	public function getSpotterDataByRoute($departure_airport_icao = '', $arrival_airport_icao = '', $limit = '', $sort = '')
1545
	{
1546
		global $global_query;
1547
		
1548
		$query_values = array();
1549
		$additional_query = '';
1550
		$limit_query = '';
1551
		if ($departure_airport_icao != "")
1552
		{
1553
			if (!is_string($departure_airport_icao))
1554
			{
1555
				return false;
1556
			} else {
1557
				$departure_airport_icao = filter_var($departure_airport_icao,FILTER_SANITIZE_STRING);
1558
				$additional_query .= " AND (spotter_output.departure_airport_icao = :departure_airport_icao)";
1559
				$query_values = array(':departure_airport_icao' => $departure_airport_icao);
1560
			}
1561
		}
1562
		
1563
		if ($arrival_airport_icao != "")
1564
		{
1565
			if (!is_string($arrival_airport_icao))
1566
			{
1567
				return false;
1568
			} else {
1569
				$arrival_airport_icao = filter_var($arrival_airport_icao,FILTER_SANITIZE_STRING);
1570
				$additional_query .= " AND (spotter_output.arrival_airport_icao = :arrival_airport_icao)";
1571
				$query_values = array_merge($query_values,array(':arrival_airport_icao' => $arrival_airport_icao));
1572
			}
1573
		}
1574
		
1575
		if ($limit != "")
1576
		{
1577
			$limit_array = explode(",", $limit);
1578
			
1579
			$limit_array[0] = filter_var($limit_array[0],FILTER_SANITIZE_NUMBER_INT);
1580
			$limit_array[1] = filter_var($limit_array[1],FILTER_SANITIZE_NUMBER_INT);
1581
			
1582
			if ($limit_array[0] >= 0 && $limit_array[1] >= 0)
1583
			{
1584
				//$limit_query = " LIMIT ".$limit_array[0].",".$limit_array[1];
1585
				$limit_query = " LIMIT ".$limit_array[1]." OFFSET ".$limit_array[0];
1586
			}
1587
		}
1588
	
1589
		if ($sort != "")
1590
		{
1591
			$search_orderby_array = $this->getOrderBy();
1592
			$orderby_query = $search_orderby_array[$sort]['sql'];
1593
		} else {
1594
			$orderby_query = " ORDER BY spotter_output.date DESC";
1595
		}
1596
1597
		$query = $global_query." WHERE spotter_output.ident <> '' ".$additional_query." ".$orderby_query;
1598
          
1599
		//$result = mysqli_query($GLOBALS["___mysqli_ston"], $query);
1600
1601
		$spotter_array = $this->getDataFromDB($query, $query_values, $limit_query);
1602
1603
		return $spotter_array;
1604
	}
1605
	
1606
	
1607
	
1608
	/**
1609
	* Gets all the spotter information based on the special column in the table
1610
	*
1611
	* @return Array the spotter information
1612
	*
1613
	*/
1614
	public function getSpotterDataByHighlight($limit = '', $sort = '')
1615
	{
1616
		global $global_query;
1617
		
1618
		date_default_timezone_set('UTC');
1619
		$limit_query = '';
1620
		
1621
		if ($limit != "")
1622
		{
1623
			$limit_array = explode(",", $limit);
1624
			
1625
			$limit_array[0] = filter_var($limit_array[0],FILTER_SANITIZE_NUMBER_INT);
1626
			$limit_array[1] = filter_var($limit_array[1],FILTER_SANITIZE_NUMBER_INT);
1627
			
1628
			if ($limit_array[0] >= 0 && $limit_array[1] >= 0)
1629
			{
1630
				//$limit_query = " LIMIT ".$limit_array[0].",".$limit_array[1];
1631
				$limit_query = " LIMIT ".$limit_array[1]." OFFSET ".$limit_array[0];
1632
			}
1633
		}
1634
		
1635
		if ($sort != "")
1636
		{
1637
			$search_orderby_array = $this->getOrderBy();
1638
			$orderby_query = $search_orderby_array[$sort]['sql'];
1639
		} else {
1640
			$orderby_query = " ORDER BY spotter_output.date DESC";
1641
		}
1642
1643
		$query  = $global_query." WHERE spotter_output.highlight <> '' ".$orderby_query;
1644
1645
		$spotter_array = $this->getDataFromDB($query, array(), $limit_query);
1646
1647
		return $spotter_array;
1648
	}
1649
    
1650
    
1651
    
1652
    /**
1653
	* Gets all the highlight based on a aircraft registration
1654
	*
1655
	* @return String the highlight text
1656
	*
1657
	*/
1658
	public function getHighlightByRegistration($registration)
1659
	{
1660
		global $global_query;
1661
		
1662
		date_default_timezone_set('UTC');
1663
		
1664
		$registration = filter_var($registration,FILTER_SANITIZE_STRING);
1665
1666
		
1667
		$query  = $global_query." WHERE spotter_output.highlight <> '' AND spotter_output.registration = :registration";
1668
		$sth = $this->db->prepare($query);
1669
		$sth->execute(array(':registration' => $registration));
1670
1671
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
1672
		{
1673
			$highlight = $row['highlight'];
1674
		}
1675
		if (isset($highlight)) return $highlight;
1676
	}
1677
1678
	
1679
	/**
1680
	* Gets the squawk usage from squawk code
1681
	*
1682
	* @param String $squawk squawk code
1683
	* @param String $country country
1684
	* @return String usage
1685
	*
1686
	*/
1687
	public function getSquawkUsage($squawk = '',$country = 'FR')
1688
	{
1689
		
1690
		$squawk = filter_var($squawk,FILTER_SANITIZE_STRING);
1691
		$country = filter_var($country,FILTER_SANITIZE_STRING);
1692
1693
		$query  = "SELECT squawk.* FROM squawk WHERE squawk.code = :squawk AND squawk.country = :country LIMIT 1";
1694
		$query_values = array(':squawk' => ltrim($squawk,'0'), ':country' => $country);
1695
		
1696
		$sth = $this->db->prepare($query);
1697
		$sth->execute($query_values);
1698
    
1699
		$row = $sth->fetch(PDO::FETCH_ASSOC);
1700
		if (count($row) > 0) {
1701
			return $row['usage'];
1702
		} else return '';
1703
	}
1704
1705
	/**
1706
	* Gets the airport icao from the iata
1707
	*
1708
	* @param String $airport_iata the iata code of the airport
1709
	* @return String airport iata
1710
	*
1711
	*/
1712
	public function getAirportIcao($airport_iata = '')
1713
	{
1714
		
1715
		$airport_iata = filter_var($airport_iata,FILTER_SANITIZE_STRING);
1716
1717
		$query  = "SELECT airport.* FROM airport WHERE airport.iata = :airport LIMIT 1";
1718
		$query_values = array(':airport' => $airport_iata);
1719
		
1720
		$sth = $this->db->prepare($query);
1721
		$sth->execute($query_values);
1722
		
1723
		$row = $sth->fetch(PDO::FETCH_ASSOC);
1724
		if (count($row) > 0) {
1725
			return $row['icao'];
1726
		} else return '';
1727
	}
1728
1729
	/**
1730
	* Gets the airport distance
1731
	*
1732
	* @param String $airport_icao the icao code of the airport
1733
	* @param Float $latitude the latitude
1734
	* @param Float $longitude the longitude
1735
	* @return Float distance to the airport
1736
	*
1737
	*/
1738
	public function getAirportDistance($airport_icao,$latitude,$longitude)
1739
	{
1740
		
1741
		$airport_icao = filter_var($airport_icao,FILTER_SANITIZE_STRING);
1742
1743
		$query  = "SELECT airport.latitude, airport.longitude FROM airport WHERE airport.icao = :airport LIMIT 1";
1744
		$query_values = array(':airport' => $airport_icao);
1745
		$sth = $this->db->prepare($query);
1746
		$sth->execute($query_values);
1747
		$row = $sth->fetch(PDO::FETCH_ASSOC);
1748
		if (count($row) > 0) {
1749
			$airport_latitude = $row['latitude'];
1750
			$airport_longitude = $row['longitude'];
1751
			$Common = new Common();
1752
			return $Common->distance($latitude,$longitude,$airport_latitude,$airport_longitude);
1753
		} else return '';
1754
	}
1755
	
1756
	/**
1757
	* Gets the airport info based on the icao
1758
	*
1759
	* @param String $airport the icao code of the airport
1760
	* @return Array airport information
1761
	*
1762
	*/
1763
	public function getAllAirportInfo($airport = '')
1764
	{
1765
		
1766
		$airport = filter_var($airport,FILTER_SANITIZE_STRING);
1767
1768
		$query_values = array();
1769
		if ($airport == 'NA') {
1770
			return array(array('name' => 'Not available','city' => 'N/A', 'country' => 'N/A','iata' => 'NA','icao' => 'NA','altitude' => NULL,'latitude' => 0,'longitude' => 0,'type' => 'NA','home_link' => '','wikipedia_link' => '','image_thumb' => '', 'image' => ''));
1771
		} elseif ($airport == '') {
1772
			$query  = "SELECT airport.name, airport.city, airport.country, airport.iata, airport.icao, airport.latitude, airport.longitude, airport.altitude, airport.type, airport.home_link, airport.wikipedia_link, airport.image_thumb, airport.image FROM airport";
1773
		} else {
1774
			$query  = "SELECT airport.name, airport.city, airport.country, airport.iata, airport.icao, airport.latitude, airport.longitude, airport.altitude, airport.type, airport.home_link, airport.wikipedia_link, airport.image_thumb, airport.image FROM airport WHERE airport.icao = :airport LIMIT 1";
1775
			$query_values = array(':airport' => $airport);
1776
		}
1777
		
1778
		$sth = $this->db->prepare($query);
1779
		$sth->execute($query_values);
1780
		/*
1781
		$airport_array = array();
1782
		$temp_array = array();
1783
		
1784
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
1785
		{
1786
			$temp_array['name'] = $row['name'];
1787
			$temp_array['city'] = $row['city'];
1788
			$temp_array['country'] = $row['country'];
1789
			$temp_array['iata'] = $row['iata'];
1790
			$temp_array['icao'] = $row['icao'];
1791
			$temp_array['latitude'] = $row['latitude'];
1792
			$temp_array['longitude'] = $row['longitude'];
1793
			$temp_array['altitude'] = $row['altitude'];
1794
			$temp_array['home_link'] = $row['home_link'];
1795
			$temp_array['wikipedia_link'] = $row['wikipedia_link'];
1796
			$temp_array['image'] = $row['image'];
1797
			$temp_array['image_thumb'] = $row['image_thumb'];
1798
1799
			$airport_array[] = $temp_array;
1800
		}
1801
1802
		return $airport_array;
1803
		*/
1804
		return $sth->fetchAll(PDO::FETCH_ASSOC);
1805
	}
1806
	
1807
	/**
1808
	* Gets the airport info based on the country
1809
	*
1810
	* @param Array $countries Airports countries
1811
	* @return Array airport information
1812
	*
1813
	*/
1814
	public function getAllAirportInfobyCountry($countries)
1815
	{
1816
		$lst_countries = '';
1817
		foreach ($countries as $country) {
1818
			$country = filter_var($country,FILTER_SANITIZE_STRING);
1819
			if ($lst_countries == '') {
1820
				$lst_countries = "'".$country."'";
1821
			} else {
1822
				$lst_countries .= ",'".$country."'";
1823
			}
1824
		}
1825
		$query  = "SELECT airport.* FROM airport WHERE airport.country IN (".$lst_countries.")";
1826
		
1827
		$sth = $this->db->prepare($query);
1828
		$sth->execute();
1829
    
1830
		$airport_array = array();
1831
		$temp_array = array();
1832
		
1833
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
1834
		{
1835
			$temp_array['name'] = $row['name'];
1836
			$temp_array['city'] = $row['city'];
1837
			$temp_array['country'] = $row['country'];
1838
			$temp_array['iata'] = $row['iata'];
1839
			$temp_array['icao'] = $row['icao'];
1840
			$temp_array['latitude'] = $row['latitude'];
1841
			$temp_array['longitude'] = $row['longitude'];
1842
			$temp_array['altitude'] = $row['altitude'];
1843
1844
			$airport_array[] = $temp_array;
1845
		}
1846
1847
		return $airport_array;
1848
	}
1849
	
1850
	/**
1851
	* Gets airports info based on the coord
1852
	*
1853
	* @param Array $coord Airports longitude min,latitude min, longitude max, latitude max
1854
	* @return Array airport information
1855
	*
1856
	*/
1857
	public function getAllAirportInfobyCoord($coord)
1858
	{
1859
		global $globalDBdriver;
1860
		if (is_array($coord)) {
1861
			$minlong = filter_var($coord[0],FILTER_SANITIZE_NUMBER_FLOAT,FILTER_FLAG_ALLOW_FRACTION);
1862
			$minlat = filter_var($coord[1],FILTER_SANITIZE_NUMBER_FLOAT,FILTER_FLAG_ALLOW_FRACTION);
1863
			$maxlong = filter_var($coord[2],FILTER_SANITIZE_NUMBER_FLOAT,FILTER_FLAG_ALLOW_FRACTION);
1864
			$maxlat = filter_var($coord[3],FILTER_SANITIZE_NUMBER_FLOAT,FILTER_FLAG_ALLOW_FRACTION);
1865
		} else return array();
1866
		if ($globalDBdriver == 'mysql') {
1867
			$query  = "SELECT airport.* FROM airport WHERE airport.latitude BETWEEN ".$minlat." AND ".$maxlat." AND airport.longitude BETWEEN ".$minlong." AND ".$maxlong." AND airport.type != 'closed'";
1868
		} else {
1869
			$query  = "SELECT airport.* FROM airport WHERE CAST(airport.latitude AS FLOAT) BETWEEN ".$minlat." AND ".$maxlat." AND CAST(airport.longitude AS FLOAT) BETWEEN ".$minlong." AND ".$maxlong." AND airport.type != 'closed'";
1870
		}
1871
		$sth = $this->db->prepare($query);
1872
		$sth->execute();
1873
    
1874
		$airport_array = array();
1875
		
1876
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
1877
		{
1878
			$temp_array = $row;
1879
1880
			$airport_array[] = $temp_array;
1881
		}
1882
1883
		return $airport_array;
1884
	}
1885
1886
	/**
1887
	* Gets waypoints info based on the coord
1888
	*
1889
	* @param Array $coord waypoints coord
1890
	* @return Array airport information
1891
	*
1892
	*/
1893
	public function getAllWaypointsInfobyCoord($coord)
1894
	{
1895
		if (is_array($coord)) {
1896
			$minlong = filter_var($coord[0],FILTER_SANITIZE_NUMBER_FLOAT,FILTER_FLAG_ALLOW_FRACTION);
1897
			$minlat = filter_var($coord[1],FILTER_SANITIZE_NUMBER_FLOAT,FILTER_FLAG_ALLOW_FRACTION);
1898
			$maxlong = filter_var($coord[2],FILTER_SANITIZE_NUMBER_FLOAT,FILTER_FLAG_ALLOW_FRACTION);
1899
			$maxlat = filter_var($coord[3],FILTER_SANITIZE_NUMBER_FLOAT,FILTER_FLAG_ALLOW_FRACTION);
1900
		} else return array();
1901
		//$query  = "SELECT waypoints.* FROM waypoints WHERE waypoints.latitude_begin BETWEEN ".$minlat." AND ".$maxlat." AND waypoints.longitude_begin BETWEEN ".$minlong." AND ".$maxlong;
1902
		$query  = "SELECT waypoints.* FROM waypoints WHERE (waypoints.latitude_begin BETWEEN ".$minlat." AND ".$maxlat." AND waypoints.longitude_begin BETWEEN ".$minlong." AND ".$maxlong.") OR (waypoints.latitude_end BETWEEN ".$minlat." AND ".$maxlat." AND waypoints.longitude_end BETWEEN ".$minlong." AND ".$maxlong.")";
1903
		//$query  = "SELECT waypoints.* FROM waypoints";
1904
		//$query  = "SELECT waypoints.* FROM waypoints INNER JOIN (SELECT waypoints.* FROM waypoints WHERE waypoints.latitude_begin BETWEEN ".$minlat." AND ".$maxlat." AND waypoints.longitude_begin BETWEEN ".$minlong." AND ".$maxlong.") w ON w.name_end = waypoints.name_begin OR w.name_begin = waypoints.name_begin OR w.name_begin = waypoints.name_end OR w.name_end = waypoints.name_end";
1905
		//$query = "SELECT * FROM waypoints LEFT JOIN waypoints w ON waypoints.name_end = w.name_begin WHERE waypoints.latitude_begin BETWEEN ".$minlat." AND ".$maxlat." AND waypoints.longitude_begin BETWEEN ".$minlong." AND ".$maxlong;
1906
		//$query = "SELECT z.name_begin as name_begin, z.name_end as name_end, z.latitude_begin as latitude_begin, z.longitude_begin as longitude_begin, z.latitude_end as latitude_end, z.longitude_end as longitude_end, z.segment_name as segment_name, w.name_end as name_end_seg2, w.latitude_end as latitude_end_seg2, w.longitude_end as longitude_end_seg2, w.segment_name as segment_name_seg2 FROM waypoints z INNER JOIN waypoints w ON z.name_end = w.name_begin WHERE z.latitude_begin BETWEEN ".$minlat." AND ".$maxlat." AND z.longitude_begin BETWEEN ".$minlong." AND ".$maxlong;
1907
		//echo $query;
1908
		
1909
		$sth = $this->db->prepare($query);
1910
		$sth->execute();
1911
    
1912
		$waypoints_array = array();
1913
		
1914
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
1915
		{
1916
			$temp_array = $row;
1917
1918
			$waypoints_array[] = $temp_array;
1919
		}
1920
1921
		return $waypoints_array;
1922
	}
1923
	
1924
	
1925
	/**
1926
	* Gets the airline info based on the icao code or iata code
1927
	*
1928
	* @param String $airline_icao the iata code of the airport
1929
	* @return Array airport information
1930
	*
1931
	*/
1932
	public function getAllAirlineInfo($airline_icao)
1933
	{
1934
		$airline_icao = strtoupper(filter_var($airline_icao,FILTER_SANITIZE_STRING));
1935
		if ($airline_icao == 'NA') {
1936
			$airline_array = array();
1937
			$airline_array[] = array('name' => 'Not Available','iata' => 'NA', 'icao' => 'NA', 'callsign' => '', 'country' => 'NA', 'type' =>'');
1938
			return $airline_array;
1939
		} else {
1940
			if (strlen($airline_icao) == 2) {
1941
				$query  = "SELECT airlines.name, airlines.iata, airlines.icao, airlines.callsign, airlines.country, airlines.type FROM airlines WHERE airlines.iata = :airline_icao AND airlines.active = 'Y' LIMIT 1";
1942
			} else {
1943
				$query  = "SELECT airlines.name, airlines.iata, airlines.icao, airlines.callsign, airlines.country, airlines.type FROM airlines WHERE airlines.icao = :airline_icao AND airlines.active = 'Y' LIMIT 1";
1944
			}
1945
			
1946
			$sth = $this->db->prepare($query);
1947
			$sth->execute(array(':airline_icao' => $airline_icao));
1948
                        /*
1949
			$airline_array = array();
1950
			$temp_array = array();
1951
		
1952
			while($row = $sth->fetch(PDO::FETCH_ASSOC))
1953
			{
1954
				$temp_array['name'] = $row['name'];
1955
				$temp_array['iata'] = $row['iata'];
1956
				$temp_array['icao'] = $row['icao'];
1957
				$temp_array['callsign'] = $row['callsign'];
1958
				$temp_array['country'] = $row['country'];
1959
				$temp_array['type'] = $row['type'];
1960
				$airline_array[] = $temp_array;
1961
			}
1962
			return $airline_array;
1963
			*/
1964
			return $sth->fetchAll(PDO::FETCH_ASSOC);
1965
		}
1966
	}
1967
	
1968
	
1969
	
1970
	/**
1971
	* Gets the aircraft info based on the aircraft type
1972
	*
1973
	* @param String $aircraft_type the aircraft type
1974
	* @return Array aircraft information
1975
	*
1976
	*/
1977
	public function getAllAircraftInfo($aircraft_type)
1978
	{
1979
		$aircraft_type = filter_var($aircraft_type,FILTER_SANITIZE_STRING);
1980
1981
		if ($aircraft_type == 'NA') {
1982
			return array(array('icao' => 'NA','type' => 'Not Available', 'manufacturer' => 'Not Available', 'aircraft_shadow' => NULL));
1983
		}
1984
		$query  = "SELECT aircraft.icao, aircraft.type,aircraft.manufacturer,aircraft.aircraft_shadow FROM aircraft WHERE aircraft.icao = :aircraft_type";
1985
		
1986
		$sth = $this->db->prepare($query);
1987
		$sth->execute(array(':aircraft_type' => $aircraft_type));
1988
		/*
1989
		$aircraft_array = array();
1990
		$temp_array = array();
1991
		
1992
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
1993
		{
1994
			$temp_array = array();
1995
			$temp_array['icao'] = $row['icao'];
1996
			$temp_array['type'] = $row['type'];
1997
			$temp_array['manufacturer'] = $row['manufacturer'];
1998
			$temp_array['aircraft_shadow'] = $row['aircraft_shadow'];
1999
2000
			$aircraft_array[] = $temp_array;
2001
		}
2002
		return $aircraft_array;
2003
		*/
2004
		return $sth->fetchAll(PDO::FETCH_ASSOC);
2005
	}
2006
2007
	/**
2008
	* Gets the aircraft icao based on the aircraft name/type
2009
	*
2010
	* @param String $aircraft_type the aircraft type
2011
	* @return String aircraft information
2012
	*
2013
	*/
2014
	public function getAircraftIcao($aircraft_type)
2015
	{
2016
		$aircraft_type = filter_var($aircraft_type,FILTER_SANITIZE_STRING);
2017
		$all_aircraft = array('737-300' => 'B733',
2018
				'777-200' => 'B772',
2019
				'777-200ER' => 'B772',
2020
				'777-300ER' => 'B77W',
2021
				'c172p' => 'C172',
2022
				'aerostar' => 'AEST',
2023
				'A320-211' => 'A320',
2024
				'747-8i' => 'B748',
2025
				'A380' => 'A388');
2026
		if (isset($all_aircraft[$aircraft_type])) return $all_aircraft[$aircraft_type];
2027
2028
		$query  = "SELECT aircraft.icao FROM aircraft WHERE aircraft.type LIKE :saircraft_type OR aircraft.type = :aircraft_type OR aircraft.icao = :aircraft_type LIMIT 1";
2029
		$aircraft_type = strtoupper($aircraft_type);
2030
		$sth = $this->db->prepare($query);
2031
		$sth->execute(array(':saircraft_type' => '%'.$aircraft_type.'%',':aircraft_type' => $aircraft_type,));
2032
		$result = $sth->fetchAll(PDO::FETCH_ASSOC);
2033
		if (isset($result[0]['icao'])) return $result[0]['icao'];
2034
		else return '';
2035
	}
2036
	
2037
	/**
2038
	* Gets the aircraft info based on the aircraft ident
2039
	*
2040
	* @param String $aircraft_modes the aircraft ident (hex)
2041
	* @return String aircraft type
2042
	*
2043
	*/
2044
	public function getAllAircraftType($aircraft_modes)
2045
	{
2046
		$aircraft_modes = filter_var($aircraft_modes,FILTER_SANITIZE_STRING);
2047
2048
		$query  = "SELECT aircraft_modes.ICAOTypeCode FROM aircraft_modes WHERE aircraft_modes.ModeS = :aircraft_modes LIMIT 1";
2049
		
2050
		$sth = $this->db->prepare($query);
2051
		$sth->execute(array(':aircraft_modes' => $aircraft_modes));
2052
2053
		$row = $sth->fetch(PDO::FETCH_ASSOC);
2054
		if (isset($row['icaotypecode'])) {
2055
			return $row['icaotypecode'];
2056
		} else return '';
2057
	}
2058
2059
	/**
2060
	* Gets correct aircraft operator corde
2061
	*
2062
	* @param String $operator the aircraft operator code (callsign)
2063
	* @return String aircraft operator code
2064
	*
2065
	*/
2066
	public function getOperator($operator)
2067
	{
2068
		$operator = filter_var($operator,FILTER_SANITIZE_STRING);
2069
		$query  = "SELECT translation.operator_correct FROM translation WHERE translation.operator = :operator LIMIT 1";
2070
		
2071
		$sth = $this->db->prepare($query);
2072
		$sth->execute(array(':operator' => $operator));
2073
2074
		$row = $sth->fetch(PDO::FETCH_ASSOC);
2075
		if (isset($row['operator_correct'])) {
2076
			return $row['operator_correct'];
2077
		} else return $operator;
2078
	}
2079
2080
	/**
2081
	* Gets the aircraft route based on the aircraft callsign
2082
	*
2083
	* @param String $callsign the aircraft callsign
2084
	* @return Array aircraft type
2085
	*
2086
	*/
2087
	public function getRouteInfo($callsign)
2088
	{
2089
		$callsign = filter_var($callsign,FILTER_SANITIZE_STRING);
2090
                if ($callsign == '') return array();
2091
		$query  = "SELECT routes.Operator_ICAO, routes.FromAirport_ICAO, routes.ToAirport_ICAO, routes.RouteStop, routes.FromAirport_Time, routes.ToAirport_Time FROM routes WHERE CallSign = :callsign LIMIT 1";
2092
		
2093
		$sth = $this->db->prepare($query);
2094
		$sth->execute(array(':callsign' => $callsign));
2095
2096
		$row = $sth->fetch(PDO::FETCH_ASSOC);
2097
		if (count($row) > 0) {
2098
			return $row;
2099
		} else return array();
2100
	}
2101
	
2102
	/**
2103
	* Gets the aircraft info based on the aircraft registration
2104
	*
2105
	* @param String $registration the aircraft registration
2106
	* @return Array aircraft information
2107
	*
2108
	*/
2109
	public function getAircraftInfoByRegistration($registration)
2110
	{
2111
		$registration = filter_var($registration,FILTER_SANITIZE_STRING);
2112
2113
		$query  = "SELECT spotter_output.aircraft_icao, spotter_output.aircraft_name, spotter_output.aircraft_manufacturer, spotter_output.airline_icao FROM spotter_output WHERE spotter_output.registration = :registration";
2114
		
2115
		$sth = $this->db->prepare($query);
2116
		$sth->execute(array(':registration' => $registration));
2117
2118
		$aircraft_array = array();
2119
		$temp_array = array();
2120
		
2121
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
2122
		{
2123
			$temp_array['airline_icao'] = $row['airline_icao'];
2124
			$temp_array['aircraft_icao'] = $row['aircraft_icao'];
2125
			$temp_array['aircraft_name'] = $row['aircraft_name'];
2126
			$temp_array['aircraft_manufacturer'] = $row['aircraft_manufacturer'];
2127
2128
			$aircraft_array[] = $temp_array;
2129
		}
2130
2131
		return $aircraft_array;
2132
	}
2133
	
2134
	/**
2135
	* Gets the aircraft owner & base based on the aircraft registration
2136
	*
2137
	* @param String $registration the aircraft registration
2138
	* @return Array aircraft information
2139
	*
2140
	*/
2141
	public function getAircraftOwnerByRegistration($registration)
2142
	{
2143
		$registration = filter_var($registration,FILTER_SANITIZE_STRING);
2144
		$Connection = new Connection($this->db);
2145
		if ($Connection->tableExists('aircraft_owner')) {
2146
			$query  = "SELECT aircraft_owner.base, aircraft_owner.owner, aircraft_owner.date_first_reg FROM aircraft_owner WHERE registration = :registration LIMIT 1";
2147
			$sth = $this->db->prepare($query);
2148
			$sth->execute(array(':registration' => $registration));
2149
2150
			return $sth->fetch(PDO::FETCH_ASSOC);
2151
		} else return array();
2152
	}
2153
	
2154
  
2155
  /**
2156
	* Gets all flights (but with only little info)
2157
	*
2158
	* @return Array basic flight information
2159
	*
2160
	*/
2161
	public function getAllFlightsforSitemap()
2162
	{
2163
		//$query  = "SELECT spotter_output.spotter_id, spotter_output.ident, spotter_output.airline_name, spotter_output.aircraft_name, spotter_output.aircraft_icao FROM spotter_output ORDER BY LIMIT ";
2164
		$query  = "SELECT spotter_output.spotter_id FROM spotter_output ORDER BY spotter_id DESC LIMIT 200 OFFSET 0";
2165
		
2166
		$sth = $this->db->prepare($query);
2167
		$sth->execute();
2168
                  /*
2169
		$flight_array = array();
2170
		$temp_array = array();
2171
		
2172
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
2173
		{
2174
			$temp_array['spotter_id'] = $row['spotter_id'];
2175
//			$temp_array['ident'] = $row['ident'];
2176
//			$temp_array['airline_name'] = $row['airline_name'];
2177
//			$temp_array['aircraft_type'] = $row['aircraft_icao'];
2178
//			$temp_array['aircraft_name'] = $row['aircraft_name'];
2179
			//$temp_array['image'] = $row['image'];
2180
2181
			$flight_array[] = $temp_array;
2182
		}
2183
2184
		return $flight_array;
2185
		*/
2186
		return $sth->fetchAll(PDO::FETCH_ASSOC);
2187
	}
2188
  
2189
	/**
2190
	* Gets a list of all aircraft manufacturers
2191
	*
2192
	* @return Array list of aircraft types
2193
	*
2194
	*/
2195
	public function getAllManufacturers()
2196
	{
2197
		/*
2198
		$query  = "SELECT DISTINCT spotter_output.aircraft_manufacturer AS aircraft_manufacturer
2199
								FROM spotter_output
2200
								WHERE spotter_output.aircraft_manufacturer <> '' 
2201
								ORDER BY spotter_output.aircraft_manufacturer ASC";
2202
		  */
2203
		
2204
		$query = "SELECT DISTINCT manufacturer AS aircraft_manufacturer FROM aircraft WHERE manufacturer <> '' ORDER BY manufacturer ASC";
2205
		$sth = $this->db->prepare($query);
2206
		$sth->execute();
2207
2208
		$manufacturer_array = array();
2209
		$temp_array = array();
2210
		
2211
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
2212
		{
2213
			$temp_array['aircraft_manufacturer'] = $row['aircraft_manufacturer'];
2214
2215
			$manufacturer_array[] = $temp_array;
2216
		}
2217
2218
		return $manufacturer_array;
2219
	}
2220
  
2221
  
2222
  /**
2223
	* Gets a list of all aircraft types
2224
	*
2225
	* @return Array list of aircraft types
2226
	*
2227
	*/
2228
	public function getAllAircraftTypes()
2229
	{
2230
		/*
2231
		$query  = "SELECT DISTINCT spotter_output.aircraft_icao AS aircraft_icao, spotter_output.aircraft_name AS aircraft_name
2232
								FROM spotter_output  
2233
								WHERE spotter_output.aircraft_icao <> '' 
2234
								ORDER BY spotter_output.aircraft_name ASC";
2235
								
2236
		*/
2237
		$query = "SELECT DISTINCT icao AS aircraft_icao, type AS aircraft_name, manufacturer AS aircraft_manufacturer FROM aircraft WHERE icao <> '' ORDER BY aircraft_manufacturer ASC";
2238
		
2239
		$sth = $this->db->prepare($query);
2240
		$sth->execute();
2241
2242
		$aircraft_array = array();
2243
		$temp_array = array();
2244
		
2245
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
2246
		{
2247
			$temp_array['aircraft_icao'] = $row['aircraft_icao'];
2248
			$temp_array['aircraft_manufacturer'] = $row['aircraft_manufacturer'];
2249
			$temp_array['aircraft_name'] = $row['aircraft_name'];
2250
2251
			$aircraft_array[] = $temp_array;
2252
		}
2253
2254
		return $aircraft_array;
2255
	}
2256
	
2257
	
2258
	/**
2259
	* Gets a list of all aircraft registrations
2260
	*
2261
	* @return Array list of aircraft registrations
2262
	*
2263
	*/
2264
	public function getAllAircraftRegistrations()
2265
	{
2266
		$query  = "SELECT DISTINCT spotter_output.registration 
2267
				FROM spotter_output  
2268
				WHERE spotter_output.registration <> '' 
2269
				ORDER BY spotter_output.registration ASC";
2270
2271
		$sth = $this->db->prepare($query);
2272
		$sth->execute();
2273
2274
		$aircraft_array = array();
2275
		$temp_array = array();
2276
		
2277
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
2278
		{
2279
			$temp_array['registration'] = $row['registration'];
2280
2281
			$aircraft_array[] = $temp_array;
2282
		}
2283
2284
		return $aircraft_array;
2285
	}
2286
2287
	/**
2288
	* Gets all source name
2289
	*
2290
	* @param String type format of source
2291
	* @return Array list of source name
2292
	*
2293
	*/
2294
	public function getAllSourceName($type = '')
2295
	{
2296
		$query_values = array();
2297
		$query  = "SELECT DISTINCT spotter_output.source_name 
2298
				FROM spotter_output  
2299
				WHERE spotter_output.source_name <> ''";
2300
		if ($type != '') {
2301
			$query_values = array(':type' => $type);
2302
			$query .= " AND format_source = :type";
2303
		}
2304
		$query .= " ORDER BY spotter_output.source_name ASC";
2305
2306
		$sth = $this->db->prepare($query);
2307
		if (!empty($query_values)) $sth->execute($query_values);
2308
		else $sth->execute();
2309
2310
		$source_array = array();
2311
		$temp_array = array();
2312
		
2313
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
2314
		{
2315
			$temp_array['source_name'] = $row['source_name'];
2316
			$source_array[] = $temp_array;
2317
		}
2318
		return $source_array;
2319
	}
2320
2321
2322
2323
	/**
2324
	* Gets a list of all airline names
2325
	*
2326
	* @return Array list of airline names
2327
	*
2328
	*/
2329
	public function getAllAirlineNames($airline_type = '')
2330
	{
2331
		$airline_type = filter_var($airline_type,FILTER_SANITIZE_STRING);
2332
		if ($airline_type == '' || $airline_type == 'all') {
2333
			/*
2334
			$query  = "SELECT DISTINCT spotter_output.airline_icao AS airline_icao, spotter_output.airline_name AS airline_name, spotter_output.airline_type AS airline_type
2335
								FROM spotter_output
2336
								WHERE spotter_output.airline_icao <> '' 
2337
								ORDER BY spotter_output.airline_name ASC";
2338
			*/
2339
			$query = "SELECT DISTINCT icao AS airline_icao, name AS airline_name, type AS airline_type FROM airlines ORDER BY name ASC";
2340
		} else {
2341
			$query  = "SELECT DISTINCT spotter_output.airline_icao AS airline_icao, spotter_output.airline_name AS airline_name, spotter_output.airline_type AS airline_type
2342
					FROM spotter_output
2343
					WHERE spotter_output.airline_icao <> '' 
2344
					AND spotter_output.airline_type = :airline_type 
2345
					ORDER BY spotter_output.airline_icao ASC";
2346
		}
2347
		
2348
		$sth = $this->db->prepare($query);
2349
		if ($airline_type != '' || $airline_type == 'all') {
2350
			$sth->execute(array(':airline_type' => $airline_type));
2351
		} else {
2352
			$sth->execute();
2353
		}
2354
    
2355
		$airline_array = array();
2356
		$temp_array = array();
2357
		
2358
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
2359
		{
2360
			$temp_array['airline_icao'] = $row['airline_icao'];
2361
			$temp_array['airline_name'] = $row['airline_name'];
2362
			$temp_array['airline_type'] = $row['airline_type'];
2363
2364
			$airline_array[] = $temp_array;
2365
		}
2366
		return $airline_array;
2367
	}
2368
	
2369
	
2370
	/**
2371
	* Gets a list of all airline countries
2372
	*
2373
	* @return Array list of airline countries
2374
	*
2375
	*/
2376
	public function getAllAirlineCountries()
2377
	{
2378
		
2379
		$query  = "SELECT DISTINCT spotter_output.airline_country AS airline_country
2380
				FROM spotter_output  
2381
				WHERE spotter_output.airline_country <> '' 
2382
				ORDER BY spotter_output.airline_country ASC";
2383
		
2384
		//$query = "SELECT DISTINCT country AS airline_country FROM airlines WHERE country <> '' AND active = 'Y' ORDER BY country ASC";
2385
		$sth = $this->db->prepare($query);
2386
		$sth->execute();
2387
2388
		$airline_array = array();
2389
		$temp_array = array();
2390
		
2391
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
2392
		{
2393
			$temp_array['airline_country'] = $row['airline_country'];
2394
2395
			$airline_array[] = $temp_array;
2396
		}
2397
2398
		return $airline_array;
2399
	}
2400
2401
	
2402
	
2403
	/**
2404
	* Gets a list of all departure & arrival names
2405
	*
2406
	* @return Array list of airport names
2407
	*
2408
	*/
2409
	public function getAllAirportNames()
2410
	{
2411
		$airport_array = array();
2412
2413
		$query  = "SELECT DISTINCT spotter_output.departure_airport_icao AS airport_icao, spotter_output.departure_airport_name AS airport_name, spotter_output.departure_airport_city AS airport_city, spotter_output.departure_airport_country AS airport_country
2414
				FROM spotter_output 
2415
				WHERE spotter_output.departure_airport_icao <> '' AND spotter_output.departure_airport_icao <> 'NA' 
2416
				ORDER BY spotter_output.departure_airport_city ASC";
2417
		
2418
		//$query = "SELECT DISTINCT icao AS airport_icao, name AS airport_name, city AS airport_city, country AS airport_country FROM airport ORDER BY city ASC";
2419
		$sth = $this->db->prepare($query);
2420
		$sth->execute();
2421
2422
		$temp_array = array();
2423
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
2424
		{
2425
			$temp_array['airport_icao'] = $row['airport_icao'];
2426
			$temp_array['airport_name'] = $row['airport_name'];
2427
			$temp_array['airport_city'] = $row['airport_city'];
2428
			$temp_array['airport_country'] = $row['airport_country'];
2429
2430
			$airport_array[$row['airport_city'].",".$row['airport_name']] = $temp_array;
2431
		}
2432
2433
		$query  = "SELECT DISTINCT spotter_output.arrival_airport_icao AS airport_icao, spotter_output.arrival_airport_name AS airport_name, spotter_output.arrival_airport_city AS airport_city, spotter_output.arrival_airport_country AS airport_country
2434
								FROM spotter_output 
2435
								WHERE spotter_output.arrival_airport_icao <> '' AND spotter_output.arrival_airport_icao <> 'NA' 
2436
								ORDER BY spotter_output.arrival_airport_city ASC";
2437
					
2438
		$sth = $this->db->prepare($query);
2439
		$sth->execute();
2440
2441
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
2442
			{
2443
		//	if ($airport_array[$row['airport_city'].",".$row['airport_name']]['airport_icao'] != $row['airport_icao'])
2444
		//	{
2445
				$temp_array['airport_icao'] = $row['airport_icao'];
2446
				$temp_array['airport_name'] = $row['airport_name'];
2447
				$temp_array['airport_city'] = $row['airport_city'];
2448
				$temp_array['airport_country'] = $row['airport_country'];
2449
				
2450
				$airport_array[$row['airport_city'].",".$row['airport_name']] = $temp_array;
2451
		//	}
2452
		}
2453
2454
		return $airport_array;
2455
	} 
2456
	
2457
	
2458
	/**
2459
	* Gets a list of all departure & arrival airport countries
2460
	*
2461
	* @return Array list of airport countries
2462
	*
2463
	*/
2464
	public function getAllAirportCountries()
2465
	{
2466
		$airport_array = array();
2467
					
2468
		  /*
2469
		$query  = "SELECT DISTINCT spotter_output.departure_airport_country AS airport_country
2470
								FROM spotter_output
2471
								WHERE spotter_output.departure_airport_country <> '' 
2472
								ORDER BY spotter_output.departure_airport_country ASC";
2473
		*/
2474
		$query = "SELECT DISTINCT country AS airport_country FROM airport ORDER BY country ASC";
2475
		
2476
		$sth = $this->db->prepare($query);
2477
		$sth->execute();
2478
   
2479
		$temp_array = array();
2480
		
2481
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
2482
		{
2483
			$temp_array['airport_country'] = $row['airport_country'];
2484
2485
			$airport_array[$row['airport_country']] = $temp_array;
2486
		}
2487
								
2488
		$query  = "SELECT DISTINCT spotter_output.arrival_airport_country AS airport_country
2489
								FROM spotter_output
2490
								WHERE spotter_output.arrival_airport_country <> '' 
2491
								ORDER BY spotter_output.arrival_airport_country ASC";
2492
					
2493
		$sth = $this->db->prepare($query);
2494
		$sth->execute();
2495
		
2496
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
2497
		{
2498
			if (isset($airport_array[$row['airport_country']]['airport_country']) && $airport_array[$row['airport_country']]['airport_country'] != $row['airport_country'])
2499
			{
2500
				$temp_array['airport_country'] = $row['airport_country'];
2501
				$airport_array[$row['airport_country']] = $temp_array;
2502
			}
2503
		}
2504
2505
		return $airport_array;
2506
	} 
2507
	
2508
	
2509
	
2510
	
2511
	/**
2512
	* Gets a list of all countries (airline, departure airport & arrival airport)
2513
	*
2514
	* @return Array list of countries
2515
	*
2516
	*/
2517
	public function getAllCountries()
2518
	{
2519
		$Connection= new Connection($this->db);
2520
		if ($Connection->tableExists('countries')) {
2521
			$query  = "SELECT countries.name AS airport_country
2522
				FROM countries
2523
				ORDER BY countries.name ASC";
2524
			$sth = $this->db->prepare($query);
2525
			$sth->execute();
2526
   
2527
			$temp_array = array();
2528
			$country_array = array();
2529
		
2530
			while($row = $sth->fetch(PDO::FETCH_ASSOC))
2531
			{
2532
				$temp_array['country'] = $row['airport_country'];
2533
				$country_array[$row['airport_country']] = $temp_array;
2534
			}
2535
		} else {
2536
			$query  = "SELECT DISTINCT spotter_output.departure_airport_country AS airport_country
2537
								FROM spotter_output
2538
								WHERE spotter_output.departure_airport_country <> '' 
2539
								ORDER BY spotter_output.departure_airport_country ASC";
2540
2541
			$sth = $this->db->prepare($query);
2542
			$sth->execute();
2543
   
2544
			$temp_array = array();
2545
			$country_array = array();
2546
			while($row = $sth->fetch(PDO::FETCH_ASSOC))
2547
			{
2548
				$temp_array['country'] = $row['airport_country'];
2549
				$country_array[$row['airport_country']] = $temp_array;
2550
			}
2551
2552
		$query  = "SELECT DISTINCT spotter_output.arrival_airport_country AS airport_country
2553
								FROM spotter_output
2554
								WHERE spotter_output.arrival_airport_country <> '' 
2555
								ORDER BY spotter_output.arrival_airport_country ASC";
2556
					
2557
		$sth = $this->db->prepare($query);
2558
		$sth->execute();
2559
		
2560
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
2561
		{
2562
			if ($country_array[$row['airport_country']]['country'] != $row['airport_country'])
2563
			{
2564
				$temp_array['country'] = $row['airport_country'];
2565
				
2566
				$country_array[$row['country']] = $temp_array;
2567
			}
2568
		}
2569
		
2570
		$query  = "SELECT DISTINCT spotter_output.airline_country AS airline_country
2571
								FROM spotter_output  
2572
								WHERE spotter_output.airline_country <> '' 
2573
								ORDER BY spotter_output.airline_country ASC";
2574
					
2575
		$sth = $this->db->prepare($query);
2576
		$sth->execute();
2577
		
2578
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
2579
		{
2580
			if (isset($country_array[$row['airline_country']]['country']) && $country_array[$row['airline_country']]['country'] != $row['airline_country'])
2581
			{
2582
				$temp_array['country'] = $row['airline_country'];
2583
				
2584
				$country_array[$row['country']] = $temp_array;
2585
			}
2586
		}
2587
		}  
2588
		return $country_array;
2589
	} 
2590
	
2591
	
2592
	
2593
	
2594
	/**
2595
	* Gets a list of all idents/callsigns
2596
	*
2597
	* @return Array list of ident/callsign names
2598
	*
2599
	*/
2600
	public function getAllIdents()
2601
	{
2602
		$query  = "SELECT DISTINCT spotter_output.ident
2603
								FROM spotter_output
2604
								WHERE spotter_output.ident <> '' 
2605
								ORDER BY spotter_output.date ASC LIMIT 700 OFFSET 0";
2606
2607
		$sth = $this->db->prepare($query);
2608
		$sth->execute();
2609
    
2610
		$ident_array = array();
2611
		$temp_array = array();
2612
		
2613
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
2614
		{
2615
			$temp_array['ident'] = $row['ident'];
2616
			$ident_array[] = $temp_array;
2617
		}
2618
2619
		return $ident_array;
2620
	}
2621
2622
	/**
2623
	* Get a list of flights from airport since 7 days
2624
	* @return Array number, icao, name and city of airports
2625
	*/
2626
2627
	public function getLast7DaysAirportsDeparture($airport_icao = '') {
2628
		global $globalTimezone, $globalDBdriver;
2629
		if ($globalTimezone != '') {
2630
			date_default_timezone_set($globalTimezone);
2631
			$datetime = new DateTime();
2632
			$offset = $datetime->format('P');
2633
		} else $offset = '+00:00';
2634
		if ($airport_icao == '') {
2635
			if ($globalDBdriver == 'mysql') {
2636
				$query = "SELECT COUNT(departure_airport_icao) AS departure_airport_count, departure_airport_icao, departure_airport_name, departure_airport_city, departure_airport_country, DATE_FORMAT(DATE(CONVERT_TZ(spotter_output.date,'+00:00', :offset)),'%Y-%m-%d') as date FROM `spotter_output` WHERE spotter_output.date >= DATE_SUB(UTC_TIMESTAMP(), INTERVAL 7 DAY) AND departure_airport_icao <> 'NA' GROUP BY departure_airport_icao, DATE_FORMAT(DATE(CONVERT_TZ(spotter_output.date,'+00:00', :offset)),'%Y-%m-%d'), departure_airport_name, departure_airport_city, departure_airport_country ORDER BY departure_airport_count DESC";
2637
			} else {
2638
				$query = "SELECT COUNT(departure_airport_icao) AS departure_airport_count, departure_airport_icao, departure_airport_name, departure_airport_city, departure_airport_country, to_char(spotter_output.date AT TIME ZONE INTERVAL :offset,'YYYY-mm-dd') as date FROM spotter_output WHERE spotter_output.date >= CURRENT_TIMESTAMP AT TIME ZONE 'UTC' - INTERVAL '7 DAYS' AND departure_airport_icao <> 'NA' GROUP BY departure_airport_icao, to_char(spotter_output.date AT TIME ZONE INTERVAL :offset,'YYYY-mm-dd'), departure_airport_name, departure_airport_city, departure_airport_country ORDER BY departure_airport_count DESC";
2639
			}
2640
			$sth = $this->db->prepare($query);
2641
			$sth->execute(array(':offset' => $offset));
2642
		} else {
2643
			if ($globalDBdriver == 'mysql') {
2644
				$query = "SELECT COUNT(departure_airport_icao) AS departure_airport_count, departure_airport_icao, departure_airport_name, departure_airport_city, departure_airport_country, DATE_FORMAT(DATE(CONVERT_TZ(spotter_output.date,'+00:00', :offset)),'%Y-%m-%d') as date FROM `spotter_output` WHERE spotter_output.date >= DATE_SUB(UTC_TIMESTAMP(), INTERVAL 7 DAY) AND departure_airport_icao = :airport_icao GROUP BY departure_airport_icao, DATE_FORMAT(DATE(CONVERT_TZ(spotter_output.date,'+00:00', :offset)),'%Y-%m-%d'), departure_airport_name, departure_airport_city, departure_airport_country ORDER BY departure_airport_count DESC";
2645
			} else {
2646
				$query = "SELECT COUNT(departure_airport_icao) AS departure_airport_count, departure_airport_icao, departure_airport_name, departure_airport_city, departure_airport_country, to_char(spotter_output.date AT TIME ZONE INTERVAL :offset,'YYYY-mm-dd') as date FROM spotter_output WHERE spotter_output.date >= CURRENT_TIMESTAMP AT TIME ZONE 'UTC' - INTERVAL '7 DAYS' AND departure_airport_icao = :airport_icao GROUP BY departure_airport_icao, to_char(spotter_output.date AT TIME ZONE INTERVAL :offset,'YYYY-mm-dd'), departure_airport_name, departure_airport_city, departure_airport_country ORDER BY departure_airport_count DESC";
2647
			}
2648
			$sth = $this->db->prepare($query);
2649
			$sth->execute(array(':offset' => $offset, ':airport_icao' => $airport_icao));
2650
		}
2651
		return $sth->fetchAll(PDO::FETCH_ASSOC);
2652
	}
2653
2654
	/**
2655
	* Get a list of flights from detected airport since 7 days
2656
	* @return Array number, icao, name and city of airports
2657
	*/
2658
2659
	public function getLast7DaysDetectedAirportsDeparture($airport_icao = '') {
2660
		global $globalTimezone, $globalDBdriver;
2661
		if ($globalTimezone != '') {
2662
			date_default_timezone_set($globalTimezone);
2663
			$datetime = new DateTime();
2664
			$offset = $datetime->format('P');
2665
		} else $offset = '+00:00';
2666
		if ($airport_icao == '') {
2667
			if ($globalDBdriver == 'mysql') {
2668
				$query = "SELECT COUNT(real_departure_airport_icao) AS departure_airport_count, real_departure_airport_icao AS departure_airport_icao, airport.name AS departure_airport_name, airport.city AS departure_airport_city, airport.country AS departure_airport_country, DATE_FORMAT(DATE(CONVERT_TZ(spotter_output.date,'+00:00', :offset)),'%Y-%m-%d') as date 
2669
				FROM `spotter_output`, airport 
2670
				WHERE airport.icao = spotter_output.real_departure_airport_icao AND spotter_output.date >= DATE_SUB(UTC_TIMESTAMP(), INTERVAL 7 DAY) AND real_departure_airport_icao <> 'NA' 
2671
				GROUP BY real_departure_airport_icao, DATE_FORMAT(DATE(CONVERT_TZ(spotter_output.date,'+00:00', :offset)),'%Y-%m-%d'), airport.name, airport.city, airport.country ORDER BY departure_airport_count DESC";
2672
			} else {
2673
				$query = "SELECT COUNT(real_departure_airport_icao) AS departure_airport_count, real_departure_airport_icao AS departure_airport_icao, airport.name AS departure_airport_name, airport.city AS departure_airport_city, airport.country AS departure_airport_country, to_char(spotter_output.date AT TIME ZONE INTERVAL :offset,'YYYY-mm-dd') as date 
2674
				FROM spotter_output, airport 
2675
				WHERE airport.icao = spotter_output.real_departure_airport_icao AND spotter_output.date >= CURRENT_TIMESTAMP AT TIME ZONE 'UTC' - INTERVAL '7 DAYS' AND real_departure_airport_icao <> 'NA' 
2676
				GROUP BY real_departure_airport_icao, to_char(spotter_output.date AT TIME ZONE INTERVAL :offset,'YYYY-mm-dd'), airport.name, airport.city, airport.country ORDER BY departure_airport_count DESC";
2677
			}
2678
			$sth = $this->db->prepare($query);
2679
			$sth->execute(array(':offset' => $offset));
2680
		} else {
2681
			if ($globalDBdriver == 'mysql') {
2682
				$query = "SELECT COUNT(real_departure_airport_icao) AS departure_airport_count, real_departure_airport_icao AS departure_airport_icao, airport.name AS departure_airport_name, airport.city AS departure_airport_city, airport.country AS departure_airport_country, DATE_FORMAT(DATE(CONVERT_TZ(spotter_output.date,'+00:00', :offset)),'%Y-%m-%d') as date 
2683
				FROM `spotter_output`, airport 
2684
				WHERE airport.icao = spotter_output.real_departure_airport_icao AND spotter_output.date >= DATE_SUB(UTC_TIMESTAMP(), INTERVAL 7 DAY) AND real_departure_airport_icao = :airport_icao 
2685
				GROUP BY departure_airport_icao, DATE_FORMAT(DATE(CONVERT_TZ(spotter_output.date,'+00:00', :offset)),'%Y-%m-%d'), airport.name, airport.city, airport.country ORDER BY departure_airport_count DESC";
2686
			} else {
2687
				$query = "SELECT COUNT(real_departure_airport_icao) AS departure_airport_count, real_departure_airport_icao AS departure_airport_icao, airport.name AS departure_airport_name, airport.city AS departure_airport_city, airport.country AS departure_airport_country, to_char(spotter_output.date AT TIME ZONE INTERVAL :offset,'YYYY-mm-dd') as date 
2688
				FROM spotter_output, airport 
2689
				WHERE airport.icao = spotter_output.real_departure_airport_icao AND spotter_output.date >= CURRENT_TIMESTAMP AT TIME ZONE 'UTC' - INTERVAL '7 DAYS' AND real_departure_airport_icao = :airport_icao GROUP BY departure_airport_icao, to_char(spotter_output.date AT TIME ZONE INTERVAL :offset,'YYYY-mm-dd'), airport.name, airport.city, airport.country ORDER BY departure_airport_count DESC";
2690
			}
2691
			$sth = $this->db->prepare($query);
2692
			$sth->execute(array(':offset' => $offset, ':airport_icao' => $airport_icao));
2693
		}
2694
		return $sth->fetchAll(PDO::FETCH_ASSOC);
2695
	}
2696
2697
	/**
2698
	* Get a list of flights to airport since 7 days
2699
	* @return Array number, icao, name and city of airports
2700
	*/
2701
2702
	public function getLast7DaysAirportsArrival($airport_icao = '') {
2703
		global $globalTimezone, $globalDBdriver;
2704
		if ($globalTimezone != '') {
2705
			date_default_timezone_set($globalTimezone);
2706
			$datetime = new DateTime();
2707
			$offset = $datetime->format('P');
2708
		} else $offset = '+00:00';
2709
		if ($airport_icao == '') {
2710
			if ($globalDBdriver == 'mysql') {
2711
				$query = "SELECT COUNT(arrival_airport_icao) AS arrival_airport_count, arrival_airport_icao, arrival_airport_name, arrival_airport_city, arrival_airport_country, DATE_FORMAT(DATE(CONVERT_TZ(spotter_output.date,'+00:00', :offset)),'%Y-%m-%d') as date FROM `spotter_output` WHERE spotter_output.date >= DATE_SUB(UTC_TIMESTAMP(), INTERVAL 7 DAY) AND arrival_airport_icao <> 'NA' GROUP BY arrival_airport_icao, DATE_FORMAT(DATE(CONVERT_TZ(spotter_output.date,'+00:00', :offset)),'%Y-%m-%d'), arrival_airport_name, arrival_airport_city, arrival_airport_country ORDER BY arrival_airport_count DESC";
2712
			} else {
2713
				$query = "SELECT COUNT(arrival_airport_icao) AS arrival_airport_count, arrival_airport_icao, arrival_airport_name, arrival_airport_city, arrival_airport_country, to_char(spotter_output.date AT TIME ZONE INTERVAL :offset,'YYYY-mm-dd') as date FROM spotter_output WHERE spotter_output.date >= CURRENT_TIMESTAMP AT TIME ZONE 'UTC' - INTERVAL '7 DAYS' AND arrival_airport_icao <> 'NA' GROUP BY arrival_airport_icao, to_char(spotter_output.date AT TIME ZONE INTERVAL :offset,'YYYY-mm-dd'), arrival_airport_name, arrival_airport_city, arrival_airport_country ORDER BY arrival_airport_count DESC";
2714
			}
2715
			$sth = $this->db->prepare($query);
2716
			$sth->execute(array(':offset' => $offset));
2717
		} else {
2718
			if ($globalDBdriver == 'mysql') {
2719
				$query = "SELECT COUNT(arrival_airport_icao) AS arrival_airport_count, arrival_airport_icao, arrival_airport_name, arrival_airport_city, arrival_airport_country, DATE_FORMAT(DATE(CONVERT_TZ(spotter_output.date,'+00:00', :offset)),'%Y-%m-%d') as date FROM `spotter_output` WHERE spotter_output.date >= DATE_SUB(UTC_TIMESTAMP(), INTERVAL 7 DAY) AND arrival_airport_icao = :airport_icao GROUP BY arrival_airport_icao, DATE_FORMAT(DATE(CONVERT_TZ(spotter_output.date,'+00:00', :offset)),'%Y-%m-%d'),arrival_airport_name, arrival_airport_city, arrival_airport_country ORDER BY arrival_airport_count DESC";
2720
			} else {
2721
				$query = "SELECT COUNT(arrival_airport_icao) AS arrival_airport_count, arrival_airport_icao, arrival_airport_name, arrival_airport_city, arrival_airport_country, to_char(spotter_output.date AT TIME ZONE INTERVAL :offset,'YYYY-mm-dd') as date FROM spotter_output WHERE spotter_output.date >= CURRENT_TIMESTAMP AT TIME ZONE 'UTC' - INTERVAL '7 DAYS' AND arrival_airport_icao = :airport_icao GROUP BY arrival_airport_icao, to_char(spotter_output.date AT TIME ZONE INTERVAL :offset,'YYYY-mm-dd'), arrival_airport_name, arrival_airport_city, arrival_airport_country ORDER BY arrival_airport_count DESC";
2722
			}
2723
			$sth = $this->db->prepare($query);
2724
			$sth->execute(array(':offset' => $offset, ':airport_icao' => $airport_icao));
2725
		}
2726
		
2727
		return $sth->fetchAll(PDO::FETCH_ASSOC);
2728
	}
2729
2730
2731
	/**
2732
	* Get a list of flights detected to airport since 7 days
2733
	* @return Array number, icao, name and city of airports
2734
	*/
2735
2736
	public function getLast7DaysDetectedAirportsArrival($airport_icao = '') {
2737
		global $globalTimezone, $globalDBdriver;
2738
		if ($globalTimezone != '') {
2739
			date_default_timezone_set($globalTimezone);
2740
			$datetime = new DateTime();
2741
			$offset = $datetime->format('P');
2742
		} else $offset = '+00:00';
2743
		if ($airport_icao == '') {
2744
			if ($globalDBdriver == 'mysql') {
2745
				$query = "SELECT COUNT(real_arrival_airport_icao) AS arrival_airport_count, real_arrival_airport_icao AS arrival_airport_icao, airport.name AS arrival_airport_name, airport.city AS arrival_airport_city, airport.country AS arrival_airport_country, DATE_FORMAT(DATE(CONVERT_TZ(spotter_output.date,'+00:00', :offset)),'%Y-%m-%d') as date 
2746
				FROM `spotter_output`, airport 
2747
				WHERE airport.icao = spotter_output.real_arrival_airport_icao AND spotter_output.date >= DATE_SUB(UTC_TIMESTAMP(), INTERVAL 7 DAY) AND arrival_airport_icao <> 'NA' 
2748
				GROUP BY real_arrival_airport_icao, DATE_FORMAT(DATE(CONVERT_TZ(spotter_output.date,'+00:00', :offset)),'%Y-%m-%d'), airport.name, airport.city, airport.country ORDER BY arrival_airport_count DESC";
2749
			} else {
2750
				$query = "SELECT COUNT(real_arrival_airport_icao) AS arrival_airport_count, real_arrival_airport_icao AS arrival_airport_icao, airport.name AS arrival_airport_name, airport.city AS arrival_airport_city, airport.country AS arrival_airport_country, to_char(spotter_output.date AT TIME ZONE INTERVAL :offset,'YYYY-mm-dd') as date 
2751
				FROM spotter_output, airport 
2752
				WHERE airport.icao = spotter_output.real_arrival_airport_icao AND spotter_output.date >= CURRENT_TIMESTAMP AT TIME ZONE 'UTC' - INTERVAL '7 DAYS' AND arrival_airport_icao <> 'NA' 
2753
				GROUP BY real_arrival_airport_icao, to_char(spotter_output.date AT TIME ZONE INTERVAL :offset,'YYYY-mm-dd'), airport.name, airport.city, airport.country ORDER BY arrival_airport_count DESC";
2754
			}
2755
			$sth = $this->db->prepare($query);
2756
			$sth->execute(array(':offset' => $offset));
2757
		} else {
2758
			if ($globalDBdriver == 'mysql') {
2759
				$query = "SELECT COUNT(real_arrival_airport_icao) AS arrival_airport_count, real_arrival_airport_icao AS arrival_airport_icao, airport.name AS arrival_airport_name, airport.city AS arrival_airport_city, airport.country AS arrival_airport_country, DATE_FORMAT(DATE(CONVERT_TZ(spotter_output.date,'+00:00', :offset)),'%Y-%m-%d') as date 
2760
				FROM `spotter_output`, airport 
2761
				WHERE airport.icao = spotter_output.real_arrival_airport_icao AND spotter_output.date >= DATE_SUB(UTC_TIMESTAMP(), INTERVAL 7 DAY) AND arrival_airport_icao = :airport_icao 
2762
				GROUP BY real_arrival_airport_icao, DATE_FORMAT(DATE(CONVERT_TZ(spotter_output.date,'+00:00', :offset)),'%Y-%m-%d'),airport.name, airport.city, airport.country ORDER BY arrival_airport_count DESC";
2763
			} else {
2764
				$query = "SELECT COUNT(real_arrival_airport_icao) AS arrival_airport_count, real_arrival_airport_icao AS arrival_airport_icao, airport.name AS arrival_airport_name, airport.city AS arrival_airport_city, airport.country AS arrival_airport_country, to_char(spotter_output.date AT TIME ZONE INTERVAL :offset,'YYYY-mm-dd') as date 
2765
				FROM spotter_output, airport 
2766
				WHERE airport.icao = spotter_output.real_arrival_airport_icao AND spotter_output.date >= CURRENT_TIMESTAMP AT TIME ZONE 'UTC' - INTERVAL '7 DAYS' AND arrival_airport_icao = :airport_icao 
2767
				GROUP BY real_arrival_airport_icao, to_char(spotter_output.date AT TIME ZONE INTERVAL :offset,'YYYY-mm-dd'), airport.name, airport.city, airport.country ORDER BY arrival_airport_count DESC";
2768
			}
2769
			$sth = $this->db->prepare($query);
2770
			$sth->execute(array(':offset' => $offset, ':airport_icao' => $airport_icao));
2771
		}
2772
		
2773
		return $sth->fetchAll(PDO::FETCH_ASSOC);
2774
	}
2775
2776
2777
	/**
2778
	* Gets a list of all dates
2779
	*
2780
	* @return Array list of date names
2781
	*
2782
	*/
2783
	public function getAllDates()
2784
	{
2785
		global $globalTimezone, $globalDBdriver;
2786
		if ($globalTimezone != '') {
2787
			date_default_timezone_set($globalTimezone);
2788
			$datetime = new DateTime();
2789
			$offset = $datetime->format('P');
2790
		} else $offset = '+00:00';
2791
2792
		if ($globalDBdriver == 'mysql') {
2793
			$query  = "SELECT DISTINCT DATE(CONVERT_TZ(spotter_output.date,'+00:00', :offset)) as date
2794
								FROM spotter_output
2795
								WHERE spotter_output.date <> '' 
2796
								ORDER BY spotter_output.date ASC LIMIT 0,200";
2797
		} else {
2798
			$query  = "SELECT DISTINCT to_char(spotter_output.date AT TIME ZONE INTERVAL :offset,'YYYY-mm-dd') as date
2799
								FROM spotter_output
2800
								WHERE spotter_output.date <> '' 
2801
								ORDER BY spotter_output.date ASC LIMIT 0,200";
2802
		}
2803
		
2804
		$sth = $this->db->prepare($query);
2805
		$sth->execute(array(':offset' => $offset));
2806
    
2807
		$date_array = array();
2808
		$temp_array = array();
2809
		
2810
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
2811
		{
2812
			$temp_array['date'] = $row['date'];
2813
2814
			$date_array[] = $temp_array;
2815
		}
2816
2817
		return $date_array;
2818
	}
2819
	
2820
	
2821
	
2822
	/**
2823
	* Gets all route combinations
2824
	*
2825
	* @return Array the route list
2826
	*
2827
	*/
2828
	public function getAllRoutes()
2829
	{
2830
		$query  = "SELECT DISTINCT concat(spotter_output.departure_airport_icao, ' - ',  spotter_output.arrival_airport_icao) AS route,  spotter_output.departure_airport_icao, spotter_output.arrival_airport_icao 
2831
				FROM spotter_output
2832
				WHERE spotter_output.ident <> '' 
2833
				GROUP BY route
2834
				ORDER BY route ASC";
2835
2836
		$sth = $this->db->prepare($query);
2837
		$sth->execute();
2838
2839
		$routes_array = array();
2840
		$temp_array = array();
2841
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
2842
		{
2843
			$temp_array['route'] = $row['route'];
2844
			$temp_array['airport_departure_icao'] = $row['departure_airport_icao'];
2845
			$temp_array['airport_arrival_icao'] = $row['arrival_airport_icao'];
2846
2847
			$routes_array[] = $temp_array;
2848
		}
2849
		return $routes_array;
2850
	}
2851
2852
	/**
2853
	* Update ident spotter data
2854
	*
2855
	* @param String $flightaware_id the ID from flightaware
2856
	* @param String $ident the flight ident
2857
	* @return String success or false
2858
	*
2859
	*/	
2860
	public function updateIdentSpotterData($flightaware_id = '', $ident = '')
2861
	{
2862
		if (!is_numeric(substr($ident, 0, 3)))
2863
		{
2864
			if (is_numeric(substr(substr($ident, 0, 3), -1, 1))) {
2865
				$airline_array = $this->getAllAirlineInfo(substr($ident, 0, 2));
2866
			} elseif (is_numeric(substr(substr($ident, 0, 4), -1, 1))) {
2867
				$airline_array = $this->getAllAirlineInfo(substr($ident, 0, 3));
2868
			} else {
2869
				$airline_array = $this->getAllAirlineInfo("NA");
2870
			}
2871
			if (count($airline_array) == 0) {
2872
				$airline_array = $this->getAllAirlineInfo("NA");
2873
			}
2874
			if (!isset($airline_array[0]['icao']) || $airline_array[0]['icao'] == ""){
2875
				$airline_array = $this->getAllAirlineInfo("NA");
2876
			}
2877
		} else {
2878
			$airline_array = $this->getAllAirlineInfo("NA");
2879
		}
2880
                $airline_name = $airline_array[0]['name'];
2881
                $airline_icao = $airline_array[0]['icao'];
2882
                $airline_country = $airline_array[0]['country'];
2883
                $airline_type = $airline_array[0]['type'];
2884
2885
2886
		$query = 'UPDATE spotter_output SET ident = :ident, airline_name = :airline_name, airline_icao = :airline_icao, airline_country = :airline_country, airline_type = :airline_type WHERE flightaware_id = :flightaware_id';
2887
                $query_values = array(':flightaware_id' => $flightaware_id,':ident' => $ident,':airline_name' => $airline_name,':airline_icao' => $airline_icao,':airline_country' => $airline_country,':airline_type' => $airline_type);
2888
2889
		try {
2890
			$sth = $this->db->prepare($query);
2891
			$sth->execute($query_values);
2892
		} catch (PDOException $e) {
2893
			return "error : ".$e->getMessage();
2894
		}
2895
		
2896
		return "success";
2897
2898
	}
2899
	/**
2900
	* Update latest spotter data
2901
	*
2902
	* @param String $flightaware_id the ID from flightaware
2903
	* @param String $ident the flight ident
2904
	* @param String $arrival_airport_icao the arrival airport
2905
	* @return String success or false
2906
	*
2907
	*/	
2908
	public function updateLatestSpotterData($flightaware_id = '', $ident = '', $latitude = '', $longitude = '', $altitude = '', $ground = false, $groundspeed = NULL, $date = '', $arrival_airport_icao = '',$arrival_airport_time = '')
2909
	{
2910
		if ($groundspeed == '') $groundspeed = NULL;
2911
		$query = 'UPDATE spotter_output SET ident = :ident, last_latitude = :last_latitude, last_longitude = :last_longitude, last_altitude = :last_altitude, last_ground = :last_ground, last_seen = :last_seen, real_arrival_airport_icao = :real_arrival_airport_icao, real_arrival_airport_time = :real_arrival_airport_time, last_ground_speed = :last_ground_speed WHERE flightaware_id = :flightaware_id';
2912
                $query_values = array(':flightaware_id' => $flightaware_id,':real_arrival_airport_icao' => $arrival_airport_icao,':last_latitude' => $latitude,':last_longitude' => $longitude, ':last_altitude' => $altitude,':last_ground_speed' => $groundspeed,':last_seen' => $date,':real_arrival_airport_time' => $arrival_airport_time, ':last_ground' => $ground, ':ident' => $ident);
2913
2914
		try {
2915
			$sth = $this->db->prepare($query);
2916
			$sth->execute($query_values);
2917
		} catch (PDOException $e) {
2918
			return "error : ".$e->getMessage();
2919
		}
2920
		
2921
		return "success";
2922
2923
	}
2924
2925
	/**
2926
	* Adds a new spotter data
2927
	*
2928
	* @param String $flightaware_id the ID from flightaware
2929
	* @param String $ident the flight ident
2930
	* @param String $aircraft_icao the aircraft type
2931
	* @param String $departure_airport_icao the departure airport
2932
	* @param String $arrival_airport_icao the arrival airport
2933
	* @param String $latitude latitude of flight
2934
	* @param String $longitude latitude of flight
2935
	* @param String $waypoints waypoints of flight
2936
	* @param String $altitude altitude of flight
2937
	* @param String $heading heading of flight
2938
	* @param String $groundspeed speed of flight
2939
	* @param String $date date of flight
2940
	* @param String $departure_airport_time departure time of flight
2941
	* @param String $arrival_airport_time arrival time of flight
2942
	* @param String $squawk squawk code of flight
2943
	* @param String $route_stop route stop of flight
2944
	* @param String $highlight highlight or not
2945
	* @param String $ModeS ModesS code of flight
2946
	* @param String $registration registration code of flight
2947
	* @param String $pilot_id pilot id of flight (for virtual airlines)
2948
	* @param String $pilot_name pilot name of flight (for virtual airlines)
2949
	* @param String $verticalrate vertival rate of flight
2950
	* @return String success or false
2951
	*/
2952
	public function addSpotterData($flightaware_id = '', $ident = '', $aircraft_icao = '', $departure_airport_icao = '', $arrival_airport_icao = '', $latitude = '', $longitude = '', $waypoints = '', $altitude = '', $heading = '', $groundspeed = '', $date = '', $departure_airport_time = '', $arrival_airport_time = '',$squawk = '', $route_stop = '', $highlight = '', $ModeS = '', $registration = '',$pilot_id = '', $pilot_name = '', $verticalrate = '', $ground = false,$format_source = '', $source_name = '')
2953
	{
2954
		global $globalURL, $globalIVAO, $globalVATSIM, $globalphpVMS, $globalDebugTimeElapsed;
2955
		
2956
		//if (isset($globalDebugTimeElapsed) || $globalDebugTimeElapsed == '') $globalDebugTimeElapsed = FALSE;
2957
		$Image = new Image($this->db);
2958
		$Common = new Common();
2959
		
2960
		if (!isset($globalIVAO)) $globalIVAO = FALSE;
2961
		if (!isset($globalVATSIM)) $globalVATSIM = FALSE;
2962
		if (!isset($globalphpVMS)) $globalphpVMS = FALSE;
2963
		date_default_timezone_set('UTC');
2964
		
2965
		//getting the registration
2966
		if ($flightaware_id != "" && $registration == '')
2967
		{
2968
			if (!is_string($flightaware_id))
2969
			{
2970
				return false;
2971
			} else {
2972
				if ($ModeS != '') {
2973
					$timeelapsed = microtime(true);
2974
					$registration = $this->getAircraftRegistrationBymodeS($ModeS);
2975
					if ($globalDebugTimeElapsed) echo 'ADD SPOTTER DATA : Time elapsed for getAircraftRegistrationBymodes : '.round(microtime(true)-$timeelapsed,2).'s'."\n";
2976
				} else {
2977
					$myhex = explode('-',$flightaware_id);
2978
					if (count($myhex) > 0) {
2979
						$timeelapsed = microtime(true);
2980
						$registration = $this->getAircraftRegistrationBymodeS($myhex[0]);
2981
						if ($globalDebugTimeElapsed) echo 'ADD SPOTTER DATA : Time elapsed for getAircraftRegistrationBymodes : '.round(microtime(true)-$timeelapsed,2).'s'."\n";
2982
					}
2983
				}
2984
			}
2985
		}
2986
2987
		//getting the airline information
2988
		if ($ident != "")
2989
		{
2990
			if (!is_string($ident))
2991
			{
2992
				return false;
2993
			} else {
2994
				if (!is_numeric(substr($ident, 0, 3)))
2995
				{
2996
					$timeelapsed = microtime(true);
2997
					if (is_numeric(substr(substr($ident, 0, 3), -1, 1))) {
2998
						$airline_array = $this->getAllAirlineInfo(substr($ident, 0, 2));
2999
					} elseif (is_numeric(substr(substr($ident, 0, 4), -1, 1))) {
3000
						$airline_array = $this->getAllAirlineInfo(substr($ident, 0, 3));
3001
					} else {
3002
						$airline_array = $this->getAllAirlineInfo("NA");
3003
					}
3004
					if (count($airline_array) == 0) {
3005
						$airline_array = $this->getAllAirlineInfo("NA");
3006
					}
3007
					if (!isset($airline_array[0]['icao']) || $airline_array[0]['icao'] == ""){
3008
						$airline_array = $this->getAllAirlineInfo("NA");
3009
					}
3010
					if ($globalDebugTimeElapsed) echo 'ADD SPOTTER DATA : Time elapsed for getAirlineInfo : '.round(microtime(true)-$timeelapsed,2).'s'."\n";
3011
3012
				} else {
3013
					$timeelapsed = microtime(true);
3014
					$airline_array = $this->getAllAirlineInfo("NA");
3015
					if ($globalDebugTimeElapsed) echo 'ADD SPOTTER DATA : Time elapsed for getAirlineInfo(NA) : '.round(microtime(true)-$timeelapsed,2).'s'."\n";
3016
				}
3017
			}
3018
		} else $airline_array = array();
3019
		
3020
		//getting the aircraft information
3021
		$aircraft_array = array();
3022
		if ($aircraft_icao != "")
3023
		{
3024
			if (!is_string($aircraft_icao))
3025
			{
3026
				return false;
3027
			} else {
3028
				if ($aircraft_icao == "" || $aircraft_icao == "XXXX")
3029
				{
3030
					$timeelapsed = microtime(true);
3031
					$aircraft_array = $this->getAllAircraftInfo("NA");
3032
					if ($globalDebugTimeElapsed) echo 'ADD SPOTTER DATA : Time elapsed for getAircraftInfo(NA) : '.round(microtime(true)-$timeelapsed,2).'s'."\n";
3033
				} else {
3034
					$timeelapsed = microtime(true);
3035
					$aircraft_array = $this->getAllAircraftInfo($aircraft_icao);
3036
					if ($globalDebugTimeElapsed) echo 'ADD SPOTTER DATA : Time elapsed for getAircraftInfo : '.round(microtime(true)-$timeelapsed,2).'s'."\n";
3037
				}
3038
			}
3039
		} else {
3040
			if ($ModeS != '') {
3041
				$timeelapsed = microtime(true);
3042
				$aircraft_icao = $this->getAllAircraftType($ModeS);
3043
				if ($globalDebugTimeElapsed) echo 'ADD SPOTTER DATA : Time elapsed for getAllAircraftType : '.round(microtime(true)-$timeelapsed,2).'s'."\n";
3044
				if ($aircraft_icao == "" || $aircraft_icao == "XXXX")
3045
				{
3046
					$timeelapsed = microtime(true);
3047
					$aircraft_array = $this->getAllAircraftInfo("NA");
3048
					if ($globalDebugTimeElapsed) echo 'ADD SPOTTER DATA : Time elapsed for getAircraftInfo(NA) : '.round(microtime(true)-$timeelapsed,2).'s'."\n";
3049
				} else {
3050
					$timeelapsed = microtime(true);
3051
					$aircraft_array = $this->getAllAircraftInfo($aircraft_icao);
3052
					if ($globalDebugTimeElapsed) echo 'ADD SPOTTER DATA : Time elapsed for getAircraftInfo : '.round(microtime(true)-$timeelapsed,2).'s'."\n";
3053
				}
3054
			}
3055
		}
3056
		
3057
		//getting the departure airport information
3058
		$departure_airport_array = array();
3059
		if ($departure_airport_icao != "")
3060
		{
3061
			if (!is_string($departure_airport_icao))
3062
			{
3063
				return false;
3064
			} else {
3065
				$timeelapsed = microtime(true);
3066
				$departure_airport_array = $this->getAllAirportInfo($departure_airport_icao);
3067
				if ($globalDebugTimeElapsed) echo 'ADD SPOTTER DATA : Time elapsed for getAllAirportInfo : '.round(microtime(true)-$timeelapsed,2).'s'."\n";
3068
			}
3069
		}
3070
		
3071
		//getting the arrival airport information
3072
		$arrival_airport_array = array();
3073
		if ($arrival_airport_icao != "")
3074
		{
3075
			if (!is_string($arrival_airport_icao))
3076
			{
3077
				return false;
3078
			} else {
3079
				$timeelapsed = microtime(true);
3080
				$arrival_airport_array = $this->getAllAirportInfo($arrival_airport_icao);
3081
				if ($globalDebugTimeElapsed) echo 'ADD SPOTTER DATA : Time elapsed for getAllAirportInfo : '.round(microtime(true)-$timeelapsed,2).'s'."\n";
3082
			}
3083
		}
3084
3085
						
3086
		if ($latitude != "")
3087
		{
3088
			if (!is_numeric($latitude))
3089
			{
3090
				return false;
3091
			}
3092
		}
3093
		
3094
		if ($longitude != "")
3095
		{
3096
			if (!is_numeric($longitude))
3097
			{
3098
				return false;
3099
			}
3100
		}
3101
		
3102
		if ($waypoints != "")
3103
		{
3104
			if (!is_string($waypoints))
3105
			{
3106
				return false;
3107
			}
3108
		}
3109
		
3110
		if ($altitude != "")
3111
		{
3112
			if (!is_numeric($altitude))
3113
			{
3114
				return false;
3115
			}
3116
		} else $altitude = 0;
3117
		
3118
		if ($heading != "")
3119
		{
3120
			if (!is_numeric($heading))
3121
			{
3122
				return false;
3123
			}
3124
		}
3125
		
3126
		if ($groundspeed != "")
3127
		{
3128
			if (!is_numeric($groundspeed))
3129
			{
3130
				return false;
3131
			}
3132
		}
3133
3134
    
3135
		if ($date == "")
3136
		{
3137
			$date = date("Y-m-d H:i:s", time());
3138
		}
3139
3140
		//getting the aircraft image
3141
		if (($registration != "" || $registration != 'NA') && !$globalIVAO && !$globalVATSIM && !$globalphpVMS)
3142
		{
3143
			$timeelapsed = microtime(true);
3144
			$image_array = $Image->getSpotterImage($registration);
3145
			if ($globalDebugTimeElapsed) echo 'ADD SPOTTER DATA : Time elapsed for getSpotterImage : '.round(microtime(true)-$timeelapsed,2).'s'."\n";
3146
			if (!isset($image_array[0]['registration']))
3147
			{
3148
				//echo "Add image !!!! \n";
3149
				$Image->addSpotterImage($registration);
3150
			}
3151
			$timeelapsed = microtime(true);
3152
			$owner_info = $this->getAircraftOwnerByRegistration($registration);
3153
			if ($globalDebugTimeElapsed) echo 'ADD SPOTTER DATA : Time elapsed for getAircraftOwnerByRegistration : '.round(microtime(true)-$timeelapsed,2).'s'."\n";
3154
			if ($owner_info['owner'] != '') $aircraft_owner = ucwords(strtolower($owner_info['owner']));
3155
		}
3156
    
3157
		if ($globalIVAO && $aircraft_icao != '')
3158
		{
3159
            		if (isset($airline_array[0]['icao'])) $airline_icao = $airline_array[0]['icao'];
3160
            		else $airline_icao = '';
3161
			$image_array = $Image->getSpotterImage('',$aircraft_icao,$airline_icao);
3162
			if (!isset($image_array[0]['registration']))
3163
			{
3164
				//echo "Add image !!!! \n";
3165
				$Image->addSpotterImage('',$aircraft_icao,$airline_icao);
3166
			}
3167
		}
3168
    
3169
		$flightaware_id = filter_var($flightaware_id,FILTER_SANITIZE_STRING);
3170
		$ident = filter_var($ident,FILTER_SANITIZE_STRING);
3171
		$registration = filter_var($registration,FILTER_SANITIZE_STRING);
3172
		$aircraft_icao = filter_var($aircraft_icao,FILTER_SANITIZE_STRING);
3173
		$departure_airport_icao = filter_var($departure_airport_icao,FILTER_SANITIZE_STRING);
3174
		$arrival_airport_icao = filter_var($arrival_airport_icao,FILTER_SANITIZE_STRING);
3175
		$latitude = filter_var($latitude,FILTER_SANITIZE_NUMBER_FLOAT,FILTER_FLAG_ALLOW_FRACTION);
3176
		$longitude = filter_var($longitude,FILTER_SANITIZE_NUMBER_FLOAT,FILTER_FLAG_ALLOW_FRACTION);
3177
		$waypoints = filter_var($waypoints,FILTER_SANITIZE_STRING);
3178
		$altitude = filter_var($altitude,FILTER_SANITIZE_NUMBER_FLOAT,FILTER_FLAG_ALLOW_FRACTION);
3179
		$heading = filter_var($heading,FILTER_SANITIZE_NUMBER_INT);
3180
		$groundspeed = filter_var($groundspeed,FILTER_SANITIZE_NUMBER_FLOAT,FILTER_FLAG_ALLOW_FRACTION);
3181
		$squawk = filter_var($squawk,FILTER_SANITIZE_NUMBER_INT);
3182
		$route_stop = filter_var($route_stop,FILTER_SANITIZE_STRING);
3183
		$ModeS = filter_var($ModeS,FILTER_SANITIZE_STRING);
3184
		$pilot_id = filter_var($pilot_id,FILTER_SANITIZE_STRING);
3185
		$pilot_name = filter_var($pilot_name,FILTER_SANITIZE_STRING);
3186
		$format_source = filter_var($format_source,FILTER_SANITIZE_STRING);
3187
		$verticalrate = filter_var($verticalrate,FILTER_SANITIZE_NUMBER_INT);
3188
	
3189
		if (count($airline_array) == 0) 
3190
		{
3191
                        $airline_array = $this->getAllAirlineInfo('NA');
3192
                }
3193
                if (count($aircraft_array) == 0) 
3194
                {
3195
                        $aircraft_array = $this->getAllAircraftInfo('NA');
3196
                }
3197
                if (count($departure_airport_array) == 0) 
3198
                {
3199
                        $departure_airport_array = $this->getAllAirportInfo('NA');
3200
                }
3201
                if (count($arrival_airport_array) == 0) 
3202
                {
3203
                        $arrival_airport_array = $this->getAllAirportInfo('NA');
3204
                }
3205
                if ($registration == '') $registration = 'NA';
3206
                if ($squawk == '' || $Common->isInteger($squawk) === false) $squawk = NULL;
3207
                if ($verticalrate == '' || $Common->isInteger($verticalrate) === false) $verticalrate = NULL;
3208
                if ($heading == '' || $Common->isInteger($heading) === false) $heading = 0;
3209
                if ($groundspeed == '' || $Common->isInteger($groundspeed) === false) $groundspeed = 0;
3210
                if (!isset($aircraft_owner)) $aircraft_owner = NULL;
3211
                $query  = "INSERT INTO spotter_output (flightaware_id, ident, registration, airline_name, airline_icao, airline_country, airline_type, aircraft_icao, aircraft_name, aircraft_manufacturer, departure_airport_icao, departure_airport_name, departure_airport_city, departure_airport_country, arrival_airport_icao, arrival_airport_name, arrival_airport_city, arrival_airport_country, latitude, longitude, waypoints, altitude, heading, ground_speed, date, departure_airport_time, arrival_airport_time, squawk, route_stop,highlight,ModeS, pilot_id, pilot_name, verticalrate, owner_name, ground, format_source, source_name) 
3212
                VALUES (:flightaware_id,:ident,:registration,:airline_name,:airline_icao,:airline_country,:airline_type,:aircraft_icao,:aircraft_type,:aircraft_manufacturer,:departure_airport_icao,:departure_airport_name,:departure_airport_city,:departure_airport_country, :arrival_airport_icao, :arrival_airport_name, :arrival_airport_city, :arrival_airport_country, :latitude,:longitude,:waypoints,:altitude,:heading,:groundspeed,:date, :departure_airport_time, :arrival_airport_time, :squawk, :route_stop, :highlight, :ModeS, :pilot_id, :pilot_name, :verticalrate, :owner_name,:ground, :format_source, :source_name)";
3213
3214
                $airline_name = $airline_array[0]['name'];
3215
                $airline_icao = $airline_array[0]['icao'];
3216
                $airline_country = $airline_array[0]['country'];
3217
                $airline_type = $airline_array[0]['type'];
3218
		if ($airline_type == '') {
3219
			$timeelapsed = microtime(true);
3220
			$airline_type = $this->getAircraftTypeBymodeS($ModeS);
3221
			if ($globalDebugTimeElapsed) echo 'ADD SPOTTER DATA : Time elapsed for getAircraftTypeBymodes : '.round(microtime(true)-$timeelapsed,2).'s'."\n";
3222
		}
3223
		if ($airline_type == null) $airline_type = '';
3224
                $aircraft_type = $aircraft_array[0]['type'];
3225
                $aircraft_manufacturer = $aircraft_array[0]['manufacturer'];
3226
                $departure_airport_name = $departure_airport_array[0]['name'];
3227
                $departure_airport_city = $departure_airport_array[0]['city'];
3228
                $departure_airport_country = $departure_airport_array[0]['country'];
3229
                $arrival_airport_name = $arrival_airport_array[0]['name'];
3230
                $arrival_airport_city = $arrival_airport_array[0]['city'];
3231
                $arrival_airport_country = $arrival_airport_array[0]['country'];
3232
                $query_values = array(':flightaware_id' => $flightaware_id,':ident' => $ident, ':registration' => $registration,':airline_name' => $airline_name,':airline_icao' => $airline_icao,':airline_country' => $airline_country,':airline_type' => $airline_type,':aircraft_icao' => $aircraft_icao,':aircraft_type' => $aircraft_type,':aircraft_manufacturer' => $aircraft_manufacturer,':departure_airport_icao' => $departure_airport_icao,':departure_airport_name' => $departure_airport_name,':departure_airport_city' => $departure_airport_city,':departure_airport_country' => $departure_airport_country,':arrival_airport_icao' => $arrival_airport_icao,':arrival_airport_name' => $arrival_airport_name,':arrival_airport_city' => $arrival_airport_city,':arrival_airport_country' => $arrival_airport_country,':latitude' => $latitude,':longitude' => $longitude, ':waypoints' => $waypoints,':altitude' => $altitude,':heading' => $heading,':groundspeed' => $groundspeed,':date' => $date,':departure_airport_time' => $departure_airport_time,':arrival_airport_time' => $arrival_airport_time, ':squawk' => $squawk, ':route_stop' => $route_stop, ':highlight' => $highlight, ':ModeS' => $ModeS, ':pilot_id' => $pilot_id, ':pilot_name' => $pilot_name, ':verticalrate' => $verticalrate, ':owner_name' => $aircraft_owner, ':format_source' => $format_source, ':ground' => $ground, ':source_name' => $source_name);
3233
3234
		try {
3235
		        
3236
			$sth = $this->db->prepare($query);
3237
			$sth->execute($query_values);
3238
			$this->db = null;
3239
		} catch (PDOException $e) {
3240
		    return "error : ".$e->getMessage();
3241
		}
3242
		
3243
		return "success";
3244
3245
	}
3246
	
3247
  
3248
	/**
3249
	* Gets the aircraft ident within the last hour
3250
	*
3251
	* @return String the ident
3252
	*
3253
	*/
3254
	public function getIdentFromLastHour($ident)
3255
	{
3256
		global $globalDBdriver, $globalTimezone;
3257
		if ($globalDBdriver == 'mysql') {
3258
			$query  = "SELECT spotter_output.ident FROM spotter_output 
3259
								WHERE spotter_output.ident = :ident 
3260
								AND spotter_output.date >= DATE_SUB(UTC_TIMESTAMP(),INTERVAL 1 HOUR) 
3261
								AND spotter_output.date < UTC_TIMESTAMP()";
3262
			$query_data = array(':ident' => $ident);
3263
		} else {
3264
			$query  = "SELECT spotter_output.ident FROM spotter_output 
3265
								WHERE spotter_output.ident = :ident 
3266
								AND spotter_output.date >= now() AT TIME ZONE 'UTC' - INTERVAL '1 HOURS'
3267
								AND spotter_output.date < now() AT TIME ZONE 'UTC'";
3268
			$query_data = array(':ident' => $ident);
3269
    		}
3270
		
3271
		$sth = $this->db->prepare($query);
3272
		$sth->execute($query_data);
3273
    		$ident_result='';
3274
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
3275
		{
3276
			$ident_result = $row['ident'];
3277
		}
3278
3279
		return $ident_result;
3280
	}
3281
	
3282
	
3283
	/**
3284
	* Gets the aircraft data from the last 20 seconds
3285
	*
3286
	* @return Array the spotter data
3287
	*
3288
	*/
3289
	public function getRealTimeData($q = '')
3290
	{
3291
		global $globalDBdriver;
3292
		$additional_query = '';
3293
		if ($q != "")
3294
		{
3295
			if (!is_string($q))
3296
			{
3297
				return false;
3298
			} else {
3299
				$q_array = explode(" ", $q);
3300
				foreach ($q_array as $q_item){
3301
					$q_item = filter_var($q_item,FILTER_SANITIZE_STRING);
3302
					$additional_query .= " AND (";
3303
					$additional_query .= "(spotter_output.aircraft_icao like '%".$q_item."%') OR ";
3304
					$additional_query .= "(spotter_output.aircraft_name like '%".$q_item."%') OR ";
3305
					$additional_query .= "(spotter_output.aircraft_manufacturer like '%".$q_item."%') OR ";
3306
					$additional_query .= "(spotter_output.airline_icao like '%".$q_item."%') OR ";
3307
					$additional_query .= "(spotter_output.departure_airport_icao like '%".$q_item."%') OR ";
3308
					$additional_query .= "(spotter_output.arrival_airport_icao like '%".$q_item."%') OR ";
3309
					$additional_query .= "(spotter_output.registration like '%".$q_item."%') OR ";
3310
					$additional_query .= "(spotter_output.ident like '%".$q_item."%')";
3311
					$additional_query .= ")";
3312
				}
3313
			}
3314
		}
3315
		if ($globalDBdriver == 'mysql') {
3316
			$query  = "SELECT spotter_output.* FROM spotter_output 
3317
				WHERE spotter_output.date >= DATE_SUB(UTC_TIMESTAMP(),INTERVAL 20 SECOND) ".$additional_query." 
3318
				AND spotter_output.date < UTC_TIMESTAMP()";
3319
		} else {
3320
			$query  = "SELECT spotter_output.* FROM spotter_output 
3321
				WHERE spotter_output.date::timestamp >= CURRENT_TIMESTAMP AT TIME ZONE 'UTC' - INTERVAL '20 SECONDS' ".$additional_query." 
3322
				AND spotter_output.date::timestamp < CURRENT_TIMESTAMP AT TIME ZONE 'UTC'";
3323
		}
3324
		$spotter_array = $this->getDataFromDB($query, array());
3325
3326
		return $spotter_array;
3327
	}
3328
	
3329
	
3330
	
3331
	 /**
3332
	* Gets all airlines that have flown over
3333
	*
3334
	* @return Array the airline list
3335
	*
3336
	*/
3337
	public function countAllAirlines($limit = true, $olderthanmonths = 0, $sincedate = '')
3338
	{
3339
		global $globalDBdriver;
3340
		$query  = "SELECT DISTINCT spotter_output.airline_name, spotter_output.airline_icao, spotter_output.airline_country, COUNT(spotter_output.airline_name) AS airline_count
3341
		 			FROM spotter_output
3342
					WHERE spotter_output.airline_name <> '' AND spotter_output.airline_icao <> 'NA' ";
3343
		if ($olderthanmonths > 0) {
3344
			if ($globalDBdriver == 'mysql') {
3345
				$query .= 'AND spotter_output.date < DATE_SUB(UTC_TIMESTAMP(), INTERVAL '.$olderthanmonths.' MONTH) ';
3346
			} else {
3347
				$query .= "AND spotter_output.date < CURRENT_TIMESTAMP AT TIME ZONE 'UTC' - INTERVAL '".$olderthanmonths." MONTHS' ";
3348
			}
3349
		}
3350
                if ($sincedate != '') {
3351
			if ($globalDBdriver == 'mysql') {
3352
				$query .= "AND spotter_output.date > '".$sincedate."' ";
3353
			} else {
3354
				$query .= "AND spotter_output.date > CAST('".$sincedate."' AS TIMESTAMP)";
3355
			}
3356
		}
3357
		$query .= "GROUP BY spotter_output.airline_name,spotter_output.airline_icao, spotter_output.airline_country ORDER BY airline_count DESC";
3358
		if ($limit) $query .= " LIMIT 10 OFFSET 0";
3359
		
3360
		$sth = $this->db->prepare($query);
3361
		$sth->execute();
3362
 
3363
		$airline_array = array();
3364
		$temp_array = array();
3365
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
3366
		{
3367
			$temp_array['airline_name'] = $row['airline_name'];
3368
			$temp_array['airline_icao'] = $row['airline_icao'];
3369
			$temp_array['airline_count'] = $row['airline_count'];
3370
			$temp_array['airline_country'] = $row['airline_country'];
3371
			$airline_array[] = $temp_array;
3372
		}
3373
		return $airline_array;
3374
	}
3375
3376
	 /**
3377
	* Gets all pilots that have flown over
3378
	*
3379
	* @return Array the pilots list
3380
	*
3381
	*/
3382
	public function countAllPilots($limit = true, $olderthanmonths = 0, $sincedate = '')
3383
	{
3384
		global $globalDBdriver;
3385
		$query  = "SELECT DISTINCT spotter_output.pilot_id, spotter_output.pilot_name, COUNT(spotter_output.pilot_id) AS pilot_count
3386
		 			FROM spotter_output
3387
					WHERE spotter_output.pilot_id <> '' ";
3388
                if ($olderthanmonths > 0) {
3389
            		if ($globalDBdriver == 'mysql') {
3390
				$query .= 'AND spotter_output.date < DATE_SUB(UTC_TIMESTAMP(), INTERVAL '.$olderthanmonths.' MONTH) ';
3391
			} else {
3392
				$query .= "AND spotter_output.date < CURRENT_TIMESTAMP AT TIME ZONE 'UTC' - INTERVAL '".$olderthanmonths." MONTHS' ";
3393
			}
3394
		}
3395
                if ($sincedate != '') {
3396
            		if ($globalDBdriver == 'mysql') {
3397
				$query .= "AND spotter_output.date > '".$sincedate."' ";
3398
			} else {
3399
				$query .= "AND spotter_output.date > CAST('".$sincedate."' AS TIMESTAMP)";
3400
			}
3401
		}
3402
		$query .= "GROUP BY spotter_output.pilot_id,spotter_output.pilot_name ORDER BY pilot_count DESC";
3403
		if ($limit) $query .= " LIMIT 10 OFFSET 0";
3404
      
3405
		
3406
		$sth = $this->db->prepare($query);
3407
		$sth->execute();
3408
      
3409
		$airline_array = array();
3410
		$temp_array = array();
3411
        
3412
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
3413
		{
3414
			$temp_array['pilot_name'] = $row['pilot_name'];
3415
			$temp_array['pilot_id'] = $row['pilot_id'];
3416
			$temp_array['pilot_count'] = $row['pilot_count'];
3417
			$airline_array[] = $temp_array;
3418
		}
3419
		return $airline_array;
3420
	}
3421
	
3422
	 /**
3423
	* Gets all owner that have flown over
3424
	*
3425
	* @return Array the pilots list
3426
	*
3427
	*/
3428
	public function countAllOwners($limit = true, $olderthanmonths = 0, $sincedate = '')
3429
	{
3430
		global $globalDBdriver;
3431
		$query  = "SELECT DISTINCT spotter_output.owner_name, COUNT(spotter_output.owner_name) AS owner_count
3432
		 			FROM spotter_output
3433
					WHERE spotter_output.owner_name <> '' AND spotter_output.owner_name IS NOT NULL ";
3434
                if ($olderthanmonths > 0) {
3435
            		if ($globalDBdriver == 'mysql') {
3436
				$query .= 'AND spotter_output.date < DATE_SUB(UTC_TIMESTAMP(), INTERVAL '.$olderthanmonths.' MONTH) ';
3437
			} else {
3438
				$query .= "AND spotter_output.date < CURRENT_TIMESTAMP AT TIME ZONE 'UTC' - INTERVAL '".$olderthanmonths." MONTHS' ";
3439
			}
3440
		}
3441
                if ($sincedate != '') {
3442
            		if ($globalDBdriver == 'mysql') {
3443
				$query .= "AND spotter_output.date > '".$sincedate."' ";
3444
			} else {
3445
				$query .= "AND spotter_output.date > CAST('".$sincedate."' AS TIMESTAMP)";
3446
			}
3447
		}
3448
		$query .= "GROUP BY spotter_output.owner_name ORDER BY owner_count DESC";
3449
		if ($limit) $query .= " LIMIT 10 OFFSET 0";
3450
      
3451
		
3452
		$sth = $this->db->prepare($query);
3453
		$sth->execute();
3454
      
3455
		$airline_array = array();
3456
		$temp_array = array();
3457
        
3458
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
3459
		{
3460
			$temp_array['owner_name'] = $row['owner_name'];
3461
			$temp_array['owner_count'] = $row['owner_count'];
3462
			$airline_array[] = $temp_array;
3463
		}
3464
		return $airline_array;
3465
	}
3466
	
3467
	
3468
	/**
3469
	* Gets all airlines that have flown over by aircraft
3470
	*
3471
	* @return Array the airline list
3472
	*
3473
	*/
3474
	public function countAllAirlinesByAircraft($aircraft_icao)
3475
	{
3476
		$aircraft_icao = filter_var($aircraft_icao,FILTER_SANITIZE_STRING);
3477
3478
		$query  = "SELECT DISTINCT spotter_output.airline_name, spotter_output.airline_icao, spotter_output.airline_country, COUNT(spotter_output.airline_name) AS airline_count
3479
		 			FROM spotter_output
3480
					WHERE spotter_output.airline_name <> '' AND spotter_output.aircraft_icao = :aircraft_icao 
3481
                    GROUP BY spotter_output.airline_name
3482
					ORDER BY airline_count DESC";
3483
      
3484
		
3485
		$sth = $this->db->prepare($query);
3486
		$sth->execute(array(':aircraft_icao' => $aircraft_icao));
3487
      
3488
		$airline_array = array();
3489
		$temp_array = array();
3490
        
3491
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
3492
		{
3493
			$temp_array['airline_name'] = $row['airline_name'];
3494
			$temp_array['airline_icao'] = $row['airline_icao'];
3495
			$temp_array['airline_count'] = $row['airline_count'];
3496
			$temp_array['airline_country'] = $row['airline_country'];
3497
3498
			$airline_array[] = $temp_array;
3499
		}
3500
3501
		return $airline_array;
3502
	}
3503
3504
3505
	/**
3506
	* Gets all airline countries that have flown over by aircraft
3507
	*
3508
	* @return Array the airline country list
3509
	*
3510
	*/
3511
	public function countAllAirlineCountriesByAircraft($aircraft_icao)
3512
	{
3513
		$aircraft_icao = filter_var($aircraft_icao,FILTER_SANITIZE_STRING);
3514
      
3515
		$query  = "SELECT DISTINCT spotter_output.airline_country, COUNT(spotter_output.airline_country) AS airline_country_count
3516
		 			FROM spotter_output
3517
					WHERE spotter_output.airline_country <> '' AND spotter_output.aircraft_icao = :aircraft_icao
3518
                    GROUP BY spotter_output.airline_country
3519
					ORDER BY airline_country_count DESC
3520
					LIMIT 10 OFFSET 0";
3521
      
3522
		
3523
		$sth = $this->db->prepare($query);
3524
		$sth->execute(array(':aircraft_icao' => $aircraft_icao));
3525
      
3526
		$airline_country_array = array();
3527
		$temp_array = array();
3528
        
3529
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
3530
		{
3531
			$temp_array['airline_country_count'] = $row['airline_country_count'];
3532
			$temp_array['airline_country'] = $row['airline_country'];
3533
 
3534
			$airline_country_array[] = $temp_array;
3535
		}
3536
		return $airline_country_array;
3537
	}
3538
3539
3540
	
3541
	
3542
	/**
3543
	* Gets all airlines that have flown over by airport
3544
	*
3545
	* @return Array the airline list
3546
	*
3547
	*/
3548
	public function countAllAirlinesByAirport($airport_icao)
3549
	{
3550
		$airport_icao = filter_var($airport_icao,FILTER_SANITIZE_STRING);
3551
3552
		$query  = "SELECT DISTINCT spotter_output.airline_name, spotter_output.airline_icao, spotter_output.airline_country, COUNT(spotter_output.airline_name) AS airline_count
3553
		 			FROM spotter_output
3554
					WHERE spotter_output.airline_name <> '' AND (spotter_output.departure_airport_icao = :airport_icao OR spotter_output.arrival_airport_icao = :airport_icao ) 
3555
                    GROUP BY spotter_output.airline_name
3556
					ORDER BY airline_count DESC";
3557
      
3558
		
3559
		$sth = $this->db->prepare($query);
3560
		$sth->execute(array(':airport_icao' => $airport_icao));
3561
      
3562
		$airline_array = array();
3563
		$temp_array = array();
3564
        
3565
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
3566
		{
3567
			$temp_array['airline_name'] = $row['airline_name'];
3568
			$temp_array['airline_icao'] = $row['airline_icao'];
3569
			$temp_array['airline_count'] = $row['airline_count'];
3570
			$temp_array['airline_country'] = $row['airline_country'];
3571
3572
			$airline_array[] = $temp_array;
3573
		}
3574
		return $airline_array;
3575
	}
3576
3577
3578
	/**
3579
	* Gets all airline countries that have flown over by airport icao
3580
	*
3581
	* @return Array the airline country list
3582
	*
3583
	*/
3584
	public function countAllAirlineCountriesByAirport($airport_icao)
3585
	{
3586
		$airport_icao = filter_var($airport_icao,FILTER_SANITIZE_STRING);
3587
      
3588
		$query  = "SELECT DISTINCT spotter_output.airline_country, COUNT(spotter_output.airline_country) AS airline_country_count
3589
		 			FROM spotter_output
3590
					WHERE spotter_output.airline_country <> '' AND (spotter_output.departure_airport_icao = :airport_icao OR spotter_output.arrival_airport_icao = :airport_icao )
3591
					GROUP BY spotter_output.airline_country
3592
					ORDER BY airline_country_count DESC
3593
					LIMIT 10 OFFSET 0";
3594
3595
		
3596
		$sth = $this->db->prepare($query);
3597
		$sth->execute(array(':airport_icao' => $airport_icao));
3598
3599
		$airline_country_array = array();
3600
		$temp_array = array();
3601
        
3602
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
3603
		{
3604
			$temp_array['airline_country_count'] = $row['airline_country_count'];
3605
			$temp_array['airline_country'] = $row['airline_country'];
3606
 
3607
			$airline_country_array[] = $temp_array;
3608
		}
3609
		return $airline_country_array;
3610
	}
3611
3612
3613
	/**
3614
	* Gets all airlines that have flown over by aircraft manufacturer
3615
	*
3616
	* @return Array the airline list
3617
	*
3618
	*/
3619
	public function countAllAirlinesByManufacturer($aircraft_manufacturer)
3620
	{
3621
		$aircraft_manufacturer = filter_var($aircraft_manufacturer,FILTER_SANITIZE_STRING);
3622
3623
		$query  = "SELECT DISTINCT spotter_output.airline_name, spotter_output.airline_icao, spotter_output.airline_country, COUNT(spotter_output.airline_name) AS airline_count
3624
		 			FROM spotter_output
3625
					WHERE spotter_output.aircraft_manufacturer = :aircraft_manufacturer 
3626
					GROUP BY spotter_output.airline_name
3627
					ORDER BY airline_count DESC";
3628
 
3629
		$sth = $this->db->prepare($query);
3630
		$sth->execute(array(':aircraft_manufacturer' => $aircraft_manufacturer));
3631
 
3632
		$airline_array = array();
3633
		$temp_array = array();
3634
        
3635
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
3636
		{
3637
			$temp_array['airline_name'] = $row['airline_name'];
3638
			$temp_array['airline_icao'] = $row['airline_icao'];
3639
			$temp_array['airline_count'] = $row['airline_count'];
3640
			$temp_array['airline_country'] = $row['airline_country'];
3641
3642
			$airline_array[] = $temp_array;
3643
		}
3644
		return $airline_array;
3645
	}
3646
3647
3648
3649
	/**
3650
	* Gets all airline countries that have flown over by aircraft manufacturer
3651
	*
3652
	* @return Array the airline country list
3653
	*
3654
	*/
3655
	public function countAllAirlineCountriesByManufacturer($aircraft_manufacturer)
3656
	{
3657
		$aircraft_manufacturer = filter_var($aircraft_manufacturer,FILTER_SANITIZE_STRING);
3658
      
3659
		$query  = "SELECT DISTINCT spotter_output.airline_country, COUNT(spotter_output.airline_country) AS airline_country_count
3660
		 			FROM spotter_output
3661
					WHERE spotter_output.airline_country <> '' AND spotter_output.aircraft_manufacturer = :aircraft_manufacturer 
3662
					GROUP BY spotter_output.airline_country
3663
					ORDER BY airline_country_count DESC
3664
					LIMIT 10 OFFSET 0";
3665
      
3666
		
3667
		$sth = $this->db->prepare($query);
3668
		$sth->execute(array(':aircraft_manufacturer' => $aircraft_manufacturer));
3669
3670
		$airline_country_array = array();
3671
		$temp_array = array();
3672
        
3673
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
3674
		{
3675
			$temp_array['airline_country_count'] = $row['airline_country_count'];
3676
			$temp_array['airline_country'] = $row['airline_country'];
3677
			$airline_country_array[] = $temp_array;
3678
		}
3679
		return $airline_country_array;
3680
	}
3681
3682
3683
	/**
3684
	* Gets all airlines that have flown over by date
3685
	*
3686
	* @return Array the airline list
3687
	*
3688
	*/
3689
	public function countAllAirlinesByDate($date)
3690
	{
3691
		global $globalTimezone, $globalDBdriver;
3692
		$date = filter_var($date,FILTER_SANITIZE_STRING);
3693
3694
		if ($globalTimezone != '') {
3695
			date_default_timezone_set($globalTimezone);
3696
			$datetime = new DateTime($date);
3697
			$offset = $datetime->format('P');
3698
		} else $offset = '+00:00';
3699
3700
		if ($globalDBdriver == 'mysql') {
3701
			$query  = "SELECT DISTINCT spotter_output.airline_name, spotter_output.airline_icao, spotter_output.airline_country, COUNT(spotter_output.airline_name) AS airline_count
3702
		 			FROM spotter_output
3703
					WHERE DATE(CONVERT_TZ(spotter_output.date,'+00:00', :offset)) = :date 
3704
					GROUP BY spotter_output.airline_name
3705
					ORDER BY airline_count DESC";
3706
		} else {
3707
			$query  = "SELECT DISTINCT spotter_output.airline_name, spotter_output.airline_icao, spotter_output.airline_country, COUNT(spotter_output.airline_name) AS airline_count
3708
		 			FROM spotter_output
3709
					WHERE to_char(spotter_output.date AT TIME ZONE INTERVAL :offset,'YYYY-mm-dd') = :date 
3710
					GROUP BY spotter_output.airline_name
3711
					ORDER BY airline_count DESC";
3712
		}
3713
		
3714
		$sth = $this->db->prepare($query);
3715
		$sth->execute(array(':date' => $date, ':offset' => $offset));
3716
3717
		$airline_array = array();
3718
		$temp_array = array();
3719
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
3720
		{
3721
			$temp_array['airline_name'] = $row['airline_name'];
3722
			$temp_array['airline_icao'] = $row['airline_icao'];
3723
			$temp_array['airline_count'] = $row['airline_count'];
3724
			$temp_array['airline_country'] = $row['airline_country'];
3725
 
3726
			$airline_array[] = $temp_array;
3727
		}
3728
3729
		return $airline_array;
3730
	}	
3731
	
3732
	
3733
	/**
3734
	* Gets all airline countries that have flown over by date
3735
	*
3736
	* @return Array the airline country list
3737
	*
3738
	*/
3739
	public function countAllAirlineCountriesByDate($date)
3740
	{
3741
		global $globalTimezone, $globalDBdriver;
3742
		$date = filter_var($date,FILTER_SANITIZE_STRING);
3743
		if ($globalTimezone != '') {
3744
			date_default_timezone_set($globalTimezone);
3745
			$datetime = new DateTime($date);
3746
			$offset = $datetime->format('P');
3747
		} else $offset = '+00:00';
3748
		
3749
		if ($globalDBdriver == 'mysql') {
3750
			$query  = "SELECT DISTINCT spotter_output.airline_country, COUNT(spotter_output.airline_country) AS airline_country_count
3751
		 			FROM spotter_output
3752
					WHERE spotter_output.airline_country <> '' AND DATE(CONVERT_TZ(spotter_output.date,'+00:00', :offset)) = :date 
3753
					GROUP BY spotter_output.airline_country
3754
					ORDER BY airline_country_count DESC
3755
					LIMIT 10 OFFSET 0";
3756
		} else {
3757
			$query  = "SELECT DISTINCT spotter_output.airline_country, COUNT(spotter_output.airline_country) AS airline_country_count
3758
		 			FROM spotter_output
3759
					WHERE spotter_output.airline_country <> '' AND to_char(spotter_output.date AT TIME ZONE INTERVAL :offset,'YYYY-mm-dd') = :date 
3760
					GROUP BY spotter_output.airline_country
3761
					ORDER BY airline_country_count DESC
3762
					LIMIT 10 OFFSET 0";
3763
		}
3764
3765
		$sth = $this->db->prepare($query);
3766
		$sth->execute(array(':date' => $date, ':offset' => $offset));
3767
 
3768
		$airline_country_array = array();
3769
		$temp_array = array();
3770
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
3771
		{
3772
			$temp_array['airline_country_count'] = $row['airline_country_count'];
3773
			$temp_array['airline_country'] = $row['airline_country'];
3774
3775
			$airline_country_array[] = $temp_array;
3776
		}
3777
		return $airline_country_array;
3778
	}
3779
3780
3781
	/**
3782
	* Gets all airlines that have flown over by ident/callsign
3783
	*
3784
	* @return Array the airline list
3785
	*
3786
	*/
3787
	public function countAllAirlinesByIdent($ident)
3788
	{
3789
		$ident = filter_var($ident,FILTER_SANITIZE_STRING);
3790
3791
		$query  = "SELECT DISTINCT spotter_output.airline_name, spotter_output.airline_icao, spotter_output.airline_country, COUNT(spotter_output.airline_name) AS airline_count
3792
		 		FROM spotter_output
3793
				WHERE spotter_output.ident = :ident  
3794
				GROUP BY spotter_output.airline_name
3795
				ORDER BY airline_count DESC";
3796
      
3797
		
3798
		$sth = $this->db->prepare($query);
3799
		$sth->execute(array(':ident' => $ident));
3800
      
3801
		$airline_array = array();
3802
		$temp_array = array();
3803
        
3804
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
3805
		{
3806
			$temp_array['airline_name'] = $row['airline_name'];
3807
			$temp_array['airline_icao'] = $row['airline_icao'];
3808
			$temp_array['airline_count'] = $row['airline_count'];
3809
			$temp_array['airline_country'] = $row['airline_country'];
3810
3811
			$airline_array[] = $temp_array;
3812
		}
3813
		return $airline_array;
3814
	}
3815
3816
	/**
3817
	* Gets all airlines that have flown over by route
3818
	*
3819
	* @return Array the airline list
3820
	*
3821
	*/
3822
	public function countAllAirlinesByRoute($departure_airport_icao, $arrival_airport_icao)
3823
	{
3824
		$departure_airport_icao = filter_var($departure_airport_icao,FILTER_SANITIZE_STRING);
3825
		$arrival_airport_icao = filter_var($arrival_airport_icao,FILTER_SANITIZE_STRING);
3826
3827
		$query  = "SELECT DISTINCT spotter_output.airline_name, spotter_output.airline_icao, spotter_output.airline_country, COUNT(spotter_output.airline_name) AS airline_count
3828
		 			FROM spotter_output
3829
					WHERE (spotter_output.departure_airport_icao = :departure_airport_icao) AND (spotter_output.arrival_airport_icao = :arrival_airport_icao) 
3830
					GROUP BY spotter_output.airline_name
3831
					ORDER BY airline_count DESC";
3832
      
3833
		
3834
		$sth = $this->db->prepare($query);
3835
		$sth->execute(array(':departure_airport_icao' => $departure_airport_icao,':arrival_airport_icao' => $arrival_airport_icao));
3836
      
3837
		$airline_array = array();
3838
		$temp_array = array();
3839
        
3840
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
3841
		{
3842
			$temp_array['airline_name'] = $row['airline_name'];
3843
			$temp_array['airline_icao'] = $row['airline_icao'];
3844
			$temp_array['airline_count'] = $row['airline_count'];
3845
			$temp_array['airline_country'] = $row['airline_country'];
3846
3847
			$airline_array[] = $temp_array;
3848
		}
3849
		return $airline_array;
3850
	}
3851
3852
	/**
3853
	* Gets all airline countries that have flown over by route
3854
	*
3855
	* @return Array the airline country list
3856
	*
3857
	*/
3858
	public function countAllAirlineCountriesByRoute($departure_airport_icao, $arrival_airport_icao)
3859
	{
3860
		$departure_airport_icao = filter_var($departure_airport_icao,FILTER_SANITIZE_STRING);
3861
		$arrival_airport_icao = filter_var($arrival_airport_icao,FILTER_SANITIZE_STRING);
3862
      
3863
		$query  = "SELECT DISTINCT spotter_output.airline_country, COUNT(spotter_output.airline_country) AS airline_country_count
3864
		 		FROM spotter_output
3865
				WHERE spotter_output.airline_country <> '' AND (spotter_output.departure_airport_icao = :departure_airport_icao) AND (spotter_output.arrival_airport_icao = :arrival_airport_icao) 
3866
				GROUP BY spotter_output.airline_country
3867
				ORDER BY airline_country_count DESC
3868
				LIMIT 10 OFFSET 0";
3869
      
3870
		
3871
		$sth = $this->db->prepare($query);
3872
		$sth->execute(array(':departure_airport_icao' => $departure_airport_icao,':arrival_airport_icao' => $arrival_airport_icao));
3873
      
3874
		$airline_country_array = array();
3875
		$temp_array = array();
3876
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
3877
		{
3878
			$temp_array['airline_country_count'] = $row['airline_country_count'];
3879
			$temp_array['airline_country'] = $row['airline_country'];
3880
3881
			$airline_country_array[] = $temp_array;
3882
		}
3883
3884
		return $airline_country_array;
3885
	}
3886
3887
3888
	/**
3889
	* Gets all airlines that have flown over by country
3890
	*
3891
	* @return Array the airline list
3892
	*
3893
	*/
3894
	public function countAllAirlinesByCountry($country)
3895
	{
3896
		$country = filter_var($country,FILTER_SANITIZE_STRING);
3897
3898
		$query  = "SELECT DISTINCT spotter_output.airline_name, spotter_output.airline_icao, spotter_output.airline_country, COUNT(spotter_output.airline_name) AS airline_count
3899
		 		FROM spotter_output
3900
				WHERE ((spotter_output.departure_airport_country = :country) OR (spotter_output.arrival_airport_country = :country)) OR spotter_output.airline_country = :country  
3901
				GROUP BY spotter_output.airline_name
3902
				ORDER BY airline_count DESC";
3903
      
3904
		
3905
		$sth = $this->db->prepare($query);
3906
		$sth->execute(array(':country' => $country));
3907
3908
		$airline_array = array();
3909
		$temp_array = array();
3910
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
3911
		{
3912
			$temp_array['airline_name'] = $row['airline_name'];
3913
			$temp_array['airline_icao'] = $row['airline_icao'];
3914
			$temp_array['airline_count'] = $row['airline_count'];
3915
			$temp_array['airline_country'] = $row['airline_country'];
3916
 
3917
			$airline_array[] = $temp_array;
3918
		}
3919
		return $airline_array;
3920
	}
3921
3922
3923
	/**
3924
	* Gets all airline countries that have flown over by country
3925
	*
3926
	* @return Array the airline country list
3927
	*
3928
	*/
3929
	public function countAllAirlineCountriesByCountry($country)
3930
	{
3931
		$country = filter_var($country,FILTER_SANITIZE_STRING);
3932
      
3933
		$query  = "SELECT DISTINCT spotter_output.airline_country, COUNT(spotter_output.airline_country) AS airline_country_count
3934
		 		FROM spotter_output
3935
				WHERE spotter_output.airline_country <> '' AND ((spotter_output.departure_airport_country = :country) OR (spotter_output.arrival_airport_country = :country)) OR spotter_output.airline_country = :country 
3936
				GROUP BY spotter_output.airline_country
3937
				ORDER BY airline_country_count DESC
3938
				LIMIT 10 OFFSET 0";
3939
      
3940
		
3941
		$sth = $this->db->prepare($query);
3942
		$sth->execute(array(':country' => $country));
3943
3944
		$airline_country_array = array();
3945
		$temp_array = array();
3946
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
3947
		{
3948
			$temp_array['airline_country_count'] = $row['airline_country_count'];
3949
			$temp_array['airline_country'] = $row['airline_country'];
3950
3951
			$airline_country_array[] = $temp_array;
3952
		}
3953
		return $airline_country_array;
3954
	}
3955
3956
3957
	/**
3958
	* Gets all airlines countries
3959
	*
3960
	* @return Array the airline country list
3961
	*
3962
	*/
3963
	public function countAllAirlineCountries($limit = true)
3964
	{
3965
		$query  = "SELECT DISTINCT spotter_output.airline_country, COUNT(spotter_output.airline_country) AS airline_country_count
3966
		 			FROM spotter_output
3967
					WHERE spotter_output.airline_country <> '' AND spotter_output.airline_country <> 'NA' 
3968
					GROUP BY spotter_output.airline_country
3969
					ORDER BY airline_country_count DESC";
3970
		if ($limit) $query .= " LIMIT 10 OFFSET 0";
3971
      
3972
		$sth = $this->db->prepare($query);
3973
		$sth->execute();
3974
3975
		$airline_array = array();
3976
		$temp_array = array();
3977
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
3978
		{
3979
			$temp_array['airline_country_count'] = $row['airline_country_count'];
3980
			$temp_array['airline_country'] = $row['airline_country'];
3981
3982
			$airline_array[] = $temp_array;
3983
		}
3984
		return $airline_array;
3985
	}
3986
3987
	/**
3988
	* Gets all number of flight over countries
3989
	*
3990
	* @return Array the airline country list
3991
	*
3992
	*/
3993
	public function countAllFlightOverCountries($limit = true,$olderthanmonths = 0,$sincedate = '')
3994
	{
3995
		global $globalDBdriver;
3996
		/*
3997
		$query = "SELECT c.name, c.iso3, c.iso2, count(c.name) as nb 
3998
					FROM countries c, spotter_output s
3999
					WHERE Within(GeomFromText(CONCAT('POINT(',s.longitude,' ',s.latitude,')')), ogc_geom) ";
4000
		*/
4001
		$query = "SELECT c.name, c.iso3, c.iso2, count(c.name) as nb 
4002
					FROM countries c, spotter_live s
4003
					WHERE c.iso2 = s.over_country ";
4004
                if ($olderthanmonths > 0) {
4005
			if ($globalDBdriver == 'mysql') {
4006
				$query .= 'AND spotter_output.date < DATE_SUB(UTC_TIMESTAMP(),INTERVAL '.$olderthanmonths.' MONTH) ';
4007
			} else {
4008
				$query .= "AND spotter_output.date < CURRENT_TIMESTAMP AT TIME ZONE 'UTC' - INTERVAL '".$olderthanmonths." MONTHS'";
4009
			}
4010
		}
4011
                if ($sincedate != '') {
4012
            		if ($globalDBdriver == 'mysql') {
4013
				$query .= "AND spotter_output.date > '".$sincedate."' ";
4014
			} else {
4015
				$query .= "AND spotter_output.date > CAST('".$sincedate."' AS TIMESTAMP)";
4016
			}
4017
		}
4018
4019
		$query .= "GROUP BY c.name ORDER BY nb DESC";
4020
		if ($limit) $query .= " LIMIT 10 OFFSET 0";
4021
      
4022
		
4023
		$sth = $this->db->prepare($query);
4024
		$sth->execute();
4025
 
4026
		$flight_array = array();
4027
		$temp_array = array();
4028
        
4029
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
4030
		{
4031
			$temp_array['flight_count'] = $row['nb'];
4032
			$temp_array['flight_country'] = $row['name'];
4033
			$temp_array['flight_country_iso3'] = $row['iso3'];
4034
			$temp_array['flight_country_iso2'] = $row['iso2'];
4035
			$flight_array[] = $temp_array;
4036
		}
4037
		return $flight_array;
4038
	}
4039
	
4040
	
4041
	/**
4042
	* Gets all aircraft types that have flown over
4043
	*
4044
	* @return Array the aircraft list
4045
	*
4046
	*/
4047
	public function countAllAircraftTypes($limit = true,$olderthanmonths = 0,$sincedate = '')
4048
	{
4049
		global $globalDBdriver;
4050
		$query  = "SELECT spotter_output.aircraft_icao, COUNT(spotter_output.aircraft_icao) AS aircraft_icao_count, spotter_output.aircraft_name, spotter_output.aircraft_manufacturer 
4051
                    FROM spotter_output
4052
                    WHERE spotter_output.aircraft_name  <> '' AND spotter_output.aircraft_icao  <> '' ";
4053
                if ($olderthanmonths > 0) {
4054
            		if ($globalDBdriver == 'mysql') {
4055
				$query .= 'AND spotter_output.date < DATE_SUB(UTC_TIMESTAMP(), INTERVAL '.$olderthanmonths.' MONTH) ';
4056
			} else {
4057
				$query .= "AND spotter_output.date < CURRENT_TIMESTAMP AT TIME ZONE 'UTC' - INTERVAL '".$olderthanmonths." MONTHS' ";
4058
			}
4059
                }
4060
                if ($sincedate != '') {
4061
            		if ($globalDBdriver == 'mysql') {
4062
				$query .= "AND spotter_output.date > '".$sincedate."' ";
4063
			} else {
4064
				$query .= "AND spotter_output.date > CAST('".$sincedate."' AS TIMESTAMP)";
4065
			}
4066
		}
4067
4068
                //if ($olderthanmonths > 0) $query .= 'AND date < DATE_SUB(UTC_TIMESTAMP(),INTERVAL '.$olderthanmonths.' MONTH) ';
4069
                //if ($sincedate != '') $query .= "AND date > '".$sincedate."' ";
4070
                $query .= "GROUP BY spotter_output.aircraft_icao, spotter_output.aircraft_name, spotter_output.aircraft_manufacturer ORDER BY aircraft_icao_count DESC";
4071
		if ($limit) $query .= " LIMIT 10 OFFSET 0";
4072
      
4073
		
4074
		$sth = $this->db->prepare($query);
4075
		$sth->execute();
4076
4077
		$aircraft_array = array();
4078
		$temp_array = array();
4079
        
4080
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
4081
		{
4082
			$temp_array['aircraft_icao'] = $row['aircraft_icao'];
4083
			$temp_array['aircraft_name'] = $row['aircraft_name'];
4084
			$temp_array['aircraft_manufacturer'] = $row['aircraft_manufacturer'];
4085
			$temp_array['aircraft_icao_count'] = $row['aircraft_icao_count'];
4086
4087
			$aircraft_array[] = $temp_array;
4088
		}
4089
		return $aircraft_array;
4090
	}
4091
4092
4093
	/**
4094
	* Gets all aircraft registration that have flown over by aircaft icao
4095
	*
4096
	* @return Array the aircraft list
4097
	*
4098
	*/
4099
	public function countAllAircraftRegistrationByAircraft($aircraft_icao)
4100
	{
4101
		$Image = new Image($this->db);
4102
		$aircraft_icao = filter_var($aircraft_icao,FILTER_SANITIZE_STRING);
4103
4104
		$query  = "SELECT DISTINCT spotter_output.aircraft_icao, COUNT(spotter_output.registration) AS registration_count, spotter_output.aircraft_name, spotter_output.registration, spotter_output.airline_name  
4105
				FROM spotter_output
4106
				WHERE spotter_output.registration <> '' AND spotter_output.aircraft_icao = :aircraft_icao  
4107
				GROUP BY spotter_output.registration 
4108
				ORDER BY registration_count DESC";
4109
4110
		$sth = $this->db->prepare($query);
4111
		$sth->execute(array(':aircraft_icao' => $aircraft_icao));
4112
4113
		$aircraft_array = array();
4114
		$temp_array = array();
4115
        
4116
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
4117
		{
4118
			$temp_array['aircraft_icao'] = $row['aircraft_icao'];
4119
			$temp_array['aircraft_name'] = $row['aircraft_name'];
4120
			$temp_array['registration'] = $row['registration'];
4121
			$temp_array['airline_name'] = $row['airline_name'];
4122
			$temp_array['image_thumbnail'] = "";
4123
			if($row['registration'] != "")
4124
			{
4125
				$image_array = $Image->getSpotterImage($row['registration']);
4126
				if (isset($image_array[0]['image_thumbnail'])) $temp_array['image_thumbnail'] = $image_array[0]['image_thumbnail'];
4127
			}
4128
			$temp_array['registration_count'] = $row['registration_count'];
4129
4130
			$aircraft_array[] = $temp_array;
4131
		}
4132
		return $aircraft_array;
4133
	}
4134
4135
4136
	/**
4137
	* Gets all aircraft types that have flown over by airline icao
4138
	*
4139
	* @return Array the aircraft list
4140
	*
4141
	*/
4142
	public function countAllAircraftTypesByAirline($airline_icao)
4143
	{
4144
		$airline_icao = filter_var($airline_icao,FILTER_SANITIZE_STRING);
4145
4146
		$query  = "SELECT DISTINCT spotter_output.aircraft_icao, COUNT(spotter_output.aircraft_icao) AS aircraft_icao_count, spotter_output.aircraft_name  
4147
				FROM spotter_output
4148
				WHERE spotter_output.aircraft_icao <> '' AND spotter_output.airline_icao = :airline_icao 
4149
				GROUP BY spotter_output.aircraft_name 
4150
				ORDER BY aircraft_icao_count DESC";
4151
4152
		$sth = $this->db->prepare($query);
4153
		$sth->execute(array(':airline_icao' => $airline_icao));
4154
4155
		$aircraft_array = array();
4156
		$temp_array = array();
4157
4158
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
4159
		{
4160
			$temp_array['aircraft_icao'] = $row['aircraft_icao'];
4161
			$temp_array['aircraft_name'] = $row['aircraft_name'];
4162
			$temp_array['aircraft_icao_count'] = $row['aircraft_icao_count'];
4163
4164
			$aircraft_array[] = $temp_array;
4165
		}
4166
		return $aircraft_array;
4167
	}
4168
4169
4170
	/**
4171
	* Gets all aircraft registration that have flown over by airline icao
4172
	*
4173
	* @return Array the aircraft list
4174
	*
4175
	*/
4176
	public function countAllAircraftRegistrationByAirline($airline_icao)
4177
	{
4178
		$Image = new Image($this->db);
4179
		$airline_icao = filter_var($airline_icao,FILTER_SANITIZE_STRING);
4180
4181
		$query  = "SELECT DISTINCT spotter_output.aircraft_icao, COUNT(spotter_output.registration) AS registration_count, spotter_output.aircraft_name, spotter_output.registration, spotter_output.airline_name   
4182
				FROM spotter_output
4183
				WHERE spotter_output.registration <> '' AND spotter_output.airline_icao = :airline_icao 
4184
				GROUP BY spotter_output.registration 
4185
				ORDER BY registration_count DESC";
4186
4187
		$sth = $this->db->prepare($query);
4188
		$sth->execute(array(':airline_icao' => $airline_icao));
4189
4190
		$aircraft_array = array();
4191
		$temp_array = array();
4192
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
4193
		{
4194
			$temp_array['aircraft_icao'] = $row['aircraft_icao'];
4195
			$temp_array['aircraft_name'] = $row['aircraft_name'];
4196
			$temp_array['registration'] = $row['registration'];
4197
			$temp_array['airline_name'] = $row['airline_name'];
4198
			$temp_array['image_thumbnail'] = "";
4199
			if($row['registration'] != "")
4200
			{
4201
				$image_array = $Image->getSpotterImage($row['registration']);
4202
				if (isset($image_array[0]['image_thumbnail'])) $temp_array['image_thumbnail'] = $image_array[0]['image_thumbnail'];
4203
			}
4204
			$temp_array['registration_count'] = $row['registration_count'];
4205
4206
			$aircraft_array[] = $temp_array;
4207
		}
4208
		return $aircraft_array;
4209
	}
4210
4211
4212
	/**
4213
	* Gets all aircraft manufacturer that have flown over by airline icao
4214
	*
4215
	* @return Array the aircraft list
4216
	*
4217
	*/
4218
	public function countAllAircraftManufacturerByAirline($airline_icao)
4219
	{
4220
		$airline_icao = filter_var($airline_icao,FILTER_SANITIZE_STRING);
4221
4222
		$query  = "SELECT DISTINCT spotter_output.aircraft_manufacturer, COUNT(spotter_output.aircraft_manufacturer) AS aircraft_manufacturer_count  
4223
				FROM spotter_output
4224
				WHERE spotter_output.aircraft_manufacturer <> '' AND spotter_output.airline_icao = :airline_icao 
4225
				GROUP BY spotter_output.aircraft_manufacturer 
4226
				ORDER BY aircraft_manufacturer_count DESC";
4227
4228
		$sth = $this->db->prepare($query);
4229
		$sth->execute(array(':airline_icao' => $airline_icao));
4230
4231
		$aircraft_array = array();
4232
		$temp_array = array();
4233
4234
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
4235
		{
4236
			$temp_array['aircraft_manufacturer'] = $row['aircraft_manufacturer'];
4237
			$temp_array['aircraft_manufacturer_count'] = $row['aircraft_manufacturer_count'];
4238
4239
			$aircraft_array[] = $temp_array;
4240
		}
4241
		return $aircraft_array;
4242
	}
4243
4244
4245
	/**
4246
	* Gets all aircraft types that have flown over by airline icao
4247
	*
4248
	* @return Array the aircraft list
4249
	*
4250
	*/
4251
	public function countAllAircraftTypesByAirport($airport_icao)
4252
	{
4253
		$airport_icao = filter_var($airport_icao,FILTER_SANITIZE_STRING);
4254
4255
		$query  = "SELECT DISTINCT spotter_output.aircraft_icao, COUNT(spotter_output.aircraft_icao) AS aircraft_icao_count, spotter_output.aircraft_name  
4256
				FROM spotter_output
4257
				WHERE spotter_output.aircraft_icao <> '' AND (spotter_output.departure_airport_icao = :airport_icao OR spotter_output.arrival_airport_icao = :airport_icao) 
4258
				GROUP BY spotter_output.aircraft_name 
4259
				ORDER BY aircraft_icao_count DESC";
4260
 
4261
		$sth = $this->db->prepare($query);
4262
		$sth->execute(array(':airport_icao' => $airport_icao));
4263
4264
		$aircraft_array = array();
4265
		$temp_array = array();
4266
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
4267
		{
4268
			$temp_array['aircraft_icao'] = $row['aircraft_icao'];
4269
			$temp_array['aircraft_name'] = $row['aircraft_name'];
4270
			$temp_array['aircraft_icao_count'] = $row['aircraft_icao_count'];
4271
4272
			$aircraft_array[] = $temp_array;
4273
		}
4274
		return $aircraft_array;
4275
	}
4276
4277
4278
	/**
4279
	* Gets all aircraft registration that have flown over by airport icao
4280
	*
4281
	* @return Array the aircraft list
4282
	*
4283
	*/
4284
	public function countAllAircraftRegistrationByAirport($airport_icao)
4285
	{
4286
		$Image = new Image($this->db);
4287
		$airport_icao = filter_var($airport_icao,FILTER_SANITIZE_STRING);
4288
4289
		$query  = "SELECT DISTINCT spotter_output.aircraft_icao, COUNT(spotter_output.registration) AS registration_count, spotter_output.aircraft_name, spotter_output.registration, spotter_output.airline_name  
4290
                    FROM spotter_output
4291
                    WHERE spotter_output.registration <> '' AND (spotter_output.departure_airport_icao = :airport_icao OR spotter_output.arrival_airport_icao = :airport_icao)   
4292
                    GROUP BY spotter_output.registration 
4293
					ORDER BY registration_count DESC";
4294
4295
		
4296
		$sth = $this->db->prepare($query);
4297
		$sth->execute(array(':airport_icao' => $airport_icao));
4298
4299
		$aircraft_array = array();
4300
		$temp_array = array();
4301
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
4302
		{
4303
			$temp_array['aircraft_icao'] = $row['aircraft_icao'];
4304
			$temp_array['aircraft_name'] = $row['aircraft_name'];
4305
			$temp_array['registration'] = $row['registration'];
4306
			$temp_array['airline_name'] = $row['airline_name'];
4307
			$temp_array['image_thumbnail'] = "";
4308
			if($row['registration'] != "")
4309
			{
4310
				$image_array = $Image->getSpotterImage($row['registration']);
4311
				$temp_array['image_thumbnail'] = $image_array[0]['image_thumbnail'];
4312
			}
4313
			$temp_array['registration_count'] = $row['registration_count'];
4314
			$aircraft_array[] = $temp_array;
4315
		}
4316
		return $aircraft_array;
4317
	}
4318
	
4319
	
4320
	/**
4321
	* Gets all aircraft manufacturer that have flown over by airport icao
4322
	*
4323
	* @return Array the aircraft list
4324
	*
4325
	*/
4326
	public function countAllAircraftManufacturerByAirport($airport_icao)
4327
	{
4328
		$airport_icao = filter_var($airport_icao,FILTER_SANITIZE_STRING);
4329
4330
		$query  = "SELECT DISTINCT spotter_output.aircraft_manufacturer, COUNT(spotter_output.aircraft_manufacturer) AS aircraft_manufacturer_count  
4331
                    FROM spotter_output
4332
                    WHERE spotter_output.aircraft_manufacturer <> '' AND (spotter_output.departure_airport_icao = :airport_icao OR spotter_output.arrival_airport_icao = :airport_icao)  
4333
                    GROUP BY spotter_output.aircraft_manufacturer 
4334
					ORDER BY aircraft_manufacturer_count DESC";
4335
4336
		
4337
		$sth = $this->db->prepare($query);
4338
		$sth->execute(array(':airport_icao' => $airport_icao));
4339
4340
		$aircraft_array = array();
4341
		$temp_array = array();
4342
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
4343
		{
4344
			$temp_array['aircraft_manufacturer'] = $row['aircraft_manufacturer'];
4345
			$temp_array['aircraft_manufacturer_count'] = $row['aircraft_manufacturer_count'];
4346
			$aircraft_array[] = $temp_array;
4347
		}
4348
		return $aircraft_array;
4349
	}
4350
4351
	/**
4352
	* Gets all aircraft types that have flown over by aircraft manufacturer
4353
	*
4354
	* @return Array the aircraft list
4355
	*
4356
	*/
4357
	public function countAllAircraftTypesByManufacturer($aircraft_manufacturer)
4358
	{
4359
		$aircraft_manufacturer = filter_var($aircraft_manufacturer,FILTER_SANITIZE_STRING);
4360
4361
		$query  = "SELECT DISTINCT spotter_output.aircraft_icao, COUNT(spotter_output.aircraft_icao) AS aircraft_icao_count, spotter_output.aircraft_name  
4362
                    FROM spotter_output
4363
                    WHERE spotter_output.aircraft_manufacturer = :aircraft_manufacturer
4364
                    GROUP BY spotter_output.aircraft_name 
4365
					ORDER BY aircraft_icao_count DESC";
4366
4367
		$sth = $this->db->prepare($query);
4368
		$sth->execute(array(':aircraft_manufacturer' => $aircraft_manufacturer));
4369
		$aircraft_array = array();
4370
		$temp_array = array();
4371
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
4372
		{
4373
			$temp_array['aircraft_icao'] = $row['aircraft_icao'];
4374
			$temp_array['aircraft_name'] = $row['aircraft_name'];
4375
			$temp_array['aircraft_icao_count'] = $row['aircraft_icao_count'];
4376
			$aircraft_array[] = $temp_array;
4377
		}
4378
		return $aircraft_array;
4379
	}
4380
4381
4382
	/**
4383
	* Gets all aircraft registration that have flown over by aircaft manufacturer
4384
	*
4385
	* @return Array the aircraft list
4386
	*
4387
	*/
4388
	public function countAllAircraftRegistrationByManufacturer($aircraft_manufacturer)
4389
	{
4390
		$Image = new Image($this->db);
4391
		$aircraft_manufacturer = filter_var($aircraft_manufacturer,FILTER_SANITIZE_STRING);
4392
4393
		$query  = "SELECT DISTINCT spotter_output.aircraft_icao, COUNT(spotter_output.registration) AS registration_count, spotter_output.aircraft_name, spotter_output.registration, spotter_output.airline_name   
4394
                    FROM spotter_output
4395
                    WHERE spotter_output.registration <> '' AND spotter_output.aircraft_manufacturer = :aircraft_manufacturer   
4396
                    GROUP BY spotter_output.registration 
4397
					ORDER BY registration_count DESC";
4398
4399
		
4400
		$sth = $this->db->prepare($query);
4401
		$sth->execute(array(':aircraft_manufacturer' => $aircraft_manufacturer));
4402
		$aircraft_array = array();
4403
		$temp_array = array();
4404
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
4405
		{
4406
			$temp_array['aircraft_icao'] = $row['aircraft_icao'];
4407
			$temp_array['aircraft_name'] = $row['aircraft_name'];
4408
			$temp_array['registration'] = $row['registration'];
4409
			$temp_array['airline_name'] = $row['airline_name'];
4410
			$temp_array['image_thumbnail'] = "";
4411
			if($row['registration'] != "")
4412
			{
4413
				$image_array = $Image->getSpotterImage($row['registration']);
4414
				$temp_array['image_thumbnail'] = $image_array[0]['image_thumbnail'];
4415
			}
4416
			$temp_array['registration_count'] = $row['registration_count'];
4417
			$aircraft_array[] = $temp_array;
4418
		}
4419
		return $aircraft_array;
4420
	}
4421
4422
	/**
4423
	* Gets all aircraft types that have flown over by date
4424
	*
4425
	* @return Array the aircraft list
4426
	*
4427
	*/
4428
	public function countAllAircraftTypesByDate($date)
4429
	{
4430
		global $globalTimezone, $globalDBdriver;
4431
		$date = filter_var($date,FILTER_SANITIZE_STRING);
4432
		if ($globalTimezone != '') {
4433
			date_default_timezone_set($globalTimezone);
4434
			$datetime = new DateTime($date);
4435
			$offset = $datetime->format('P');
4436
		} else $offset = '+00:00';
4437
4438
		if ($globalDBdriver == 'mysql') {
4439
			$query  = "SELECT DISTINCT spotter_output.aircraft_icao, COUNT(spotter_output.aircraft_icao) AS aircraft_icao_count, spotter_output.aircraft_name  
4440
					FROM spotter_output
4441
					WHERE DATE(CONVERT_TZ(spotter_output.date,'+00:00', :offset)) = :date
4442
					GROUP BY spotter_output.aircraft_name 
4443
					ORDER BY aircraft_icao_count DESC";
4444
		} else {
4445
			$query  = "SELECT DISTINCT spotter_output.aircraft_icao, COUNT(spotter_output.aircraft_icao) AS aircraft_icao_count, spotter_output.aircraft_name  
4446
					FROM spotter_output
4447
					WHERE to_char(spotter_output.date AT TIME ZONE INTERVAL :offset,'YYYY-mm-dd') = :date
4448
					GROUP BY spotter_output.aircraft_name 
4449
					ORDER BY aircraft_icao_count DESC";
4450
		}
4451
		
4452
		$sth = $this->db->prepare($query);
4453
		$sth->execute(array(':date' => $date, ':offset' => $offset));
4454
4455
		$aircraft_array = array();
4456
		$temp_array = array();
4457
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
4458
		{
4459
			$temp_array['aircraft_icao'] = $row['aircraft_icao'];
4460
			$temp_array['aircraft_name'] = $row['aircraft_name'];
4461
			$temp_array['aircraft_icao_count'] = $row['aircraft_icao_count'];
4462
4463
			$aircraft_array[] = $temp_array;
4464
		}
4465
		return $aircraft_array;
4466
	}
4467
4468
4469
	/**
4470
	* Gets all aircraft registration that have flown over by date
4471
	*
4472
	* @return Array the aircraft list
4473
	*
4474
	*/
4475
	public function countAllAircraftRegistrationByDate($date)
4476
	{
4477
		global $globalTimezone, $globalDBdriver;
4478
		$Image = new Image($this->db);
4479
		$date = filter_var($date,FILTER_SANITIZE_STRING);
4480
		if ($globalTimezone != '') {
4481
			date_default_timezone_set($globalTimezone);
4482
			$datetime = new DateTime($date);
4483
			$offset = $datetime->format('P');
4484
		} else $offset = '+00:00';
4485
4486
		if ($globalDBdriver == 'mysql') {
4487
			$query  = "SELECT DISTINCT spotter_output.aircraft_icao, COUNT(spotter_output.registration) AS registration_count, spotter_output.aircraft_name, spotter_output.registration, spotter_output.airline_name    
4488
					FROM spotter_output
4489
					WHERE spotter_output.registration <> '' AND DATE(CONVERT_TZ(spotter_output.date,'+00:00', :offset)) = :date 
4490
					GROUP BY spotter_output.registration 
4491
					ORDER BY registration_count DESC";
4492
		} else {
4493
			$query  = "SELECT DISTINCT spotter_output.aircraft_icao, COUNT(spotter_output.registration) AS registration_count, spotter_output.aircraft_name, spotter_output.registration, spotter_output.airline_name    
4494
					FROM spotter_output
4495
					WHERE spotter_output.registration <> '' AND to_char(spotter_output.date AT TIME ZONE INTERVAL :offset,'YYYY-mm-dd') = :date 
4496
					GROUP BY spotter_output.registration 
4497
					ORDER BY registration_count DESC";
4498
		}
4499
		
4500
		$sth = $this->db->prepare($query);
4501
		$sth->execute(array(':date' => $date, ':offset' => $offset));
4502
4503
		$aircraft_array = array();
4504
		$temp_array = array();
4505
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
4506
		{
4507
			$temp_array['aircraft_icao'] = $row['aircraft_icao'];
4508
			$temp_array['aircraft_name'] = $row['aircraft_name'];
4509
			$temp_array['registration'] = $row['registration'];
4510
			$temp_array['airline_name'] = $row['airline_name'];
4511
			$temp_array['image_thumbnail'] = "";
4512
			if($row['registration'] != "")
4513
			{
4514
				$image_array = $Image->getSpotterImage($row['registration']);
4515
				$temp_array['image_thumbnail'] = $image_array[0]['image_thumbnail'];
4516
			}
4517
			$temp_array['registration_count'] = $row['registration_count'];
4518
 
4519
			$aircraft_array[] = $temp_array;
4520
		}
4521
		return $aircraft_array;
4522
	}
4523
4524
4525
	/**
4526
	* Gets all aircraft manufacturer that have flown over by date
4527
	*
4528
	* @return Array the aircraft manufacturer list
4529
	*
4530
	*/
4531
	public function countAllAircraftManufacturerByDate($date)
4532
	{
4533
		global $globalTimezone, $globalDBdriver;
4534
		$date = filter_var($date,FILTER_SANITIZE_STRING);
4535
		if ($globalTimezone != '') {
4536
			date_default_timezone_set($globalTimezone);
4537
			$datetime = new DateTime($date);
4538
			$offset = $datetime->format('P');
4539
		} else $offset = '+00:00';
4540
4541
		if ($globalDBdriver == 'mysql') {
4542
			$query  = "SELECT DISTINCT spotter_output.aircraft_manufacturer, COUNT(spotter_output.aircraft_manufacturer) AS aircraft_manufacturer_count  
4543
				FROM spotter_output
4544
				WHERE spotter_output.aircraft_manufacturer <> '' AND DATE(CONVERT_TZ(spotter_output.date,'+00:00', :offset)) = :date 
4545
				GROUP BY spotter_output.aircraft_manufacturer 
4546
				ORDER BY aircraft_manufacturer_count DESC";
4547
		} else {
4548
			$query  = "SELECT DISTINCT spotter_output.aircraft_manufacturer, COUNT(spotter_output.aircraft_manufacturer) AS aircraft_manufacturer_count  
4549
				FROM spotter_output
4550
				WHERE spotter_output.aircraft_manufacturer <> '' AND to_char(spotter_output.date AT TIME ZONE INTERVAL :offset,'YYYY-mm-dd') = :date 
4551
				GROUP BY spotter_output.aircraft_manufacturer 
4552
				ORDER BY aircraft_manufacturer_count DESC";
4553
		}
4554
		
4555
		$sth = $this->db->prepare($query);
4556
		$sth->execute(array(':date' => $date, ':offset' => $offset));
4557
4558
		$aircraft_array = array();
4559
		$temp_array = array();
4560
4561
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
4562
		{
4563
			$temp_array['aircraft_manufacturer'] = $row['aircraft_manufacturer'];
4564
			$temp_array['aircraft_manufacturer_count'] = $row['aircraft_manufacturer_count'];
4565
4566
			$aircraft_array[] = $temp_array;
4567
		}
4568
		return $aircraft_array;
4569
	}
4570
4571
4572
	/**
4573
	* Gets all aircraft types that have flown over by ident/callsign
4574
	*
4575
	* @return Array the aircraft list
4576
	*
4577
	*/
4578
	public function countAllAircraftTypesByIdent($ident)
4579
	{
4580
		$ident = filter_var($ident,FILTER_SANITIZE_STRING);
4581
4582
		$query  = "SELECT DISTINCT spotter_output.aircraft_icao, COUNT(spotter_output.aircraft_icao) AS aircraft_icao_count, spotter_output.aircraft_name  
4583
				FROM spotter_output
4584
				WHERE spotter_output.ident = :ident 
4585
				GROUP BY spotter_output.aircraft_name, spotter_output.aircraft_icao
4586
				ORDER BY aircraft_icao_count DESC";
4587
4588
		$sth = $this->db->prepare($query);
4589
		$sth->execute(array(':ident' => $ident));
4590
      
4591
		$aircraft_array = array();
4592
		$temp_array = array();
4593
4594
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
4595
		{
4596
			$temp_array['aircraft_icao'] = $row['aircraft_icao'];
4597
			$temp_array['aircraft_name'] = $row['aircraft_name'];
4598
			$temp_array['aircraft_icao_count'] = $row['aircraft_icao_count'];
4599
4600
			$aircraft_array[] = $temp_array;
4601
		}
4602
		return $aircraft_array;
4603
	}
4604
4605
4606
	/**
4607
	* Gets all aircraft registration that have flown over by ident/callsign
4608
	*
4609
	* @return Array the aircraft list
4610
	*
4611
	*/
4612
	public function countAllAircraftRegistrationByIdent($ident)
4613
	{
4614
		$Image = new Image($this->db);
4615
		$ident = filter_var($ident,FILTER_SANITIZE_STRING);
4616
4617
		$query  = "SELECT DISTINCT spotter_output.aircraft_icao, COUNT(spotter_output.registration) AS registration_count, spotter_output.aircraft_name, spotter_output.registration, spotter_output.airline_name  
4618
                    FROM spotter_output
4619
                    WHERE spotter_output.registration <> '' AND spotter_output.ident = :ident   
4620
                    GROUP BY spotter_output.registration,spotter_output.aircraft_icao, spotter_output.aircraft_name, spotter_output.airline_name
4621
		    ORDER BY registration_count DESC";
4622
4623
		
4624
		$sth = $this->db->prepare($query);
4625
		$sth->execute(array(':ident' => $ident));
4626
      
4627
		$aircraft_array = array();
4628
		$temp_array = array();
4629
        
4630
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
4631
		{
4632
			$temp_array['aircraft_icao'] = $row['aircraft_icao'];
4633
			$temp_array['aircraft_name'] = $row['aircraft_name'];
4634
			$temp_array['registration'] = $row['registration'];
4635
			$temp_array['airline_name'] = $row['airline_name'];
4636
			$temp_array['image_thumbnail'] = "";
4637
			if($row['registration'] != "")
4638
			{
4639
				$image_array = $Image->getSpotterImage($row['registration']);
4640
				if (isset($image_array[0]['image_thumbnail'])) $temp_array['image_thumbnail'] = $image_array[0]['image_thumbnail'];
4641
				else $temp_array['image_thumbnail'] = '';
4642
			}
4643
			$temp_array['registration_count'] = $row['registration_count'];
4644
			$aircraft_array[] = $temp_array;
4645
		}
4646
		return $aircraft_array;
4647
	}
4648
4649
4650
	/**
4651
	* Gets all aircraft manufacturer that have flown over by ident/callsign
4652
	*
4653
	* @return Array the aircraft manufacturer list
4654
	*
4655
	*/
4656
	public function countAllAircraftManufacturerByIdent($ident)
4657
	{
4658
		$ident = filter_var($ident,FILTER_SANITIZE_STRING);
4659
4660
		$query  = "SELECT DISTINCT spotter_output.aircraft_manufacturer, COUNT(spotter_output.aircraft_manufacturer) AS aircraft_manufacturer_count  
4661
                    FROM spotter_output
4662
                    WHERE spotter_output.aircraft_manufacturer <> '' AND spotter_output.ident = :ident  
4663
                    GROUP BY spotter_output.aircraft_manufacturer 
4664
					ORDER BY aircraft_manufacturer_count DESC";
4665
4666
		
4667
		$sth = $this->db->prepare($query);
4668
		$sth->execute(array(':ident' => $ident));
4669
		$aircraft_array = array();
4670
		$temp_array = array();
4671
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
4672
		{
4673
			$temp_array['aircraft_manufacturer'] = $row['aircraft_manufacturer'];
4674
			$temp_array['aircraft_manufacturer_count'] = $row['aircraft_manufacturer_count'];
4675
			$aircraft_array[] = $temp_array;
4676
		}
4677
		return $aircraft_array;
4678
	}
4679
4680
4681
	/**
4682
	* Gets all aircraft types that have flown over by route
4683
	*
4684
	* @return Array the aircraft list
4685
	*
4686
	*/
4687
	public function countAllAircraftTypesByRoute($departure_airport_icao, $arrival_airport_icao)
4688
	{
4689
		$departure_airport_icao = filter_var($departure_airport_icao,FILTER_SANITIZE_STRING);
4690
		$arrival_airport_icao = filter_var($arrival_airport_icao,FILTER_SANITIZE_STRING);
4691
		
4692
4693
		$query  = "SELECT DISTINCT spotter_output.aircraft_icao, COUNT(spotter_output.aircraft_icao) AS aircraft_icao_count, spotter_output.aircraft_name  
4694
                    FROM spotter_output
4695
                    WHERE (spotter_output.departure_airport_icao = :departure_airport_icao) AND (spotter_output.arrival_airport_icao = :arrival_airport_icao)
4696
                    GROUP BY spotter_output.aircraft_name 
4697
					ORDER BY aircraft_icao_count DESC";
4698
 
4699
		
4700
		$sth = $this->db->prepare($query);
4701
		$sth->execute(array(':departure_airport_icao' => $departure_airport_icao,':arrival_airport_icao' => $arrival_airport_icao));
4702
		$aircraft_array = array();
4703
		$temp_array = array();
4704
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
4705
		{
4706
			$temp_array['aircraft_icao'] = $row['aircraft_icao'];
4707
			$temp_array['aircraft_name'] = $row['aircraft_name'];
4708
			$temp_array['aircraft_icao_count'] = $row['aircraft_icao_count'];
4709
			$aircraft_array[] = $temp_array;
4710
		}
4711
		return $aircraft_array;
4712
	}
4713
4714
	/**
4715
	* Gets all aircraft registration that have flown over by route
4716
	*
4717
	* @return Array the aircraft list
4718
	*
4719
	*/
4720
	public function countAllAircraftRegistrationByRoute($departure_airport_icao, $arrival_airport_icao)
4721
	{
4722
		$Image = new Image($this->db);
4723
		$departure_airport_icao = filter_var($departure_airport_icao,FILTER_SANITIZE_STRING);
4724
		$arrival_airport_icao = filter_var($arrival_airport_icao,FILTER_SANITIZE_STRING);
4725
4726
		$query  = "SELECT DISTINCT spotter_output.aircraft_icao, COUNT(spotter_output.registration) AS registration_count, spotter_output.aircraft_name, spotter_output.registration, spotter_output.airline_name   
4727
                    FROM spotter_output
4728
                    WHERE spotter_output.registration <> '' AND (spotter_output.departure_airport_icao = :departure_airport_icao) AND (spotter_output.arrival_airport_icao = :arrival_airport_icao)   
4729
                    GROUP BY spotter_output.registration 
4730
					ORDER BY registration_count DESC";
4731
4732
		
4733
		$sth = $this->db->prepare($query);
4734
		$sth->execute(array(':departure_airport_icao' => $departure_airport_icao,':arrival_airport_icao' => $arrival_airport_icao));
4735
      
4736
		$aircraft_array = array();
4737
		$temp_array = array();
4738
        
4739
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
4740
		{
4741
			$temp_array['aircraft_icao'] = $row['aircraft_icao'];
4742
			$temp_array['aircraft_name'] = $row['aircraft_name'];
4743
			$temp_array['registration'] = $row['registration'];
4744
			$temp_array['airline_name'] = $row['airline_name'];
4745
			$temp_array['image_thumbnail'] = "";
4746
			if($row['registration'] != "")
4747
			{
4748
				$image_array = $Image->getSpotterImage($row['registration']);
4749
				if (isset($image_array[0]['image_thumbnail'])) $temp_array['image_thumbnail'] = $image_array[0]['image_thumbnail'];
4750
			}
4751
			$temp_array['registration_count'] = $row['registration_count'];
4752
          
4753
			$aircraft_array[] = $temp_array;
4754
		}
4755
4756
		return $aircraft_array;
4757
	}
4758
	
4759
	
4760
	/**
4761
	* Gets all aircraft manufacturer that have flown over by route
4762
	*
4763
	* @return Array the aircraft manufacturer list
4764
	*
4765
	*/
4766
	public function countAllAircraftManufacturerByRoute($departure_airport_icao, $arrival_airport_icao)
4767
	{
4768
		$departure_airport_icao = filter_var($departure_airport_icao,FILTER_SANITIZE_STRING);
4769
		$arrival_airport_icao = filter_var($arrival_airport_icao,FILTER_SANITIZE_STRING);
4770
4771
		$query  = "SELECT DISTINCT spotter_output.aircraft_manufacturer, COUNT(spotter_output.aircraft_manufacturer) AS aircraft_manufacturer_count  
4772
                    FROM spotter_output
4773
                    WHERE spotter_output.aircraft_manufacturer <> '' AND (spotter_output.departure_airport_icao = :departure_airport_icao) AND (spotter_output.arrival_airport_icao = :arrival_airport_icao) 
4774
                    GROUP BY spotter_output.aircraft_manufacturer 
4775
					ORDER BY aircraft_manufacturer_count DESC";
4776
4777
		
4778
		$sth = $this->db->prepare($query);
4779
		$sth->execute(array(':departure_airport_icao' => $departure_airport_icao,':arrival_airport_icao' => $arrival_airport_icao));
4780
      
4781
		$aircraft_array = array();
4782
		$temp_array = array();
4783
        
4784
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
4785
		{
4786
			$temp_array['aircraft_manufacturer'] = $row['aircraft_manufacturer'];
4787
			$temp_array['aircraft_manufacturer_count'] = $row['aircraft_manufacturer_count'];
4788
          
4789
			$aircraft_array[] = $temp_array;
4790
		}
4791
4792
		return $aircraft_array;
4793
	}	
4794
4795
	
4796
	
4797
	
4798
	/**
4799
	* Gets all aircraft types that have flown over by country
4800
	*
4801
	* @return Array the aircraft list
4802
	*
4803
	*/
4804
	public function countAllAircraftTypesByCountry($country)
4805
	{
4806
		$country = filter_var($country,FILTER_SANITIZE_STRING);
4807
4808
		$query  = "SELECT DISTINCT spotter_output.aircraft_icao, COUNT(spotter_output.aircraft_icao) AS aircraft_icao_count, spotter_output.aircraft_name  
4809
                    FROM spotter_output
4810
                    WHERE ((spotter_output.departure_airport_country = :country) OR (spotter_output.arrival_airport_country = :country)) OR spotter_output.airline_country = :country 
4811
                    GROUP BY spotter_output.aircraft_name 
4812
					ORDER BY aircraft_icao_count DESC";
4813
 
4814
		
4815
		$sth = $this->db->prepare($query);
4816
		$sth->execute(array(':country' => $country));
4817
      
4818
		$aircraft_array = array();
4819
		$temp_array = array();
4820
        
4821
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
4822
		{
4823
			$temp_array['aircraft_icao'] = $row['aircraft_icao'];
4824
			$temp_array['aircraft_name'] = $row['aircraft_name'];
4825
			$temp_array['aircraft_icao_count'] = $row['aircraft_icao_count'];
4826
          
4827
			$aircraft_array[] = $temp_array;
4828
		}
4829
4830
		return $aircraft_array;
4831
	}
4832
4833
4834
	/**
4835
	* Gets all aircraft registration that have flown over by country
4836
	*
4837
	* @return Array the aircraft list
4838
	*
4839
	*/
4840
	public function countAllAircraftRegistrationByCountry($country)
4841
	{
4842
		$Image = new Image($this->db);
4843
		$country = filter_var($country,FILTER_SANITIZE_STRING);
4844
4845
		$query  = "SELECT DISTINCT spotter_output.aircraft_icao, COUNT(spotter_output.registration) AS registration_count, spotter_output.aircraft_name, spotter_output.registration, spotter_output.airline_name 
4846
                    FROM spotter_output
4847
                    WHERE spotter_output.registration <> '' AND (((spotter_output.departure_airport_country = :country) OR (spotter_output.arrival_airport_country = :country)) OR spotter_output.airline_country = :country)    
4848
                    GROUP BY spotter_output.registration 
4849
					ORDER BY registration_count DESC";
4850
4851
		
4852
		$sth = $this->db->prepare($query);
4853
		$sth->execute(array(':country' => $country));
4854
      
4855
		$aircraft_array = array();
4856
		$temp_array = array();
4857
        
4858
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
4859
		{
4860
			$temp_array['aircraft_icao'] = $row['aircraft_icao'];
4861
			$temp_array['aircraft_name'] = $row['aircraft_name'];
4862
			$temp_array['registration'] = $row['registration'];
4863
			$temp_array['airline_name'] = $row['airline_name'];
4864
			$temp_array['image_thumbnail'] = "";
4865
			if($row['registration'] != "")
4866
			{
4867
				$image_array = $Image->getSpotterImage($row['registration']);
4868
				if (isset($image_array[0]['image_thumbnail'])) $temp_array['image_thumbnail'] = $image_array[0]['image_thumbnail'];
4869
			}
4870
			$temp_array['registration_count'] = $row['registration_count'];
4871
          
4872
			$aircraft_array[] = $temp_array;
4873
		}
4874
4875
		return $aircraft_array;
4876
	}
4877
	
4878
	
4879
	/**
4880
	* Gets all aircraft manufacturer that have flown over by country
4881
	*
4882
	* @return Array the aircraft manufacturer list
4883
	*
4884
	*/
4885
	public function countAllAircraftManufacturerByCountry($country)
4886
	{
4887
		$country = filter_var($country,FILTER_SANITIZE_STRING);
4888
4889
		$query  = "SELECT DISTINCT spotter_output.aircraft_manufacturer, COUNT(spotter_output.aircraft_manufacturer) AS aircraft_manufacturer_count  
4890
                    FROM spotter_output
4891
                    WHERE spotter_output.aircraft_manufacturer <> '' AND (((spotter_output.departure_airport_country = :country) OR (spotter_output.arrival_airport_country = :country)) OR spotter_output.airline_country = :country) 
4892
                    GROUP BY spotter_output.aircraft_manufacturer 
4893
					ORDER BY aircraft_manufacturer_count DESC";
4894
4895
		
4896
		$sth = $this->db->prepare($query);
4897
		$sth->execute(array(':country' => $country));
4898
      
4899
		$aircraft_array = array();
4900
		$temp_array = array();
4901
        
4902
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
4903
		{
4904
			$temp_array['aircraft_manufacturer'] = $row['aircraft_manufacturer'];
4905
			$temp_array['aircraft_manufacturer_count'] = $row['aircraft_manufacturer_count'];
4906
          
4907
			$aircraft_array[] = $temp_array;
4908
		}
4909
4910
		return $aircraft_array;
4911
	}	
4912
	
4913
	
4914
	
4915
	/**
4916
	* Gets all aircraft manufacturers that have flown over
4917
	*
4918
	* @return Array the aircraft list
4919
	*
4920
	*/
4921
	public function countAllAircraftManufacturers()
4922
	{
4923
		$query  = "SELECT DISTINCT spotter_output.aircraft_manufacturer, COUNT(spotter_output.aircraft_manufacturer) AS aircraft_manufacturer_count  
4924
                    FROM spotter_output 
4925
                    WHERE spotter_output.aircraft_manufacturer <> '' AND spotter_output.aircraft_manufacturer <> 'Not Available' 
4926
                    GROUP BY spotter_output.aircraft_manufacturer
4927
					ORDER BY aircraft_manufacturer_count DESC
4928
					LIMIT 10";
4929
      
4930
		
4931
		$sth = $this->db->prepare($query);
4932
		$sth->execute();
4933
      
4934
		$manufacturer_array = array();
4935
		$temp_array = array();
4936
        
4937
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
4938
		{
4939
			$temp_array['aircraft_manufacturer'] = $row['aircraft_manufacturer'];
4940
			$temp_array['aircraft_manufacturer_count'] = $row['aircraft_manufacturer_count'];
4941
          
4942
			$manufacturer_array[] = $temp_array;
4943
		}
4944
4945
		return $manufacturer_array;
4946
	}
4947
	
4948
	
4949
	
4950
	/**
4951
	* Gets all aircraft registrations that have flown over
4952
	*
4953
	* @return Array the aircraft list
4954
	*
4955
	*/
4956
	public function countAllAircraftRegistrations($limit = true,$olderthanmonths = 0,$sincedate = '')
4957
	{
4958
		global $globalDBdriver;
4959
		$Image = new Image($this->db);
4960
		$query  = "SELECT DISTINCT spotter_output.registration, COUNT(spotter_output.registration) AS aircraft_registration_count, spotter_output.aircraft_icao,  spotter_output.aircraft_name, spotter_output.airline_name    
4961
                    FROM spotter_output 
4962
                    WHERE spotter_output.registration <> '' AND spotter_output.registration <> 'NA' ";
4963
                if ($olderthanmonths > 0) {
4964
            		if ($globalDBdriver == 'mysql') {
4965
				$query .= 'AND spotter_output.date < DATE_SUB(UTC_TIMESTAMP(), INTERVAL '.$olderthanmonths.' MONTH) ';
4966
			} else {
4967
				$query .= "AND spotter_output.date < CURRENT_TIMESTAMP AT TIME ZONE 'UTC' - INTERVAL '".$olderthanmonths." MONTHS' ";
4968
			}
4969
		}
4970
                if ($sincedate != '') {
4971
            		if ($globalDBdriver == 'mysql') {
4972
				$query .= "AND spotter_output.date > '".$sincedate."' ";
4973
			} else {
4974
				$query .= "AND spotter_output.date > CAST('".$sincedate."' AS TIMESTAMP)";
4975
			}
4976
		}
4977
4978
		// if ($olderthanmonths > 0) $query .= 'AND date < DATE_SUB(UTC_TIMESTAMP(),INTERVAL '.$olderthanmonths.' MONTH) ';
4979
		//if ($sincedate != '') $query .= "AND date > '".$sincedate."' ";
4980
                $query .= "GROUP BY spotter_output.registration, spotter_output.aircraft_icao, spotter_output.aircraft_name, spotter_output.airline_name ORDER BY aircraft_registration_count DESC";
4981
		if ($limit) $query .= " LIMIT 10 OFFSET 0";
4982
		
4983
		$sth = $this->db->prepare($query);
4984
		$sth->execute();
4985
      
4986
		$aircraft_array = array();
4987
		$temp_array = array();
4988
        
4989
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
4990
		{
4991
			$temp_array['registration'] = $row['registration'];
4992
			$temp_array['aircraft_registration_count'] = $row['aircraft_registration_count'];
4993
			$temp_array['aircraft_icao'] = $row['aircraft_icao'];
4994
			$temp_array['aircraft_name'] = $row['aircraft_name'];
4995
			$temp_array['airline_name'] = $row['airline_name'];
4996
			$temp_array['image_thumbnail'] = "";
4997
			if($row['registration'] != "")
4998
			{
4999
				$image_array = $Image->getSpotterImage($row['registration']);
5000
				if (isset($image_array[0]['image_thumbnail'])) $temp_array['image_thumbnail'] = $image_array[0]['image_thumbnail'];
5001
			}
5002
          
5003
			$aircraft_array[] = $temp_array;
5004
		}
5005
5006
		return $aircraft_array;
5007
	}
5008
5009
5010
	
5011
	
5012
	/**
5013
	* Gets all departure airports of the airplanes that have flown over
5014
	*
5015
	* @return Array the airport list
5016
	*
5017
	*/
5018
	public function countAllDepartureAirports($limit = true, $olderthanmonths = 0, $sincedate = '')
5019
	{
5020
		global $globalDBdriver;
5021
		$query  = "SELECT DISTINCT spotter_output.departure_airport_icao, COUNT(spotter_output.departure_airport_icao) AS airport_departure_icao_count, spotter_output.departure_airport_name, spotter_output.departure_airport_city, spotter_output.departure_airport_country 
5022
								FROM spotter_output
5023
                    WHERE spotter_output.departure_airport_name <> '' AND spotter_output.departure_airport_icao <> 'NA' ";
5024
                if ($olderthanmonths > 0) {
5025
            		if ($globalDBdriver == 'mysql') {
5026
				$query .= 'AND spotter_output.date < DATE_SUB(UTC_TIMESTAMP(), INTERVAL '.$olderthanmonths.' MONTH) ';
5027
			} else {
5028
				$query .= "AND spotter_output.date < CURRENT_TIMESTAMP AT TIME ZONE 'UTC' - INTERVAL '".$olderthanmonths." MONTHS' ";
5029
			}
5030
                }
5031
                if ($sincedate != '') {
5032
            		if ($globalDBdriver == 'mysql') {
5033
				$query .= "AND spotter_output.date > '".$sincedate."' ";
5034
			} else {
5035
				$query .= "AND spotter_output.date > CAST('".$sincedate."' AS TIMESTAMP)";
5036
			}
5037
		}
5038
5039
            	//if ($olderthanmonths > 0) $query .= 'AND date < DATE_SUB(UTC_TIMESTAMP(),INTERVAL '.$olderthanmonths.' MONTH) ';
5040
                //if ($sincedate != '') $query .= "AND date > '".$sincedate."' ";
5041
                $query .= "GROUP BY spotter_output.departure_airport_icao, spotter_output.departure_airport_name, spotter_output.departure_airport_city, spotter_output.departure_airport_country
5042
				ORDER BY airport_departure_icao_count DESC";
5043
		if ($limit) $query .= " LIMIT 10 OFFSET 0";
5044
      
5045
		$sth = $this->db->prepare($query);
5046
		$sth->execute();
5047
      
5048
		$airport_array = array();
5049
		$temp_array = array();
5050
        
5051
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
5052
		{
5053
			$temp_array['airport_departure_icao'] = $row['departure_airport_icao'];
5054
			$temp_array['airport_departure_icao_count'] = $row['airport_departure_icao_count'];
5055
			$temp_array['airport_departure_name'] = $row['departure_airport_name'];
5056
			$temp_array['airport_departure_city'] = $row['departure_airport_city'];
5057
			$temp_array['airport_departure_country'] = $row['departure_airport_country'];
5058
          
5059
			$airport_array[] = $temp_array;
5060
		}
5061
		return $airport_array;
5062
	}
5063
	
5064
	/**
5065
	* Gets all detected departure airports of the airplanes that have flown over
5066
	*
5067
	* @return Array the airport list
5068
	*
5069
	*/
5070
	public function countAllDetectedDepartureAirports($limit = true, $olderthanmonths = 0, $sincedate = '')
5071
	{
5072
		global $globalDBdriver;
5073
		$query  = "SELECT DISTINCT spotter_output.real_departure_airport_icao AS departure_airport_icao, COUNT(spotter_output.real_departure_airport_icao) AS airport_departure_icao_count, airport.name as departure_airport_name, airport.city as departure_airport_city, airport.country as departure_airport_country
5074
				FROM spotter_output, airport
5075
                    WHERE spotter_output.real_departure_airport_icao <> '' AND spotter_output.real_departure_airport_icao <> 'NA' AND airport.icao = spotter_output.real_departure_airport_icao ";
5076
                if ($olderthanmonths > 0) {
5077
            		if ($globalDBdriver == 'mysql') {
5078
				$query .= 'AND spotter_output.date < DATE_SUB(UTC_TIMESTAMP(), INTERVAL '.$olderthanmonths.' MONTH) ';
5079
			} else {
5080
				$query .= "AND spotter_output.date < CURRENT_TIMESTAMP AT TIME ZONE 'UTC' - INTERVAL '".$olderthanmonths." MONTHS' ";
5081
			}
5082
                }
5083
                if ($sincedate != '') {
5084
            		if ($globalDBdriver == 'mysql') {
5085
				$query .= "AND spotter_output.date > '".$sincedate."' ";
5086
			} else {
5087
				$query .= "AND spotter_output.date > CAST('".$sincedate."' AS TIMESTAMP)";
5088
			}
5089
		}
5090
5091
            	//if ($olderthanmonths > 0) $query .= 'AND date < DATE_SUB(UTC_TIMESTAMP(),INTERVAL '.$olderthanmonths.' MONTH) ';
5092
                //if ($sincedate != '') $query .= "AND date > '".$sincedate."' ";
5093
                $query .= "GROUP BY spotter_output.real_departure_airport_icao, airport.name, airport.city, airport.country
5094
				ORDER BY airport_departure_icao_count DESC";
5095
		if ($limit) $query .= " LIMIT 10 OFFSET 0";
5096
      
5097
		$sth = $this->db->prepare($query);
5098
		$sth->execute();
5099
      
5100
		$airport_array = array();
5101
		$temp_array = array();
5102
        
5103
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
5104
		{
5105
			$temp_array['airport_departure_icao'] = $row['departure_airport_icao'];
5106
			$temp_array['airport_departure_icao_count'] = $row['airport_departure_icao_count'];
5107
			$temp_array['airport_departure_name'] = $row['departure_airport_name'];
5108
			$temp_array['airport_departure_city'] = $row['departure_airport_city'];
5109
			$temp_array['airport_departure_country'] = $row['departure_airport_country'];
5110
          
5111
			$airport_array[] = $temp_array;
5112
		}
5113
		return $airport_array;
5114
	}
5115
	
5116
	
5117
	
5118
	/**
5119
	* Gets all departure airports of the airplanes that have flown over based on an airline icao
5120
	*
5121
	* @return Array the airport list
5122
	*
5123
	*/
5124
	public function countAllDepartureAirportsByAirline($airline_icao)
5125
	{
5126
		$airline_icao = filter_var($airline_icao,FILTER_SANITIZE_STRING);
5127
5128
		$query  = "SELECT DISTINCT spotter_output.departure_airport_icao, COUNT(spotter_output.departure_airport_icao) AS airport_departure_icao_count, spotter_output.departure_airport_name, spotter_output.departure_airport_city, spotter_output.departure_airport_country 
5129
								FROM spotter_output
5130
                    WHERE spotter_output.departure_airport_name <> '' AND spotter_output.departure_airport_icao <> 'NA' AND spotter_output.airline_icao = :airline_icao 
5131
                    GROUP BY spotter_output.departure_airport_icao
5132
					ORDER BY airport_departure_icao_count DESC";
5133
      
5134
		
5135
		$sth = $this->db->prepare($query);
5136
		$sth->execute(array(':airline_icao' => $airline_icao));
5137
      
5138
		$airport_array = array();
5139
		$temp_array = array();
5140
        
5141
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
5142
		{
5143
			$temp_array['airport_departure_icao'] = $row['departure_airport_icao'];
5144
			$temp_array['airport_departure_icao_count'] = $row['airport_departure_icao_count'];
5145
			$temp_array['airport_departure_name'] = $row['departure_airport_name'];
5146
			$temp_array['airport_departure_city'] = $row['departure_airport_city'];
5147
			$temp_array['airport_departure_country'] = $row['departure_airport_country'];
5148
          
5149
			$airport_array[] = $temp_array;
5150
		}
5151
5152
		return $airport_array;
5153
	}
5154
	
5155
	
5156
	
5157
	/**
5158
	* Gets all departure airports by country of the airplanes that have flown over based on an airline icao
5159
	*
5160
	* @return Array the airport list
5161
	*
5162
	*/
5163
	public function countAllDepartureAirportCountriesByAirline($airline_icao)
5164
	{
5165
		$airline_icao = filter_var($airline_icao,FILTER_SANITIZE_STRING);
5166
					
5167
		$query  = "SELECT DISTINCT spotter_output.departure_airport_country, COUNT(spotter_output.departure_airport_country) AS airport_departure_country_count 
5168
								FROM spotter_output 
5169
                    WHERE spotter_output.departure_airport_country <> '' AND spotter_output.airline_icao = :airline_icao 
5170
                    GROUP BY spotter_output.departure_airport_country
5171
					ORDER BY airport_departure_country_count DESC";
5172
      
5173
		
5174
		$sth = $this->db->prepare($query);
5175
		$sth->execute(array(':airline_icao' => $airline_icao));
5176
      
5177
		$airport_array = array();
5178
		$temp_array = array();
5179
        
5180
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
5181
		{
5182
			$temp_array['departure_airport_country'] = $row['departure_airport_country'];
5183
			$temp_array['airport_departure_country_count'] = $row['airport_departure_country_count'];
5184
          
5185
			$airport_array[] = $temp_array;
5186
		}
5187
5188
		return $airport_array;
5189
	}
5190
	
5191
	
5192
	
5193
	/**
5194
	* Gets all departure airports of the airplanes that have flown over based on an aircraft icao
5195
	*
5196
	* @return Array the airport list
5197
	*
5198
	*/
5199
	public function countAllDepartureAirportsByAircraft($aircraft_icao)
5200
	{
5201
		$aircraft_icao = filter_var($aircraft_icao,FILTER_SANITIZE_STRING);
5202
5203
		$query  = "SELECT DISTINCT spotter_output.departure_airport_icao, COUNT(spotter_output.departure_airport_icao) AS airport_departure_icao_count, spotter_output.departure_airport_name, spotter_output.departure_airport_city, spotter_output.departure_airport_country 
5204
								FROM spotter_output
5205
                    WHERE spotter_output.departure_airport_name <> '' AND spotter_output.departure_airport_icao <> 'NA' AND spotter_output.aircraft_icao = :aircraft_icao 
5206
                    GROUP BY spotter_output.departure_airport_icao
5207
					ORDER BY airport_departure_icao_count DESC";
5208
      
5209
		
5210
		$sth = $this->db->prepare($query);
5211
		$sth->execute(array(':aircraft_icao' => $aircraft_icao));
5212
      
5213
		$airport_array = array();
5214
		$temp_array = array();
5215
        
5216
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
5217
		{
5218
			$temp_array['airport_departure_icao'] = $row['departure_airport_icao'];
5219
			$temp_array['airport_departure_icao_count'] = $row['airport_departure_icao_count'];
5220
			$temp_array['airport_departure_name'] = $row['departure_airport_name'];
5221
			$temp_array['airport_departure_city'] = $row['departure_airport_city'];
5222
			$temp_array['airport_departure_country'] = $row['departure_airport_country'];
5223
          
5224
			$airport_array[] = $temp_array;
5225
		}
5226
5227
		return $airport_array;
5228
	}
5229
	
5230
	
5231
	/**
5232
	* Gets all departure airports by country of the airplanes that have flown over based on an aircraft icao
5233
	*
5234
	* @return Array the airport list
5235
	*
5236
	*/
5237
	public function countAllDepartureAirportCountriesByAircraft($aircraft_icao)
5238
	{
5239
		$aircraft_icao = filter_var($aircraft_icao,FILTER_SANITIZE_STRING);
5240
					
5241
		$query  = "SELECT DISTINCT spotter_output.departure_airport_country, COUNT(spotter_output.departure_airport_country) AS airport_departure_country_count 
5242
								FROM spotter_output 
5243
                    WHERE spotter_output.departure_airport_country <> '' AND spotter_output.aircraft_icao = :aircraft_icao
5244
                    GROUP BY spotter_output.departure_airport_country
5245
					ORDER BY airport_departure_country_count DESC";
5246
      
5247
		
5248
		$sth = $this->db->prepare($query);
5249
		$sth->execute(array(':aircraft_icao' => $aircraft_icao));
5250
      
5251
		$airport_array = array();
5252
		$temp_array = array();
5253
        
5254
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
5255
		{
5256
			$temp_array['departure_airport_country'] = $row['departure_airport_country'];
5257
			$temp_array['airport_departure_country_count'] = $row['airport_departure_country_count'];
5258
          
5259
			$airport_array[] = $temp_array;
5260
		}
5261
5262
		return $airport_array;
5263
	}
5264
	
5265
	
5266
	/**
5267
	* Gets all departure airports of the airplanes that have flown over based on an aircraft registration
5268
	*
5269
	* @return Array the airport list
5270
	*
5271
	*/
5272
	public function countAllDepartureAirportsByRegistration($registration)
5273
	{
5274
		$registration = filter_var($registration,FILTER_SANITIZE_STRING);
5275
5276
		$query  = "SELECT DISTINCT spotter_output.departure_airport_icao, COUNT(spotter_output.departure_airport_icao) AS airport_departure_icao_count, spotter_output.departure_airport_name, spotter_output.departure_airport_city, spotter_output.departure_airport_country 
5277
								FROM spotter_output
5278
                    WHERE spotter_output.departure_airport_name <> '' AND spotter_output.departure_airport_icao <> 'NA' AND spotter_output.registration = :registration 
5279
                    GROUP BY spotter_output.departure_airport_icao
5280
					ORDER BY airport_departure_icao_count DESC";
5281
      
5282
		
5283
		$sth = $this->db->prepare($query);
5284
		$sth->execute(array(':registration' => $registration));
5285
      
5286
		$airport_array = array();
5287
		$temp_array = array();
5288
        
5289
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
5290
		{
5291
			$temp_array['airport_departure_icao'] = $row['departure_airport_icao'];
5292
			$temp_array['airport_departure_icao_count'] = $row['airport_departure_icao_count'];
5293
			$temp_array['airport_departure_name'] = $row['departure_airport_name'];
5294
			$temp_array['airport_departure_city'] = $row['departure_airport_city'];
5295
			$temp_array['airport_departure_country'] = $row['departure_airport_country'];
5296
          
5297
			$airport_array[] = $temp_array;
5298
		}
5299
5300
		return $airport_array;
5301
	}
5302
	
5303
	
5304
	/**
5305
	* Gets all departure airports by country of the airplanes that have flown over based on an aircraft registration
5306
	*
5307
	* @return Array the airport list
5308
	*
5309
	*/
5310
	public function countAllDepartureAirportCountriesByRegistration($registration)
5311
	{
5312
		$registration = filter_var($registration,FILTER_SANITIZE_STRING);
5313
					
5314
		$query  = "SELECT DISTINCT spotter_output.departure_airport_country, COUNT(spotter_output.departure_airport_country) AS airport_departure_country_count 
5315
								FROM spotter_output 
5316
                    WHERE spotter_output.departure_airport_country <> '' AND spotter_output.registration = :registration 
5317
                    GROUP BY spotter_output.departure_airport_country
5318
					ORDER BY airport_departure_country_count DESC";
5319
      
5320
		
5321
		$sth = $this->db->prepare($query);
5322
		$sth->execute(array(':registration' => $registration));
5323
      
5324
		$airport_array = array();
5325
		$temp_array = array();
5326
        
5327
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
5328
		{
5329
			$temp_array['departure_airport_country'] = $row['departure_airport_country'];
5330
			$temp_array['airport_departure_country_count'] = $row['airport_departure_country_count'];
5331
          
5332
			$airport_array[] = $temp_array;
5333
		}
5334
5335
		return $airport_array;
5336
	}
5337
	
5338
	
5339
	/**
5340
	* Gets all departure airports of the airplanes that have flown over based on an arrivl airport icao
5341
	*
5342
	* @return Array the airport list
5343
	*
5344
	*/
5345
	public function countAllDepartureAirportsByAirport($airport_icao)
5346
	{
5347
		$airport_icao = filter_var($airport_icao,FILTER_SANITIZE_STRING);
5348
5349
		$query  = "SELECT DISTINCT spotter_output.departure_airport_icao, COUNT(spotter_output.departure_airport_icao) AS airport_departure_icao_count, spotter_output.departure_airport_name, spotter_output.departure_airport_city, spotter_output.departure_airport_country 
5350
								FROM spotter_output
5351
                    WHERE spotter_output.departure_airport_name <> '' AND spotter_output.departure_airport_icao <> 'NA' AND spotter_output.arrival_airport_icao = :airport_icao 
5352
                    GROUP BY spotter_output.departure_airport_icao
5353
					ORDER BY airport_departure_icao_count DESC";
5354
      
5355
		
5356
		$sth = $this->db->prepare($query);
5357
		$sth->execute(array(':airport_icao' => $airport_icao));
5358
      
5359
		$airport_array = array();
5360
		$temp_array = array();
5361
        
5362
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
5363
		{
5364
			$temp_array['airport_departure_icao'] = $row['departure_airport_icao'];
5365
			$temp_array['airport_departure_icao_count'] = $row['airport_departure_icao_count'];
5366
			$temp_array['airport_departure_name'] = $row['departure_airport_name'];
5367
			$temp_array['airport_departure_city'] = $row['departure_airport_city'];
5368
			$temp_array['airport_departure_country'] = $row['departure_airport_country'];
5369
          
5370
			$airport_array[] = $temp_array;
5371
		}
5372
5373
		return $airport_array;
5374
	}
5375
	
5376
	
5377
	/**
5378
	* Gets all departure airports by country of the airplanes that have flown over based on an airport icao
5379
	*
5380
	* @return Array the airport list
5381
	*
5382
	*/
5383
	public function countAllDepartureAirportCountriesByAirport($airport_icao)
5384
	{
5385
		$airport_icao = filter_var($airport_icao,FILTER_SANITIZE_STRING);
5386
					
5387
		$query  = "SELECT DISTINCT spotter_output.departure_airport_country, COUNT(spotter_output.departure_airport_country) AS airport_departure_country_count 
5388
								FROM spotter_output 
5389
                    WHERE spotter_output.departure_airport_country <> '' AND spotter_output.arrival_airport_icao = :airport_icao 
5390
                    GROUP BY spotter_output.departure_airport_country
5391
					ORDER BY airport_departure_country_count DESC";
5392
      
5393
		
5394
		$sth = $this->db->prepare($query);
5395
		$sth->execute(array(':airport_icao' => $airport_icao));
5396
      
5397
		$airport_array = array();
5398
		$temp_array = array();
5399
        
5400
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
5401
		{
5402
			$temp_array['departure_airport_country'] = $row['departure_airport_country'];
5403
			$temp_array['airport_departure_country_count'] = $row['airport_departure_country_count'];
5404
          
5405
			$airport_array[] = $temp_array;
5406
		}
5407
5408
		return $airport_array;
5409
	}
5410
	
5411
	
5412
	
5413
	/**
5414
	* Gets all departure airports of the airplanes that have flown over based on an aircraft manufacturer
5415
	*
5416
	* @return Array the airport list
5417
	*
5418
	*/
5419
	public function countAllDepartureAirportsByManufacturer($aircraft_manufacturer)
5420
	{
5421
		$aircraft_manufacturer = filter_var($aircraft_manufacturer,FILTER_SANITIZE_STRING);
5422
5423
		$query  = "SELECT DISTINCT spotter_output.departure_airport_icao, COUNT(spotter_output.departure_airport_icao) AS airport_departure_icao_count, spotter_output.departure_airport_name, spotter_output.departure_airport_city, spotter_output.departure_airport_country 
5424
								FROM spotter_output
5425
                    WHERE spotter_output.departure_airport_name <> '' AND spotter_output.departure_airport_icao <> 'NA' AND spotter_output.aircraft_manufacturer = :aircraft_manufacturer 
5426
                    GROUP BY spotter_output.departure_airport_icao
5427
					ORDER BY airport_departure_icao_count DESC";
5428
      
5429
		
5430
		$sth = $this->db->prepare($query);
5431
		$sth->execute(array(':aircraft_manufacturer' => $aircraft_manufacturer));
5432
      
5433
		$airport_array = array();
5434
		$temp_array = array();
5435
        
5436
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
5437
		{
5438
			$temp_array['airport_departure_icao'] = $row['departure_airport_icao'];
5439
			$temp_array['airport_departure_icao_count'] = $row['airport_departure_icao_count'];
5440
			$temp_array['airport_departure_name'] = $row['departure_airport_name'];
5441
			$temp_array['airport_departure_city'] = $row['departure_airport_city'];
5442
			$temp_array['airport_departure_country'] = $row['departure_airport_country'];
5443
          
5444
			$airport_array[] = $temp_array;
5445
		}
5446
5447
		return $airport_array;
5448
	}
5449
	
5450
	
5451
	/**
5452
	* Gets all departure airports by country of the airplanes that have flown over based on an aircraft manufacturer
5453
	*
5454
	* @return Array the airport list
5455
	*
5456
	*/
5457
	public function countAllDepartureAirportCountriesByManufacturer($aircraft_manufacturer)
5458
	{
5459
		$aircraft_manufacturer = filter_var($aircraft_manufacturer,FILTER_SANITIZE_STRING);
5460
					
5461
		$query  = "SELECT DISTINCT spotter_output.departure_airport_country, COUNT(spotter_output.departure_airport_country) AS airport_departure_country_count 
5462
								FROM spotter_output 
5463
                    WHERE spotter_output.departure_airport_country <> '' AND spotter_output.aircraft_manufacturer = :aircraft_manufacturer 
5464
                    GROUP BY spotter_output.departure_airport_country
5465
					ORDER BY airport_departure_country_count DESC";
5466
      
5467
		
5468
		$sth = $this->db->prepare($query);
5469
		$sth->execute(array(':aircraft_manufacturer' => $aircraft_manufacturer));
5470
      
5471
		$airport_array = array();
5472
		$temp_array = array();
5473
        
5474
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
5475
		{
5476
			$temp_array['departure_airport_country'] = $row['departure_airport_country'];
5477
			$temp_array['airport_departure_country_count'] = $row['airport_departure_country_count'];
5478
          
5479
			$airport_array[] = $temp_array;
5480
		}
5481
5482
		return $airport_array;
5483
	}
5484
	
5485
	
5486
	/**
5487
	* Gets all departure airports of the airplanes that have flown over based on a date
5488
	*
5489
	* @return Array the airport list
5490
	*
5491
	*/
5492
	public function countAllDepartureAirportsByDate($date)
5493
	{
5494
		global $globalTimezone, $globalDBdriver;
5495
		$date = filter_var($date,FILTER_SANITIZE_STRING);
5496
5497
		if ($globalTimezone != '') {
5498
			date_default_timezone_set($globalTimezone);
5499
			$datetime = new DateTime($date);
5500
			$offset = $datetime->format('P');
5501
		} else $offset = '+00:00';
5502
5503
		if ($globalDBdriver == 'mysql') {
5504
			$query  = "SELECT DISTINCT spotter_output.departure_airport_icao, COUNT(spotter_output.departure_airport_icao) AS airport_departure_icao_count, spotter_output.departure_airport_name, spotter_output.departure_airport_city, spotter_output.departure_airport_country 
5505
					FROM spotter_output
5506
					WHERE spotter_output.departure_airport_name <> '' AND spotter_output.departure_airport_icao <> 'NA' AND DATE(CONVERT_TZ(spotter_output.date,'+00:00', :offset)) = :date
5507
					GROUP BY spotter_output.departure_airport_icao
5508
					ORDER BY airport_departure_icao_count DESC";
5509
		} else {
5510
			$query  = "SELECT DISTINCT spotter_output.departure_airport_icao, COUNT(spotter_output.departure_airport_icao) AS airport_departure_icao_count, spotter_output.departure_airport_name, spotter_output.departure_airport_city, spotter_output.departure_airport_country 
5511
					FROM spotter_output
5512
					WHERE spotter_output.departure_airport_name <> '' AND spotter_output.departure_airport_icao <> 'NA' AND to_char(spotter_output.date AT TIME ZONE INTERVAL :offset,'YYYY-mm-dd') = :date
5513
					GROUP BY spotter_output.departure_airport_icao
5514
					ORDER BY airport_departure_icao_count DESC";
5515
		}
5516
5517
		$sth = $this->db->prepare($query);
5518
		$sth->execute(array(':date' => $date, ':offset' => $offset));
5519
      
5520
		$airport_array = array();
5521
		$temp_array = array();
5522
        
5523
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
5524
		{
5525
			$temp_array['airport_departure_icao'] = $row['departure_airport_icao'];
5526
			$temp_array['airport_departure_icao_count'] = $row['airport_departure_icao_count'];
5527
			$temp_array['airport_departure_name'] = $row['departure_airport_name'];
5528
			$temp_array['airport_departure_city'] = $row['departure_airport_city'];
5529
			$temp_array['airport_departure_country'] = $row['departure_airport_country'];
5530
          
5531
			$airport_array[] = $temp_array;
5532
		}
5533
		return $airport_array;
5534
	}
5535
	
5536
	
5537
	
5538
	/**
5539
	* Gets all departure airports by country of the airplanes that have flown over based on a date
5540
	*
5541
	* @return Array the airport list
5542
	*
5543
	*/
5544
	public function countAllDepartureAirportCountriesByDate($date)
5545
	{
5546
		global $globalTimezone, $globalDBdriver;
5547
		$date = filter_var($date,FILTER_SANITIZE_STRING);
5548
		if ($globalTimezone != '') {
5549
			date_default_timezone_set($globalTimezone);
5550
			$datetime = new DateTime($date);
5551
			$offset = $datetime->format('P');
5552
		} else $offset = '+00:00';
5553
5554
		if ($globalDBdriver == 'mysql') {
5555
			$query  = "SELECT DISTINCT spotter_output.departure_airport_country, COUNT(spotter_output.departure_airport_country) AS airport_departure_country_count 
5556
					FROM spotter_output 
5557
					WHERE spotter_output.departure_airport_country <> '' AND DATE(CONVERT_TZ(spotter_output.date,'+00:00', :offset)) = :date 
5558
					GROUP BY spotter_output.departure_airport_country
5559
					ORDER BY airport_departure_country_count DESC";
5560
		} else {
5561
			$query  = "SELECT DISTINCT spotter_output.departure_airport_country, COUNT(spotter_output.departure_airport_country) AS airport_departure_country_count 
5562
					FROM spotter_output 
5563
					WHERE spotter_output.departure_airport_country <> '' AND to_char(spotter_output.date AT TIME ZONE INTERVAL :offset,'YYYY-mm-dd') = :date 
5564
					GROUP BY spotter_output.departure_airport_country
5565
					ORDER BY airport_departure_country_count DESC";
5566
		}
5567
		
5568
		$sth = $this->db->prepare($query);
5569
		$sth->execute(array(':date' => $date, ':offset' => $offset));
5570
      
5571
		$airport_array = array();
5572
		$temp_array = array();
5573
        
5574
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
5575
		{
5576
			$temp_array['departure_airport_country'] = $row['departure_airport_country'];
5577
			$temp_array['airport_departure_country_count'] = $row['airport_departure_country_count'];
5578
          
5579
			$airport_array[] = $temp_array;
5580
		}
5581
		return $airport_array;
5582
	}
5583
	
5584
	
5585
	
5586
	/**
5587
	* Gets all departure airports of the airplanes that have flown over based on a ident/callsign
5588
	*
5589
	* @return Array the airport list
5590
	*
5591
	*/
5592
	public function countAllDepartureAirportsByIdent($ident)
5593
	{
5594
		$ident = filter_var($ident,FILTER_SANITIZE_STRING);
5595
5596
		$query  = "SELECT DISTINCT spotter_output.departure_airport_icao, COUNT(spotter_output.departure_airport_icao) AS airport_departure_icao_count, spotter_output.departure_airport_name, spotter_output.departure_airport_city, spotter_output.departure_airport_country 
5597
		    FROM spotter_output
5598
                    WHERE spotter_output.departure_airport_name <> '' AND spotter_output.departure_airport_icao <> 'NA' AND spotter_output.ident = :ident 
5599
                    GROUP BY spotter_output.departure_airport_icao, spotter_output.departure_airport_name, spotter_output.departure_airport_city, spotter_output.departure_airport_country
5600
		    ORDER BY airport_departure_icao_count DESC";
5601
      
5602
		
5603
		$sth = $this->db->prepare($query);
5604
		$sth->execute(array(':ident' => $ident));
5605
      
5606
		$airport_array = array();
5607
		$temp_array = array();
5608
        
5609
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
5610
		{
5611
			$temp_array['airport_departure_icao'] = $row['departure_airport_icao'];
5612
			$temp_array['airport_departure_icao_count'] = $row['airport_departure_icao_count'];
5613
			$temp_array['airport_departure_name'] = $row['departure_airport_name'];
5614
			$temp_array['airport_departure_city'] = $row['departure_airport_city'];
5615
			$temp_array['airport_departure_country'] = $row['departure_airport_country'];
5616
          
5617
			$airport_array[] = $temp_array;
5618
		}
5619
5620
		return $airport_array;
5621
	}
5622
	
5623
	
5624
	
5625
	/**
5626
	* Gets all departure airports by country of the airplanes that have flown over based on a callsign/ident
5627
	*
5628
	* @return Array the airport list
5629
	*
5630
	*/
5631
	public function countAllDepartureAirportCountriesByIdent($ident)
5632
	{
5633
		$ident = filter_var($ident,FILTER_SANITIZE_STRING);
5634
					
5635
		$query  = "SELECT DISTINCT spotter_output.departure_airport_country, COUNT(spotter_output.departure_airport_country) AS airport_departure_country_count 
5636
								FROM spotter_output 
5637
                    WHERE spotter_output.departure_airport_country <> '' AND spotter_output.ident = :ident 
5638
                    GROUP BY spotter_output.departure_airport_country
5639
					ORDER BY airport_departure_country_count DESC";
5640
      
5641
		
5642
		$sth = $this->db->prepare($query);
5643
		$sth->execute(array(':ident' => $ident));
5644
      
5645
		$airport_array = array();
5646
		$temp_array = array();
5647
        
5648
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
5649
		{
5650
			$temp_array['departure_airport_country'] = $row['departure_airport_country'];
5651
			$temp_array['airport_departure_country_count'] = $row['airport_departure_country_count'];
5652
          
5653
			$airport_array[] = $temp_array;
5654
		}
5655
5656
		return $airport_array;
5657
	}
5658
	
5659
	
5660
	
5661
	/**
5662
	* Gets all departure airports of the airplanes that have flown over based on a country
5663
	*
5664
	* @return Array the airport list
5665
	*
5666
	*/
5667
	public function countAllDepartureAirportsByCountry($country)
5668
	{
5669
		$country = filter_var($country,FILTER_SANITIZE_STRING);
5670
5671
		$query  = "SELECT DISTINCT spotter_output.departure_airport_icao, COUNT(spotter_output.departure_airport_icao) AS airport_departure_icao_count, spotter_output.departure_airport_name, spotter_output.departure_airport_city, spotter_output.departure_airport_country 
5672
								FROM spotter_output
5673
                    WHERE ((spotter_output.departure_airport_country = :country) OR (spotter_output.arrival_airport_country = :country)) OR spotter_output.airline_country = :country
5674
                    GROUP BY spotter_output.departure_airport_icao
5675
					ORDER BY airport_departure_icao_count DESC";
5676
      
5677
		
5678
		$sth = $this->db->prepare($query);
5679
		$sth->execute(array(':country' => $country));
5680
      
5681
		$airport_array = array();
5682
		$temp_array = array();
5683
        
5684
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
5685
		{
5686
			$temp_array['airport_departure_icao'] = $row['departure_airport_icao'];
5687
			$temp_array['airport_departure_icao_count'] = $row['airport_departure_icao_count'];
5688
			$temp_array['airport_departure_name'] = $row['departure_airport_name'];
5689
			$temp_array['airport_departure_city'] = $row['departure_airport_city'];
5690
			$temp_array['airport_departure_country'] = $row['departure_airport_country'];
5691
          
5692
			$airport_array[] = $temp_array;
5693
		}
5694
5695
		return $airport_array;
5696
	}
5697
5698
5699
	/**
5700
	* Gets all departure airports by country of the airplanes that have flown over based on an aircraft icao
5701
	*
5702
	* @return Array the airport list
5703
	*
5704
	*/
5705
	public function countAllDepartureAirportCountriesByCountry($country)
5706
	{
5707
		$country = filter_var($country,FILTER_SANITIZE_STRING);
5708
					
5709
		$query  = "SELECT DISTINCT spotter_output.departure_airport_country, COUNT(spotter_output.departure_airport_country) AS airport_departure_country_count 
5710
								FROM spotter_output 
5711
                    WHERE spotter_output.departure_airport_country <> '' AND ((spotter_output.departure_airport_country = :country) OR (spotter_output.arrival_airport_country = :country)) OR spotter_output.airline_country = :country 
5712
                    GROUP BY spotter_output.departure_airport_country
5713
					ORDER BY airport_departure_country_count DESC";
5714
      
5715
		
5716
		$sth = $this->db->prepare($query);
5717
		$sth->execute(array(':country' => $country));
5718
      
5719
		$airport_array = array();
5720
		$temp_array = array();
5721
        
5722
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
5723
		{
5724
			$temp_array['departure_airport_country'] = $row['departure_airport_country'];
5725
			$temp_array['airport_departure_country_count'] = $row['airport_departure_country_count'];
5726
          
5727
			$airport_array[] = $temp_array;
5728
		}
5729
5730
		return $airport_array;
5731
	}
5732
	
5733
5734
	/**
5735
	* Gets all arrival airports of the airplanes that have flown over
5736
	*
5737
	* @return Array the airport list
5738
	*
5739
	*/
5740
	public function countAllArrivalAirports($limit = true, $olderthanmonths = 0, $sincedate = '', $icaoaskey = false)
5741
	{
5742
		global $globalDBdriver;
5743
		$query  = "SELECT DISTINCT spotter_output.arrival_airport_icao, COUNT(spotter_output.arrival_airport_icao) AS airport_arrival_icao_count, spotter_output.arrival_airport_name, spotter_output.arrival_airport_city, spotter_output.arrival_airport_country 
5744
								FROM spotter_output 
5745
                    WHERE spotter_output.arrival_airport_name <> '' AND spotter_output.arrival_airport_icao <> 'NA' ";
5746
                if ($olderthanmonths > 0) {
5747
            		if ($globalDBdriver == 'mysql') {
5748
				$query .= 'AND spotter_output.date < DATE_SUB(UTC_TIMESTAMP(), INTERVAL '.$olderthanmonths.' MONTH) ';
5749
			} else {
5750
				$query .= "AND spotter_output.date < CURRENT_TIMESTAMP AT TIME ZONE 'UTC' - INTERVAL '".$olderthanmonths." MONTHS' ";
5751
			}
5752
                if ($sincedate != '') {
5753
            		if ($globalDBdriver == 'mysql') {
5754
				$query .= "AND spotter_output.date > '".$sincedate."' ";
5755
			} else {
5756
				$query .= "AND spotter_output.date > CAST('".$sincedate."' AS TIMESTAMP)";
5757
			}
5758
		}
5759
            		if ($globalDBdriver == 'mysql') {
5760
				$query .= "AND spotter_output.date > '".$sincedate."' ";
5761
			} else {
5762
				$query .= "AND spotter_output.date > CAST('".$sincedate."' AS TIMESTAMP)";
5763
			}
5764
		}
5765
5766
            	//if ($olderthanmonths > 0) $query .= 'AND date < DATE_SUB(UTC_TIMESTAMP(),INTERVAL '.$olderthanmonths.' MONTH) ';
5767
                //if ($sincedate != '') $query .= "AND date > '".$sincedate."' ";
5768
                $query .= "GROUP BY spotter_output.arrival_airport_icao, spotter_output.arrival_airport_name, spotter_output.arrival_airport_city, spotter_output.arrival_airport_country
5769
					ORDER BY airport_arrival_icao_count DESC";
5770
		if ($limit) $query .= " LIMIT 10";
5771
      
5772
		
5773
		$sth = $this->db->prepare($query);
5774
		$sth->execute();
5775
      
5776
		$airport_array = array();
5777
		$temp_array = array();
5778
        
5779
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
5780
		{
5781
			$temp_array['airport_arrival_icao'] = $row['arrival_airport_icao'];
5782
			$temp_array['airport_arrival_icao_count'] = $row['airport_arrival_icao_count'];
5783
			$temp_array['airport_arrival_name'] = $row['arrival_airport_name'];
5784
			$temp_array['airport_arrival_city'] = $row['arrival_airport_city'];
5785
			$temp_array['airport_arrival_country'] = $row['arrival_airport_country'];
5786
          
5787
			if ($icaoaskey) {
5788
				$icao = $row['arrival_airport_icao'];
5789
				$airport_array[$icao] = $temp_array;
5790
			} else $airport_array[] = $temp_array;
5791
		}
5792
5793
		return $airport_array;
5794
	}
5795
	
5796
	/**
5797
	* Gets all detected arrival airports of the airplanes that have flown over
5798
	*
5799
	* @return Array the airport list
5800
	*
5801
	*/
5802
	public function countAllDetectedArrivalAirports($limit = true, $olderthanmonths = 0, $sincedate = '',$icaoaskey = false)
5803
	{
5804
		global $globalDBdriver;
5805
		$query  = "SELECT DISTINCT spotter_output.real_arrival_airport_icao as arrival_airport_icao, COUNT(spotter_output.real_arrival_airport_icao) AS airport_arrival_icao_count, airport.name AS arrival_airport_name, airport.city AS arrival_airport_city, airport.country AS arrival_airport_country 
5806
			FROM spotter_output, airport 
5807
                    WHERE spotter_output.real_arrival_airport_icao <> '' AND spotter_output.real_arrival_airport_icao <> 'NA' AND airport.icao = spotter_output.real_arrival_airport_icao ";
5808
                if ($olderthanmonths > 0) {
5809
            		if ($globalDBdriver == 'mysql') {
5810
				$query .= 'AND spotter_output.date < DATE_SUB(UTC_TIMESTAMP(), INTERVAL '.$olderthanmonths.' MONTH) ';
5811
			} else {
5812
				$query .= "AND spotter_output.date < CURRENT_TIMESTAMP AT TIME ZONE 'UTC' - INTERVAL '".$olderthanmonths." MONTHS' ";
5813
			}
5814
                if ($sincedate != '') {
5815
            		if ($globalDBdriver == 'mysql') {
5816
				$query .= "AND spotter_output.date > '".$sincedate."' ";
5817
			} else {
5818
				$query .= "AND spotter_output.date > CAST('".$sincedate."' AS TIMESTAMP)";
5819
			}
5820
		}
5821
            		if ($globalDBdriver == 'mysql') {
5822
				$query .= "AND spotter_output.date > '".$sincedate."' ";
5823
			} else {
5824
				$query .= "AND spotter_output.date > CAST('".$sincedate."' AS TIMESTAMP)";
5825
			}
5826
		}
5827
5828
            	//if ($olderthanmonths > 0) $query .= 'AND date < DATE_SUB(UTC_TIMESTAMP(),INTERVAL '.$olderthanmonths.' MONTH) ';
5829
                //if ($sincedate != '') $query .= "AND date > '".$sincedate."' ";
5830
                $query .= "GROUP BY spotter_output.real_arrival_airport_icao, airport.name, airport.city, airport.country
5831
					ORDER BY airport_arrival_icao_count DESC";
5832
		if ($limit) $query .= " LIMIT 10";
5833
      
5834
		
5835
		$sth = $this->db->prepare($query);
5836
		$sth->execute();
5837
      
5838
		$airport_array = array();
5839
		$temp_array = array();
5840
        
5841
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
5842
		{
5843
			$temp_array['airport_arrival_icao'] = $row['arrival_airport_icao'];
5844
			$temp_array['airport_arrival_icao_count'] = $row['airport_arrival_icao_count'];
5845
			$temp_array['airport_arrival_name'] = $row['arrival_airport_name'];
5846
			$temp_array['airport_arrival_city'] = $row['arrival_airport_city'];
5847
			$temp_array['airport_arrival_country'] = $row['arrival_airport_country'];
5848
          
5849
			if ($icaoaskey) {
5850
				$icao = $row['arrival_airport_icao'];
5851
				$airport_array[$icao] = $temp_array;
5852
			} else $airport_array[] = $temp_array;
5853
		}
5854
5855
		return $airport_array;
5856
	}
5857
	
5858
	
5859
	
5860
	/**
5861
	* Gets all arrival airports of the airplanes that have flown over based on an airline icao
5862
	*
5863
	* @return Array the airport list
5864
	*
5865
	*/
5866
	public function countAllArrivalAirportsByAirline($airline_icao)
5867
	{
5868
		$airline_icao = filter_var($airline_icao,FILTER_SANITIZE_STRING);
5869
5870
		$query  = "SELECT DISTINCT spotter_output.arrival_airport_icao, COUNT(spotter_output.arrival_airport_icao) AS airport_arrival_icao_count, spotter_output.arrival_airport_name, spotter_output.arrival_airport_city, spotter_output.arrival_airport_country 
5871
								FROM spotter_output 
5872
                    WHERE spotter_output.arrival_airport_name <> '' AND spotter_output.arrival_airport_icao <> 'NA' AND spotter_output.airline_icao = :airline_icao 
5873
                    GROUP BY spotter_output.arrival_airport_icao
5874
					ORDER BY airport_arrival_icao_count DESC";
5875
      
5876
		
5877
		$sth = $this->db->prepare($query);
5878
		$sth->execute(array(':airline_icao' => $airline_icao));
5879
      
5880
		$airport_array = array();
5881
		$temp_array = array();
5882
        
5883
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
5884
		{
5885
			$temp_array['airport_arrival_icao'] = $row['arrival_airport_icao'];
5886
			$temp_array['airport_arrival_icao_count'] = $row['airport_arrival_icao_count'];
5887
			$temp_array['airport_arrival_name'] = $row['arrival_airport_name'];
5888
			$temp_array['airport_arrival_city'] = $row['arrival_airport_city'];
5889
			$temp_array['airport_arrival_country'] = $row['arrival_airport_country'];
5890
          
5891
			$airport_array[] = $temp_array;
5892
		}
5893
5894
		return $airport_array;
5895
	}
5896
	
5897
	
5898
	/**
5899
	* Gets all arrival airports by country of the airplanes that have flown over based on an airline icao
5900
	*
5901
	* @return Array the airport list
5902
	*
5903
	*/
5904
	public function countAllArrivalAirportCountriesByAirline($airline_icao)
5905
	{
5906
		$airline_icao = filter_var($airline_icao,FILTER_SANITIZE_STRING);
5907
					
5908
		$query  = "SELECT DISTINCT spotter_output.arrival_airport_country, COUNT(spotter_output.arrival_airport_country) AS airport_arrival_country_count 
5909
								FROM spotter_output 
5910
                    WHERE spotter_output.arrival_airport_country <> '' AND spotter_output.airline_icao = :airline_icao 
5911
                    GROUP BY spotter_output.arrival_airport_country
5912
					ORDER BY airport_arrival_country_count DESC";
5913
      
5914
		
5915
		$sth = $this->db->prepare($query);
5916
		$sth->execute(array(':airline_icao' => $airline_icao));
5917
      
5918
		$airport_array = array();
5919
		$temp_array = array();
5920
        
5921
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
5922
		{
5923
			$temp_array['arrival_airport_country'] = $row['arrival_airport_country'];
5924
			$temp_array['airport_arrival_country_count'] = $row['airport_arrival_country_count'];
5925
          
5926
			$airport_array[] = $temp_array;
5927
		}
5928
5929
		return $airport_array;
5930
	}
5931
	
5932
	
5933
	/**
5934
	* Gets all arrival airports of the airplanes that have flown over based on an aircraft icao
5935
	*
5936
	* @return Array the airport list
5937
	*
5938
	*/
5939
	public function countAllArrivalAirportsByAircraft($aircraft_icao)
5940
	{
5941
		$aircraft_icao = filter_var($aircraft_icao,FILTER_SANITIZE_STRING);
5942
5943
		$query  = "SELECT DISTINCT spotter_output.arrival_airport_icao, COUNT(spotter_output.arrival_airport_icao) AS airport_arrival_icao_count, spotter_output.arrival_airport_name, spotter_output.arrival_airport_city, spotter_output.arrival_airport_country 
5944
								FROM spotter_output 
5945
                    WHERE spotter_output.arrival_airport_name <> '' AND spotter_output.arrival_airport_icao <> 'NA' AND spotter_output.aircraft_icao = :aircraft_icao 
5946
                    GROUP BY spotter_output.arrival_airport_icao
5947
					ORDER BY airport_arrival_icao_count DESC";
5948
      
5949
		
5950
		$sth = $this->db->prepare($query);
5951
		$sth->execute(array(':aircraft_icao' => $aircraft_icao));
5952
      
5953
		$airport_array = array();
5954
		$temp_array = array();
5955
        
5956
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
5957
		{
5958
			$temp_array['airport_arrival_icao'] = $row['arrival_airport_icao'];
5959
			$temp_array['airport_arrival_icao_count'] = $row['airport_arrival_icao_count'];
5960
			$temp_array['airport_arrival_name'] = $row['arrival_airport_name'];
5961
			$temp_array['airport_arrival_city'] = $row['arrival_airport_city'];
5962
			$temp_array['airport_arrival_country'] = $row['arrival_airport_country'];
5963
          
5964
			$airport_array[] = $temp_array;
5965
		}
5966
5967
		return $airport_array;
5968
	}
5969
	
5970
	
5971
	
5972
	/**
5973
	* Gets all arrival airports by country of the airplanes that have flown over based on an aircraft icao
5974
	*
5975
	* @return Array the airport list
5976
	*
5977
	*/
5978
	public function countAllArrivalAirportCountriesByAircraft($aircraft_icao)
5979
	{
5980
		$aircraft_icao = filter_var($aircraft_icao,FILTER_SANITIZE_STRING);
5981
					
5982
		$query  = "SELECT DISTINCT spotter_output.arrival_airport_country, COUNT(spotter_output.arrival_airport_country) AS airport_arrival_country_count 
5983
								FROM spotter_output 
5984
                    WHERE spotter_output.arrival_airport_country <> '' AND spotter_output.aircraft_icao = :aircraft_icao
5985
                    GROUP BY spotter_output.arrival_airport_country
5986
					ORDER BY airport_arrival_country_count DESC";
5987
      
5988
		
5989
		$sth = $this->db->prepare($query);
5990
		$sth->execute(array(':aircraft_icao' => $aircraft_icao));
5991
      
5992
		$airport_array = array();
5993
		$temp_array = array();
5994
        
5995
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
5996
		{
5997
			$temp_array['arrival_airport_country'] = $row['arrival_airport_country'];
5998
			$temp_array['airport_arrival_country_count'] = $row['airport_arrival_country_count'];
5999
          
6000
			$airport_array[] = $temp_array;
6001
		}
6002
6003
		return $airport_array;
6004
	}
6005
	
6006
	
6007
	/**
6008
	* Gets all arrival airports of the airplanes that have flown over based on an aircraft registration
6009
	*
6010
	* @return Array the airport list
6011
	*
6012
	*/
6013
	public function countAllArrivalAirportsByRegistration($registration)
6014
	{
6015
		$registration = filter_var($registration,FILTER_SANITIZE_STRING);
6016
6017
		$query  = "SELECT DISTINCT spotter_output.arrival_airport_icao, COUNT(spotter_output.arrival_airport_icao) AS airport_arrival_icao_count, spotter_output.arrival_airport_name, spotter_output.arrival_airport_city, spotter_output.arrival_airport_country 
6018
								FROM spotter_output 
6019
                    WHERE spotter_output.arrival_airport_name <> '' AND spotter_output.arrival_airport_icao <> 'NA' AND spotter_output.registration = :registration 
6020
                    GROUP BY spotter_output.arrival_airport_icao
6021
					ORDER BY airport_arrival_icao_count DESC";
6022
      
6023
		
6024
		$sth = $this->db->prepare($query);
6025
		$sth->execute(array(':registration' => $registration));
6026
      
6027
		$airport_array = array();
6028
		$temp_array = array();
6029
        
6030
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
6031
		{
6032
			$temp_array['airport_arrival_icao'] = $row['arrival_airport_icao'];
6033
			$temp_array['airport_arrival_icao_count'] = $row['airport_arrival_icao_count'];
6034
			$temp_array['airport_arrival_name'] = $row['arrival_airport_name'];
6035
			$temp_array['airport_arrival_city'] = $row['arrival_airport_city'];
6036
			$temp_array['airport_arrival_country'] = $row['arrival_airport_country'];
6037
          
6038
			$airport_array[] = $temp_array;
6039
		}
6040
6041
		return $airport_array;
6042
	}
6043
	
6044
	
6045
	/**
6046
	* Gets all arrival airports by country of the airplanes that have flown over based on an aircraft registration
6047
	*
6048
	* @return Array the airport list
6049
	*
6050
	*/
6051
	public function countAllArrivalAirportCountriesByRegistration($registration)
6052
	{
6053
		$registration = filter_var($registration,FILTER_SANITIZE_STRING);
6054
					
6055
		$query  = "SELECT DISTINCT spotter_output.arrival_airport_country, COUNT(spotter_output.arrival_airport_country) AS airport_arrival_country_count 
6056
								FROM spotter_output 
6057
                    WHERE spotter_output.arrival_airport_country <> '' AND spotter_output.registration = :registration 
6058
                    GROUP BY spotter_output.arrival_airport_country
6059
					ORDER BY airport_arrival_country_count DESC";
6060
      
6061
		
6062
		$sth = $this->db->prepare($query);
6063
		$sth->execute(array(':registration' => $registration));
6064
      
6065
		$airport_array = array();
6066
		$temp_array = array();
6067
        
6068
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
6069
		{
6070
			$temp_array['arrival_airport_country'] = $row['arrival_airport_country'];
6071
			$temp_array['airport_arrival_country_count'] = $row['airport_arrival_country_count'];
6072
          
6073
			$airport_array[] = $temp_array;
6074
		}
6075
6076
		return $airport_array;
6077
	}
6078
	
6079
	
6080
	
6081
	/**
6082
	* Gets all arrival airports of the airplanes that have flown over based on an departure airport
6083
	*
6084
	* @return Array the airport list
6085
	*
6086
	*/
6087
	public function countAllArrivalAirportsByAirport($airport_icao)
6088
	{
6089
		$airport_icao = filter_var($airport_icao,FILTER_SANITIZE_STRING);
6090
6091
		$query  = "SELECT DISTINCT spotter_output.arrival_airport_icao, COUNT(spotter_output.arrival_airport_icao) AS airport_arrival_icao_count, spotter_output.arrival_airport_name, spotter_output.arrival_airport_city, spotter_output.arrival_airport_country 
6092
								FROM spotter_output 
6093
                    WHERE spotter_output.arrival_airport_name <> '' AND spotter_output.arrival_airport_icao <> 'NA' AND spotter_output.departure_airport_icao = :airport_icao 
6094
                    GROUP BY spotter_output.arrival_airport_icao
6095
					ORDER BY airport_arrival_icao_count DESC";
6096
      
6097
		
6098
		$sth = $this->db->prepare($query);
6099
		$sth->execute(array(':airport_icao' => $airport_icao));
6100
      
6101
		$airport_array = array();
6102
		$temp_array = array();
6103
        
6104
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
6105
		{
6106
			$temp_array['airport_arrival_icao'] = $row['arrival_airport_icao'];
6107
			$temp_array['airport_arrival_icao_count'] = $row['airport_arrival_icao_count'];
6108
			$temp_array['airport_arrival_name'] = $row['arrival_airport_name'];
6109
			$temp_array['airport_arrival_city'] = $row['arrival_airport_city'];
6110
			$temp_array['airport_arrival_country'] = $row['arrival_airport_country'];
6111
          
6112
			$airport_array[] = $temp_array;
6113
		}
6114
6115
		return $airport_array;
6116
	}
6117
	
6118
	
6119
	/**
6120
	* Gets all arrival airports by country of the airplanes that have flown over based on an airport icao
6121
	*
6122
	* @return Array the airport list
6123
	*
6124
	*/
6125
	public function countAllArrivalAirportCountriesByAirport($airport_icao)
6126
	{
6127
		$airport_icao = filter_var($airport_icao,FILTER_SANITIZE_STRING);
6128
					
6129
		$query  = "SELECT DISTINCT spotter_output.arrival_airport_country, COUNT(spotter_output.arrival_airport_country) AS airport_arrival_country_count 
6130
								FROM spotter_output 
6131
                    WHERE spotter_output.arrival_airport_country <> '' AND spotter_output.departure_airport_icao = :airport_icao 
6132
                    GROUP BY spotter_output.arrival_airport_country
6133
					ORDER BY airport_arrival_country_count DESC";
6134
      
6135
		
6136
		$sth = $this->db->prepare($query);
6137
		$sth->execute(array(':airport_icao' => $airport_icao));
6138
      
6139
		$airport_array = array();
6140
		$temp_array = array();
6141
        
6142
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
6143
		{
6144
			$temp_array['arrival_airport_country'] = $row['arrival_airport_country'];
6145
			$temp_array['airport_arrival_country_count'] = $row['airport_arrival_country_count'];
6146
          
6147
			$airport_array[] = $temp_array;
6148
		}
6149
6150
		return $airport_array;
6151
	}
6152
	
6153
	
6154
	/**
6155
	* Gets all arrival airports of the airplanes that have flown over based on a aircraft manufacturer
6156
	*
6157
	* @return Array the airport list
6158
	*
6159
	*/
6160
	public function countAllArrivalAirportsByManufacturer($aircraft_manufacturer)
6161
	{
6162
		$aircraft_manufacturer = filter_var($aircraft_manufacturer,FILTER_SANITIZE_STRING);
6163
6164
		$query  = "SELECT DISTINCT spotter_output.arrival_airport_icao, COUNT(spotter_output.arrival_airport_icao) AS airport_arrival_icao_count, spotter_output.arrival_airport_name, spotter_output.arrival_airport_city, spotter_output.arrival_airport_country 
6165
								FROM spotter_output 
6166
                    WHERE spotter_output.arrival_airport_name <> '' AND spotter_output.arrival_airport_icao <> 'NA' AND spotter_output.aircraft_manufacturer = :aircraft_manufacturer 
6167
                    GROUP BY spotter_output.arrival_airport_icao
6168
					ORDER BY airport_arrival_icao_count DESC";
6169
      
6170
		
6171
		$sth = $this->db->prepare($query);
6172
		$sth->execute(array(':aircraft_manufacturer' => $aircraft_manufacturer));
6173
      
6174
		$airport_array = array();
6175
		$temp_array = array();
6176
        
6177
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
6178
		{
6179
			$temp_array['airport_arrival_icao'] = $row['arrival_airport_icao'];
6180
			$temp_array['airport_arrival_icao_count'] = $row['airport_arrival_icao_count'];
6181
			$temp_array['airport_arrival_name'] = $row['arrival_airport_name'];
6182
			$temp_array['airport_arrival_city'] = $row['arrival_airport_city'];
6183
			$temp_array['airport_arrival_country'] = $row['arrival_airport_country'];
6184
          
6185
			$airport_array[] = $temp_array;
6186
		}
6187
6188
		return $airport_array;
6189
	}
6190
	
6191
	
6192
	
6193
	/**
6194
	* Gets all arrival airports by country of the airplanes that have flown over based on a aircraft manufacturer
6195
	*
6196
	* @return Array the airport list
6197
	*
6198
	*/
6199
	public function countAllArrivalAirportCountriesByManufacturer($aircraft_manufacturer)
6200
	{
6201
		$aircraft_manufacturer = filter_var($aircraft_manufacturer,FILTER_SANITIZE_STRING);
6202
					
6203
		$query  = "SELECT DISTINCT spotter_output.arrival_airport_country, COUNT(spotter_output.arrival_airport_country) AS airport_arrival_country_count 
6204
								FROM spotter_output 
6205
                    WHERE spotter_output.arrival_airport_country <> '' AND spotter_output.aircraft_manufacturer = :aircraft_manufacturer 
6206
                    GROUP BY spotter_output.arrival_airport_country
6207
					ORDER BY airport_arrival_country_count DESC";
6208
      
6209
		
6210
		$sth = $this->db->prepare($query);
6211
		$sth->execute(array(':aircraft_manufacturer' => $aircraft_manufacturer));
6212
      
6213
		$airport_array = array();
6214
		$temp_array = array();
6215
        
6216
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
6217
		{
6218
			$temp_array['arrival_airport_country'] = $row['arrival_airport_country'];
6219
			$temp_array['airport_arrival_country_count'] = $row['airport_arrival_country_count'];
6220
          
6221
			$airport_array[] = $temp_array;
6222
		}
6223
6224
		return $airport_array;
6225
	}
6226
	
6227
	
6228
	
6229
	/**
6230
	* Gets all arrival airports of the airplanes that have flown over based on a date
6231
	*
6232
	* @return Array the airport list
6233
	*
6234
	*/
6235
	public function countAllArrivalAirportsByDate($date)
6236
	{
6237
		global $globalTimezone, $globalDBdriver;
6238
		$date = filter_var($date,FILTER_SANITIZE_STRING);
6239
		if ($globalTimezone != '') {
6240
			date_default_timezone_set($globalTimezone);
6241
			$datetime = new DateTime($date);
6242
			$offset = $datetime->format('P');
6243
		} else $offset = '+00:00';
6244
6245
		if ($globalDBdriver == 'mysql') {
6246
			$query  = "SELECT DISTINCT spotter_output.arrival_airport_icao, COUNT(spotter_output.arrival_airport_icao) AS airport_arrival_icao_count, spotter_output.arrival_airport_name, spotter_output.arrival_airport_city, spotter_output.arrival_airport_country 
6247
					FROM spotter_output 
6248
					WHERE spotter_output.arrival_airport_name <> '' AND spotter_output.arrival_airport_icao <> 'NA' AND DATE(CONVERT_TZ(spotter_output.date,'+00:00', :offset)) = :date  
6249
					GROUP BY spotter_output.arrival_airport_icao
6250
					ORDER BY airport_arrival_icao_count DESC";
6251
		} else {
6252
			$query  = "SELECT DISTINCT spotter_output.arrival_airport_icao, COUNT(spotter_output.arrival_airport_icao) AS airport_arrival_icao_count, spotter_output.arrival_airport_name, spotter_output.arrival_airport_city, spotter_output.arrival_airport_country 
6253
					FROM spotter_output 
6254
					WHERE spotter_output.arrival_airport_name <> '' AND spotter_output.arrival_airport_icao <> 'NA' AND to_char(spotter_output.date AT TIME ZONE INTERVAL :offset,'YYYY-mm-dd') = :date  
6255
					GROUP BY spotter_output.arrival_airport_icao
6256
					ORDER BY airport_arrival_icao_count DESC";
6257
		}
6258
		
6259
		$sth = $this->db->prepare($query);
6260
		$sth->execute(array(':date' => $date, ':offset' => $offset));
6261
      
6262
		$airport_array = array();
6263
		$temp_array = array();
6264
        
6265
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
6266
		{
6267
			$temp_array['airport_arrival_icao'] = $row['arrival_airport_icao'];
6268
			$temp_array['airport_arrival_icao_count'] = $row['airport_arrival_icao_count'];
6269
			$temp_array['airport_arrival_name'] = $row['arrival_airport_name'];
6270
			$temp_array['airport_arrival_city'] = $row['arrival_airport_city'];
6271
			$temp_array['airport_arrival_country'] = $row['arrival_airport_country'];
6272
          
6273
			$airport_array[] = $temp_array;
6274
		}
6275
		return $airport_array;
6276
	}
6277
	
6278
	
6279
	
6280
	/**
6281
	* Gets all arrival airports by country of the airplanes that have flown over based on a date
6282
	*
6283
	* @return Array the airport list
6284
	*
6285
	*/
6286
	public function countAllArrivalAirportCountriesByDate($date)
6287
	{
6288
		global $globalTimezone, $globalDBdriver;
6289
		$date = filter_var($date,FILTER_SANITIZE_STRING);
6290
		if ($globalTimezone != '') {
6291
			date_default_timezone_set($globalTimezone);
6292
			$datetime = new DateTime($date);
6293
			$offset = $datetime->format('P');
6294
		} else $offset = '+00:00';
6295
6296
		if ($globalDBdriver == 'mysql') {
6297
			$query  = "SELECT DISTINCT spotter_output.arrival_airport_country, COUNT(spotter_output.arrival_airport_country) AS airport_arrival_country_count 
6298
					FROM spotter_output 
6299
					WHERE spotter_output.arrival_airport_country <> '' AND DATE(CONVERT_TZ(spotter_output.date,'+00:00', :offset)) = :date 
6300
					GROUP BY spotter_output.arrival_airport_country
6301
					ORDER BY airport_arrival_country_count DESC";
6302
		} else {
6303
			$query  = "SELECT DISTINCT spotter_output.arrival_airport_country, COUNT(spotter_output.arrival_airport_country) AS airport_arrival_country_count 
6304
					FROM spotter_output 
6305
					WHERE spotter_output.arrival_airport_country <> '' AND to_char(spotter_output.date AT TIME ZONE INTERVAL :offset,'YYYY-mm-dd') = :date 
6306
					GROUP BY spotter_output.arrival_airport_country
6307
					ORDER BY airport_arrival_country_count DESC";
6308
		}
6309
		
6310
		$sth = $this->db->prepare($query);
6311
		$sth->execute(array(':date' => $date, ':offset' => $offset));
6312
      
6313
		$airport_array = array();
6314
		$temp_array = array();
6315
        
6316
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
6317
		{
6318
			$temp_array['arrival_airport_country'] = $row['arrival_airport_country'];
6319
			$temp_array['airport_arrival_country_count'] = $row['airport_arrival_country_count'];
6320
          
6321
			$airport_array[] = $temp_array;
6322
		}
6323
		return $airport_array;
6324
	}
6325
	
6326
	
6327
	
6328
	/**
6329
	* Gets all arrival airports of the airplanes that have flown over based on a ident/callsign
6330
	*
6331
	* @return Array the airport list
6332
	*
6333
	*/
6334
	public function countAllArrivalAirportsByIdent($ident)
6335
	{
6336
		$ident = filter_var($ident,FILTER_SANITIZE_STRING);
6337
6338
		$query  = "SELECT DISTINCT spotter_output.arrival_airport_icao, COUNT(spotter_output.arrival_airport_icao) AS airport_arrival_icao_count, spotter_output.arrival_airport_name, spotter_output.arrival_airport_city, spotter_output.arrival_airport_country 
6339
		    FROM spotter_output 
6340
                    WHERE spotter_output.arrival_airport_name <> '' AND spotter_output.arrival_airport_icao <> 'NA' AND spotter_output.ident = :ident  
6341
                    GROUP BY spotter_output.arrival_airport_icao, spotter_output.arrival_airport_name, spotter_output.arrival_airport_city, spotter_output.arrival_airport_country
6342
		    ORDER BY airport_arrival_icao_count DESC";
6343
      
6344
		
6345
		$sth = $this->db->prepare($query);
6346
		$sth->execute(array(':ident' => $ident));
6347
      
6348
		$airport_array = array();
6349
		$temp_array = array();
6350
        
6351
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
6352
		{
6353
			$temp_array['airport_arrival_icao'] = $row['arrival_airport_icao'];
6354
			$temp_array['airport_arrival_icao_count'] = $row['airport_arrival_icao_count'];
6355
			$temp_array['airport_arrival_name'] = $row['arrival_airport_name'];
6356
			$temp_array['airport_arrival_city'] = $row['arrival_airport_city'];
6357
			$temp_array['airport_arrival_country'] = $row['arrival_airport_country'];
6358
          
6359
			$airport_array[] = $temp_array;
6360
		}
6361
6362
		return $airport_array;
6363
	}
6364
	
6365
	
6366
	/**
6367
	* Gets all arrival airports by country of the airplanes that have flown over based on a callsign/ident
6368
	*
6369
	* @return Array the airport list
6370
	*
6371
	*/
6372
	public function countAllArrivalAirportCountriesByIdent($ident)
6373
	{
6374
		$ident = filter_var($ident,FILTER_SANITIZE_STRING);
6375
					
6376
		$query  = "SELECT DISTINCT spotter_output.arrival_airport_country, COUNT(spotter_output.arrival_airport_country) AS airport_arrival_country_count 
6377
								FROM spotter_output 
6378
                    WHERE spotter_output.arrival_airport_country <> '' AND spotter_output.ident = :ident 
6379
                    GROUP BY spotter_output.arrival_airport_country
6380
					ORDER BY airport_arrival_country_count DESC";
6381
      
6382
		
6383
		$sth = $this->db->prepare($query);
6384
		$sth->execute(array(':ident' => $ident));
6385
      
6386
		$airport_array = array();
6387
		$temp_array = array();
6388
        
6389
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
6390
		{
6391
			$temp_array['arrival_airport_country'] = $row['arrival_airport_country'];
6392
			$temp_array['airport_arrival_country_count'] = $row['airport_arrival_country_count'];
6393
          
6394
			$airport_array[] = $temp_array;
6395
		}
6396
6397
		return $airport_array;
6398
	}
6399
	
6400
	
6401
	
6402
	/**
6403
	* Gets all arrival airports of the airplanes that have flown over based on a country
6404
	*
6405
	* @return Array the airport list
6406
	*
6407
	*/
6408
	public function countAllArrivalAirportsByCountry($country)
6409
	{
6410
		$country = filter_var($country,FILTER_SANITIZE_STRING);
6411
6412
		$query  = "SELECT DISTINCT spotter_output.arrival_airport_icao, COUNT(spotter_output.arrival_airport_icao) AS airport_arrival_icao_count, spotter_output.arrival_airport_name, spotter_output.arrival_airport_city, spotter_output.arrival_airport_country 
6413
								FROM spotter_output 
6414
                    WHERE ((spotter_output.departure_airport_country = :country) OR (spotter_output.arrival_airport_country = :country)) OR spotter_output.airline_country = :country  
6415
                    GROUP BY spotter_output.arrival_airport_icao
6416
					ORDER BY airport_arrival_icao_count DESC";
6417
      
6418
		
6419
		$sth = $this->db->prepare($query);
6420
		$sth->execute(array(':country' => $country));
6421
      
6422
		$airport_array = array();
6423
		$temp_array = array();
6424
        
6425
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
6426
		{
6427
			$temp_array['airport_arrival_icao'] = $row['arrival_airport_icao'];
6428
			$temp_array['airport_arrival_icao_count'] = $row['airport_arrival_icao_count'];
6429
			$temp_array['airport_arrival_name'] = $row['arrival_airport_name'];
6430
			$temp_array['airport_arrival_city'] = $row['arrival_airport_city'];
6431
			$temp_array['airport_arrival_country'] = $row['arrival_airport_country'];
6432
          
6433
			$airport_array[] = $temp_array;
6434
		}
6435
6436
		return $airport_array;
6437
	}
6438
	
6439
	
6440
	/**
6441
	* Gets all arrival airports by country of the airplanes that have flown over based on a country
6442
	*
6443
	* @return Array the airport list
6444
	*
6445
	*/
6446
	public function countAllArrivalAirportCountriesByCountry($country)
6447
	{
6448
		$country = filter_var($country,FILTER_SANITIZE_STRING);
6449
					
6450
		$query  = "SELECT DISTINCT spotter_output.arrival_airport_country, COUNT(spotter_output.arrival_airport_country) AS airport_arrival_country_count 
6451
								FROM spotter_output 
6452
                    WHERE spotter_output.arrival_airport_country <> '' AND ((spotter_output.departure_airport_country = :country) OR (spotter_output.arrival_airport_country = :country)) OR spotter_output.airline_country = :country 
6453
                    GROUP BY spotter_output.arrival_airport_country
6454
					ORDER BY airport_arrival_country_count DESC";
6455
      
6456
		
6457
		$sth = $this->db->prepare($query);
6458
		$sth->execute(array(':country' => $country));
6459
      
6460
		$airport_array = array();
6461
		$temp_array = array();
6462
        
6463
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
6464
		{
6465
			$temp_array['arrival_airport_country'] = $row['arrival_airport_country'];
6466
			$temp_array['airport_arrival_country_count'] = $row['airport_arrival_country_count'];
6467
          
6468
			$airport_array[] = $temp_array;
6469
		}
6470
6471
		return $airport_array;
6472
	}
6473
6474
6475
6476
	/**
6477
	* Counts all airport departure countries
6478
	*
6479
	* @return Array the airport departure list
6480
	*
6481
	*/
6482
	public function countAllDepartureCountries()
6483
	{
6484
		$query  = "SELECT DISTINCT spotter_output.departure_airport_country, COUNT(spotter_output.departure_airport_country) AS airport_departure_country_count 
6485
								FROM spotter_output 
6486
                    WHERE spotter_output.departure_airport_country <> '' AND spotter_output.departure_airport_icao <> 'NA' 
6487
                    GROUP BY spotter_output.departure_airport_country
6488
					ORDER BY airport_departure_country_count DESC
6489
					LIMIT 10 OFFSET 0";
6490
      
6491
		
6492
		$sth = $this->db->prepare($query);
6493
		$sth->execute();
6494
      
6495
		$airport_array = array();
6496
		$temp_array = array();
6497
        
6498
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
6499
		{
6500
			$temp_array['airport_departure_country_count'] = $row['airport_departure_country_count'];
6501
			$temp_array['airport_departure_country'] = $row['departure_airport_country'];
6502
          
6503
			$airport_array[] = $temp_array;
6504
		}
6505
6506
		return $airport_array;
6507
	}
6508
	
6509
	
6510
	/**
6511
	* Counts all airport arrival countries
6512
	*
6513
	* @return Array the airport arrival list
6514
	*
6515
	*/
6516
	public function countAllArrivalCountries($limit = true)
6517
	{
6518
		$query  = "SELECT DISTINCT spotter_output.arrival_airport_country, COUNT(spotter_output.arrival_airport_country) AS airport_arrival_country_count 
6519
								FROM spotter_output 
6520
                    WHERE spotter_output.arrival_airport_country <> '' AND spotter_output.arrival_airport_icao <> 'NA' 
6521
                    GROUP BY spotter_output.arrival_airport_country
6522
					ORDER BY airport_arrival_country_count DESC";
6523
		if ($limit) $query .= " LIMIT 10 OFFSET 0";
6524
      
6525
		
6526
		$sth = $this->db->prepare($query);
6527
		$sth->execute();
6528
      
6529
		$airport_array = array();
6530
		$temp_array = array();
6531
        
6532
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
6533
		{
6534
			$temp_array['airport_arrival_country_count'] = $row['airport_arrival_country_count'];
6535
			$temp_array['airport_arrival_country'] = $row['arrival_airport_country'];
6536
          
6537
			$airport_array[] = $temp_array;
6538
		}
6539
6540
		return $airport_array;
6541
	}
6542
6543
6544
6545
6546
6547
	/**
6548
	* Gets all route combinations
6549
	*
6550
	* @return Array the route list
6551
	*
6552
	*/
6553
	public function countAllRoutes()
6554
	{
6555
		
6556
		$query  = "SELECT DISTINCT concat(spotter_output.departure_airport_icao, ' - ',  spotter_output.arrival_airport_icao) AS route, count(concat(spotter_output.departure_airport_icao, ' - ', spotter_output.arrival_airport_icao)) AS route_count, spotter_output.departure_airport_icao, spotter_output.departure_airport_name AS airport_departure_name, spotter_output.departure_airport_city AS airport_departure_city, spotter_output.departure_airport_country AS airport_departure_country, spotter_output.arrival_airport_icao, spotter_output.arrival_airport_name AS airport_arrival_name, spotter_output.arrival_airport_city AS airport_arrival_city, spotter_output.arrival_airport_country AS airport_arrival_country
6557
		    FROM spotter_output
6558
                    WHERE spotter_output.ident <> '' AND spotter_output.departure_airport_icao <> 'NA' AND spotter_output.arrival_airport_icao <> 'NA'
6559
                    GROUP BY route,spotter_output.departure_airport_icao, spotter_output.arrival_airport_icao,spotter_output.arrival_airport_name, spotter_output.arrival_airport_city, spotter_output.arrival_airport_country, spotter_output.departure_airport_name, spotter_output.departure_airport_city, spotter_output.departure_airport_country
6560
                    ORDER BY route_count DESC
6561
		    LIMIT 10 OFFSET 0";
6562
      
6563
		
6564
		$sth = $this->db->prepare($query);
6565
		$sth->execute();
6566
      
6567
		$routes_array = array();
6568
		$temp_array = array();
6569
        
6570
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
6571
		{
6572
			$temp_array['route_count'] = $row['route_count'];
6573
			$temp_array['airport_departure_icao'] = $row['departure_airport_icao'];
6574
			$temp_array['airport_departure_name'] = $row['airport_departure_name'];
6575
			$temp_array['airport_departure_city'] = $row['airport_departure_city'];
6576
			$temp_array['airport_departure_country'] = $row['airport_departure_country'];
6577
			$temp_array['airport_arrival_icao'] = $row['arrival_airport_icao'];
6578
			$temp_array['airport_arrival_name'] = $row['airport_arrival_name'];
6579
			$temp_array['airport_arrival_city'] = $row['airport_arrival_city'];
6580
			$temp_array['airport_arrival_country'] = $row['airport_arrival_country'];
6581
          
6582
			$routes_array[] = $temp_array;
6583
		}
6584
6585
		return $routes_array;
6586
	}
6587
	
6588
	
6589
	
6590
	
6591
	/**
6592
	* Gets all route combinations based on an aircraft
6593
	*
6594
	* @return Array the route list
6595
	*
6596
	*/
6597
	public function countAllRoutesByAircraft($aircraft_icao)
6598
	{
6599
		$aircraft_icao = filter_var($aircraft_icao,FILTER_SANITIZE_STRING);
6600
		
6601
		$query  = "SELECT DISTINCT concat(spotter_output.departure_airport_icao, ' - ',  spotter_output.arrival_airport_icao) AS route, count(concat(spotter_output.departure_airport_icao, ' - ', spotter_output.arrival_airport_icao)) AS route_count, spotter_output.departure_airport_icao, spotter_output.departure_airport_name AS airport_departure_name, spotter_output.departure_airport_city AS airport_departure_city, spotter_output.departure_airport_country AS airport_departure_country, spotter_output.arrival_airport_icao, spotter_output.arrival_airport_name AS airport_arrival_name, spotter_output.arrival_airport_city AS airport_arrival_city, spotter_output.arrival_airport_country AS airport_arrival_country
6602
								FROM spotter_output
6603
                    WHERE spotter_output.ident <> '' AND spotter_output.aircraft_icao = :aircraft_icao 
6604
                    GROUP BY route
6605
                    ORDER BY route_count DESC";
6606
      
6607
		
6608
		$sth = $this->db->prepare($query);
6609
		$sth->execute(array(':aircraft_icao' => $aircraft_icao));
6610
      
6611
		$routes_array = array();
6612
		$temp_array = array();
6613
        
6614
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
6615
		{
6616
			$temp_array['route_count'] = $row['route_count'];
6617
			$temp_array['airport_departure_icao'] = $row['departure_airport_icao'];
6618
			$temp_array['airport_departure_name'] = $row['airport_departure_name'];
6619
			$temp_array['airport_departure_city'] = $row['airport_departure_city'];
6620
			$temp_array['airport_departure_country'] = $row['airport_departure_country'];
6621
			$temp_array['airport_arrival_icao'] = $row['arrival_airport_icao'];
6622
			$temp_array['airport_arrival_name'] = $row['airport_arrival_name'];
6623
			$temp_array['airport_arrival_city'] = $row['airport_arrival_city'];
6624
			$temp_array['airport_arrival_country'] = $row['airport_arrival_country'];
6625
          
6626
			$routes_array[] = $temp_array;
6627
		}
6628
6629
		return $routes_array;
6630
	}
6631
	
6632
	
6633
	/**
6634
	* Gets all route combinations based on an aircraft registration
6635
	*
6636
	* @return Array the route list
6637
	*
6638
	*/
6639
	public function countAllRoutesByRegistration($registration)
6640
	{
6641
		$registration = filter_var($registration, FILTER_SANITIZE_STRING);
6642
		
6643
		$query  = "SELECT DISTINCT concat(spotter_output.departure_airport_icao, ' - ',  spotter_output.arrival_airport_icao) AS route, count(concat(spotter_output.departure_airport_icao, ' - ', spotter_output.arrival_airport_icao)) AS route_count, spotter_output.departure_airport_icao, spotter_output.departure_airport_name AS airport_departure_name, spotter_output.departure_airport_city AS airport_departure_city, spotter_output.departure_airport_country AS airport_departure_country, spotter_output.arrival_airport_icao, spotter_output.arrival_airport_name AS airport_arrival_name, spotter_output.arrival_airport_city AS airport_arrival_city, spotter_output.arrival_airport_country AS airport_arrival_country
6644
								FROM spotter_output
6645
                    WHERE spotter_output.ident <> '' AND spotter_output.registration = :registration 
6646
                    GROUP BY route
6647
                    ORDER BY route_count DESC";
6648
      
6649
		
6650
		$sth = $this->db->prepare($query);
6651
		$sth->execute(array(':registration' => $registration));
6652
      
6653
		$routes_array = array();
6654
		$temp_array = array();
6655
        
6656
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
6657
		{
6658
			$temp_array['route_count'] = $row['route_count'];
6659
			$temp_array['airport_departure_icao'] = $row['departure_airport_icao'];
6660
			$temp_array['airport_departure_name'] = $row['airport_departure_name'];
6661
			$temp_array['airport_departure_city'] = $row['airport_departure_city'];
6662
			$temp_array['airport_departure_country'] = $row['airport_departure_country'];
6663
			$temp_array['airport_arrival_icao'] = $row['arrival_airport_icao'];
6664
			$temp_array['airport_arrival_name'] = $row['airport_arrival_name'];
6665
			$temp_array['airport_arrival_city'] = $row['airport_arrival_city'];
6666
			$temp_array['airport_arrival_country'] = $row['airport_arrival_country'];
6667
          
6668
			$routes_array[] = $temp_array;
6669
		}
6670
6671
		return $routes_array;
6672
	}
6673
	
6674
	
6675
	
6676
	/**
6677
	* Gets all route combinations based on an airline
6678
	*
6679
	* @return Array the route list
6680
	*
6681
	*/
6682
	public function countAllRoutesByAirline($airline_icao)
6683
	{
6684
		$airline_icao = filter_var($airline_icao,FILTER_SANITIZE_STRING);
6685
		
6686
		$query  = "SELECT DISTINCT concat(spotter_output.departure_airport_icao, ' - ',  spotter_output.arrival_airport_icao) AS route, count(concat(spotter_output.departure_airport_icao, ' - ', spotter_output.arrival_airport_icao)) AS route_count, spotter_output.departure_airport_icao, spotter_output.departure_airport_name AS airport_departure_name, spotter_output.departure_airport_city AS airport_departure_city, spotter_output.departure_airport_country AS airport_departure_country, spotter_output.arrival_airport_icao, spotter_output.arrival_airport_name AS airport_arrival_name, spotter_output.arrival_airport_city AS airport_arrival_city, spotter_output.arrival_airport_country AS airport_arrival_country
6687
								FROM spotter_output
6688
                    WHERE spotter_output.ident <> '' AND spotter_output.airline_icao = :airline_icao 
6689
                    GROUP BY route
6690
                    ORDER BY route_count DESC";
6691
      
6692
		
6693
		$sth = $this->db->prepare($query);
6694
		$sth->execute(array(':airline_icao' => $airline_icao));
6695
      
6696
		$routes_array = array();
6697
		$temp_array = array();
6698
        
6699
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
6700
		{
6701
			$temp_array['route_count'] = $row['route_count'];
6702
			$temp_array['airport_departure_icao'] = $row['departure_airport_icao'];
6703
			$temp_array['airport_departure_name'] = $row['airport_departure_name'];
6704
			$temp_array['airport_departure_city'] = $row['airport_departure_city'];
6705
			$temp_array['airport_departure_country'] = $row['airport_departure_country'];
6706
			$temp_array['airport_arrival_icao'] = $row['arrival_airport_icao'];
6707
			$temp_array['airport_arrival_name'] = $row['airport_arrival_name'];
6708
			$temp_array['airport_arrival_city'] = $row['airport_arrival_city'];
6709
			$temp_array['airport_arrival_country'] = $row['airport_arrival_country'];
6710
          
6711
			$routes_array[] = $temp_array;
6712
		}
6713
6714
		return $routes_array;
6715
	}
6716
	
6717
	
6718
	
6719
	/**
6720
	* Gets all route combinations based on an airport
6721
	*
6722
	* @return Array the route list
6723
	*
6724
	*/
6725
	public function countAllRoutesByAirport($airport_icao)
6726
	{
6727
		$airport_icao = filter_var($airport_icao,FILTER_SANITIZE_STRING);
6728
		
6729
		$query  = "SELECT DISTINCT concat(spotter_output.departure_airport_icao, ' - ',  spotter_output.arrival_airport_icao) AS route, count(concat(spotter_output.departure_airport_icao, ' - ', spotter_output.arrival_airport_icao)) AS route_count, spotter_output.departure_airport_icao, spotter_output.departure_airport_name AS airport_departure_name, spotter_output.departure_airport_city AS airport_departure_city, spotter_output.departure_airport_country AS airport_departure_country, spotter_output.arrival_airport_icao, spotter_output.arrival_airport_name AS airport_arrival_name, spotter_output.arrival_airport_city AS airport_arrival_city, spotter_output.arrival_airport_country AS airport_arrival_country
6730
								FROM spotter_output
6731
                    WHERE spotter_output.ident <> '' AND (spotter_output.departure_airport_icao = :airport_icao OR spotter_output.arrival_airport_icao = :airport_icao)
6732
                    GROUP BY route
6733
                    ORDER BY route_count DESC";
6734
      
6735
		
6736
		$sth = $this->db->prepare($query);
6737
		$sth->execute(array(':airport_icao' => $airport_icao));
6738
      
6739
		$routes_array = array();
6740
		$temp_array = array();
6741
        
6742
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
6743
		{
6744
			$temp_array['route_count'] = $row['route_count'];
6745
			$temp_array['airport_departure_icao'] = $row['departure_airport_icao'];
6746
			$temp_array['airport_departure_name'] = $row['airport_departure_name'];
6747
			$temp_array['airport_departure_city'] = $row['airport_departure_city'];
6748
			$temp_array['airport_departure_country'] = $row['airport_departure_country'];
6749
			$temp_array['airport_arrival_icao'] = $row['arrival_airport_icao'];
6750
			$temp_array['airport_arrival_name'] = $row['airport_arrival_name'];
6751
			$temp_array['airport_arrival_city'] = $row['airport_arrival_city'];
6752
			$temp_array['airport_arrival_country'] = $row['airport_arrival_country'];
6753
          
6754
			$routes_array[] = $temp_array;
6755
		}
6756
6757
		return $routes_array;
6758
	}
6759
	
6760
	
6761
	
6762
	/**
6763
	* Gets all route combinations based on an country
6764
	*
6765
	* @return Array the route list
6766
	*
6767
	*/
6768
	public function countAllRoutesByCountry($country)
6769
	{
6770
		$country = filter_var($country,FILTER_SANITIZE_STRING);
6771
		
6772
		$query  = "SELECT DISTINCT concat(spotter_output.departure_airport_icao, ' - ',  spotter_output.arrival_airport_icao) AS route, count(concat(spotter_output.departure_airport_icao, ' - ', spotter_output.arrival_airport_icao)) AS route_count, spotter_output.departure_airport_icao, spotter_output.departure_airport_name AS airport_departure_name, spotter_output.departure_airport_city AS airport_departure_city, spotter_output.departure_airport_country AS airport_departure_country, spotter_output.arrival_airport_icao, spotter_output.arrival_airport_name AS airport_arrival_name, spotter_output.arrival_airport_city AS airport_arrival_city, spotter_output.arrival_airport_country AS airport_arrival_country
6773
								FROM spotter_output
6774
                    WHERE spotter_output.ident <> '' AND ((spotter_output.departure_airport_country = :country) OR (spotter_output.arrival_airport_country = :country)) OR spotter_output.airline_country = :country 
6775
                    GROUP BY route
6776
                    ORDER BY route_count DESC";
6777
      
6778
		
6779
		$sth = $this->db->prepare($query);
6780
		$sth->execute(array(':country' => $country));
6781
      
6782
		$routes_array = array();
6783
		$temp_array = array();
6784
        
6785
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
6786
		{
6787
			$temp_array['route_count'] = $row['route_count'];
6788
			$temp_array['airport_departure_icao'] = $row['departure_airport_icao'];
6789
			$temp_array['airport_departure_name'] = $row['airport_departure_name'];
6790
			$temp_array['airport_departure_city'] = $row['airport_departure_city'];
6791
			$temp_array['airport_departure_country'] = $row['airport_departure_country'];
6792
			$temp_array['airport_arrival_icao'] = $row['arrival_airport_icao'];
6793
			$temp_array['airport_arrival_name'] = $row['airport_arrival_name'];
6794
			$temp_array['airport_arrival_city'] = $row['airport_arrival_city'];
6795
			$temp_array['airport_arrival_country'] = $row['airport_arrival_country'];
6796
          
6797
			$routes_array[] = $temp_array;
6798
		}
6799
6800
		return $routes_array;
6801
	}
6802
6803
6804
	/**
6805
	* Gets all route combinations based on an date
6806
	*
6807
	* @return Array the route list
6808
	*
6809
	*/
6810
	public function countAllRoutesByDate($date)
6811
	{
6812
		global $globalTimezone, $globalDBdriver;
6813
		$date = filter_var($date,FILTER_SANITIZE_STRING);
6814
		if ($globalTimezone != '') {
6815
			date_default_timezone_set($globalTimezone);
6816
			$datetime = new DateTime($date);
6817
			$offset = $datetime->format('P');
6818
		} else $offset = '+00:00';
6819
		
6820
		if ($globalDBdriver == 'mysql') {
6821
			$query  = "SELECT DISTINCT concat(spotter_output.departure_airport_icao, ' - ',  spotter_output.arrival_airport_icao) AS route, count(concat(spotter_output.departure_airport_icao, ' - ', spotter_output.arrival_airport_icao)) AS route_count, spotter_output.departure_airport_icao, spotter_output.departure_airport_name AS airport_departure_name, spotter_output.departure_airport_city AS airport_departure_city, spotter_output.departure_airport_country AS airport_departure_country, spotter_output.arrival_airport_icao, spotter_output.arrival_airport_name AS airport_arrival_name, spotter_output.arrival_airport_city AS airport_arrival_city, spotter_output.arrival_airport_country AS airport_arrival_country
6822
					FROM spotter_output
6823
					WHERE spotter_output.ident <> '' AND DATE(CONVERT_TZ(spotter_output.date,'+00:00', :offset)) = :date  
6824
					GROUP BY route
6825
					ORDER BY route_count DESC";
6826
		} else {
6827
			$query  = "SELECT DISTINCT concat(spotter_output.departure_airport_icao, ' - ',  spotter_output.arrival_airport_icao) AS route, count(concat(spotter_output.departure_airport_icao, ' - ', spotter_output.arrival_airport_icao)) AS route_count, spotter_output.departure_airport_icao, spotter_output.departure_airport_name AS airport_departure_name, spotter_output.departure_airport_city AS airport_departure_city, spotter_output.departure_airport_country AS airport_departure_country, spotter_output.arrival_airport_icao, spotter_output.arrival_airport_name AS airport_arrival_name, spotter_output.arrival_airport_city AS airport_arrival_city, spotter_output.arrival_airport_country AS airport_arrival_country
6828
					FROM spotter_output
6829
					WHERE spotter_output.ident <> '' AND to_char(spotter_output.date AT TIME ZONE INTERVAL :offset,'YYYY-mm-dd') = :date  
6830
					GROUP BY route
6831
					ORDER BY route_count DESC";
6832
		}
6833
		
6834
		$sth = $this->db->prepare($query);
6835
		$sth->execute(array(':date' => $date, ':offset' => $offset));
6836
      
6837
		$routes_array = array();
6838
		$temp_array = array();
6839
        
6840
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
6841
		{
6842
			$temp_array['route_count'] = $row['route_count'];
6843
			$temp_array['airport_departure_icao'] = $row['departure_airport_icao'];
6844
			$temp_array['airport_departure_name'] = $row['airport_departure_name'];
6845
			$temp_array['airport_departure_city'] = $row['airport_departure_city'];
6846
			$temp_array['airport_departure_country'] = $row['airport_departure_country'];
6847
			$temp_array['airport_arrival_icao'] = $row['arrival_airport_icao'];
6848
			$temp_array['airport_arrival_name'] = $row['airport_arrival_name'];
6849
			$temp_array['airport_arrival_city'] = $row['airport_arrival_city'];
6850
			$temp_array['airport_arrival_country'] = $row['airport_arrival_country'];
6851
          
6852
			$routes_array[] = $temp_array;
6853
		}
6854
6855
		return $routes_array;
6856
	}
6857
	
6858
	
6859
	/**
6860
	* Gets all route combinations based on an ident/callsign
6861
	*
6862
	* @return Array the route list
6863
	*
6864
	*/
6865
	public function countAllRoutesByIdent($ident)
6866
	{
6867
		$ident = filter_var($ident,FILTER_SANITIZE_STRING);
6868
		
6869
		$query  = "SELECT DISTINCT concat(spotter_output.departure_airport_icao, ' - ',  spotter_output.arrival_airport_icao) AS route, count(concat(spotter_output.departure_airport_icao, ' - ', spotter_output.arrival_airport_icao)) AS route_count, spotter_output.departure_airport_icao, spotter_output.departure_airport_name AS airport_departure_name, spotter_output.departure_airport_city AS airport_departure_city, spotter_output.departure_airport_country AS airport_departure_country, spotter_output.arrival_airport_icao, spotter_output.arrival_airport_name AS airport_arrival_name, spotter_output.arrival_airport_city AS airport_arrival_city, spotter_output.arrival_airport_country AS airport_arrival_country
6870
		    FROM spotter_output
6871
                    WHERE spotter_output.ident <> '' AND spotter_output.ident = :ident   
6872
                    GROUP BY route, spotter_output.departure_airport_icao, spotter_output.departure_airport_name, spotter_output.departure_airport_city, spotter_output.departure_airport_country, spotter_output.arrival_airport_icao, spotter_output.arrival_airport_name, spotter_output.arrival_airport_city, spotter_output.arrival_airport_country
6873
                    ORDER BY route_count DESC";
6874
      
6875
		
6876
		$sth = $this->db->prepare($query);
6877
		$sth->execute(array(':ident' => $ident));
6878
      
6879
		$routes_array = array();
6880
		$temp_array = array();
6881
        
6882
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
6883
		{
6884
			$temp_array['route_count'] = $row['route_count'];
6885
			$temp_array['airport_departure_icao'] = $row['departure_airport_icao'];
6886
			$temp_array['airport_departure_name'] = $row['airport_departure_name'];
6887
			$temp_array['airport_departure_city'] = $row['airport_departure_city'];
6888
			$temp_array['airport_departure_country'] = $row['airport_departure_country'];
6889
			$temp_array['airport_arrival_icao'] = $row['arrival_airport_icao'];
6890
			$temp_array['airport_arrival_name'] = $row['airport_arrival_name'];
6891
			$temp_array['airport_arrival_city'] = $row['airport_arrival_city'];
6892
			$temp_array['airport_arrival_country'] = $row['airport_arrival_country'];
6893
          
6894
			$routes_array[] = $temp_array;
6895
		}
6896
6897
		return $routes_array;
6898
	}
6899
	
6900
	
6901
	/**
6902
	* Gets all route combinations based on an manufacturer
6903
	*
6904
	* @return Array the route list
6905
	*
6906
	*/
6907
	public function countAllRoutesByManufacturer($aircraft_manufacturer)
6908
	{
6909
		$aircraft_manufacturer = filter_var($aircraft_manufacturer,FILTER_SANITIZE_STRING);
6910
		
6911
		$query  = "SELECT DISTINCT concat(spotter_output.departure_airport_icao, ' - ',  spotter_output.arrival_airport_icao) AS route, count(concat(spotter_output.departure_airport_icao, ' - ', spotter_output.arrival_airport_icao)) AS route_count, spotter_output.departure_airport_icao, spotter_output.departure_airport_name AS airport_departure_name, spotter_output.departure_airport_city AS airport_departure_city, spotter_output.departure_airport_country AS airport_departure_country, spotter_output.arrival_airport_icao, spotter_output.arrival_airport_name AS airport_arrival_name, spotter_output.arrival_airport_city AS airport_arrival_city, spotter_output.arrival_airport_country AS airport_arrival_country
6912
		    FROM spotter_output
6913
                    WHERE spotter_output.ident <> '' AND spotter_output.aircraft_manufacturer = :aircraft_manufacturer   
6914
                    GROUP BY route
6915
                    ORDER BY route_count DESC";
6916
      
6917
		
6918
		$sth = $this->db->prepare($query);
6919
		$sth->execute(array(':aircraft_manufacturer' => $aircraft_manufacturer));
6920
      
6921
		$routes_array = array();
6922
		$temp_array = array();
6923
        
6924
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
6925
		{
6926
			$temp_array['route_count'] = $row['route_count'];
6927
			$temp_array['airport_departure_icao'] = $row['departure_airport_icao'];
6928
			$temp_array['airport_departure_name'] = $row['airport_departure_name'];
6929
			$temp_array['airport_departure_city'] = $row['airport_departure_city'];
6930
			$temp_array['airport_departure_country'] = $row['airport_departure_country'];
6931
			$temp_array['airport_arrival_icao'] = $row['arrival_airport_icao'];
6932
			$temp_array['airport_arrival_name'] = $row['airport_arrival_name'];
6933
			$temp_array['airport_arrival_city'] = $row['airport_arrival_city'];
6934
			$temp_array['airport_arrival_country'] = $row['airport_arrival_country'];
6935
          
6936
			$routes_array[] = $temp_array;
6937
		}
6938
6939
		return $routes_array;
6940
	}
6941
6942
	
6943
	
6944
	/**
6945
	* Gets all route combinations with waypoints
6946
	*
6947
	* @return Array the route list
6948
	*
6949
	*/
6950
	public function countAllRoutesWithWaypoints()
6951
	{
6952
		$query  = "SELECT DISTINCT spotter_output.waypoints AS route, count(spotter_output.waypoints) AS route_count, spotter_output.spotter_id, spotter_output.departure_airport_icao, spotter_output.departure_airport_name AS airport_departure_name, spotter_output.departure_airport_city AS airport_departure_city, spotter_output.departure_airport_country AS airport_departure_country, spotter_output.arrival_airport_icao, spotter_output.arrival_airport_name AS airport_arrival_name, spotter_output.arrival_airport_city AS airport_arrival_city, spotter_output.arrival_airport_country AS airport_arrival_country
6953
		    FROM spotter_output
6954
                    WHERE spotter_output.ident <> '' AND spotter_output.waypoints <> '' 
6955
                    GROUP BY route, spotter_output.spotter_id, spotter_output.departure_airport_icao, spotter_output.departure_airport_name, spotter_output.departure_airport_city, spotter_output.departure_airport_country, spotter_output.arrival_airport_icao, spotter_output.arrival_airport_name, spotter_output.arrival_airport_city, spotter_output.arrival_airport_country
6956
                    ORDER BY route_count DESC
6957
		    LIMIT 10 OFFSET 0";
6958
      
6959
		
6960
		$sth = $this->db->prepare($query);
6961
		$sth->execute();
6962
      
6963
		$routes_array = array();
6964
		$temp_array = array();
6965
        
6966
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
6967
		{
6968
			$temp_array['spotter_id'] = $row['spotter_id'];
6969
			$temp_array['route_count'] = $row['route_count'];
6970
			$temp_array['airport_departure_icao'] = $row['departure_airport_icao'];
6971
			$temp_array['airport_departure_name'] = $row['airport_departure_name'];
6972
			$temp_array['airport_departure_city'] = $row['airport_departure_city'];
6973
			$temp_array['airport_departure_country'] = $row['airport_departure_country'];
6974
			$temp_array['airport_arrival_icao'] = $row['arrival_airport_icao'];
6975
			$temp_array['airport_arrival_name'] = $row['airport_arrival_name'];
6976
			$temp_array['airport_arrival_city'] = $row['airport_arrival_city'];
6977
			$temp_array['airport_arrival_country'] = $row['airport_arrival_country'];
6978
          
6979
			$routes_array[] = $temp_array;
6980
		}
6981
6982
		return $routes_array;
6983
	}
6984
	
6985
	
6986
	
6987
	
6988
	/**
6989
	* Gets all callsigns that have flown over
6990
	*
6991
	* @return Array the callsign list
6992
	*
6993
	*/
6994
	public function countAllCallsigns($limit = true, $olderthanmonths = 0, $sincedate = '')
6995
	{
6996
		global $globalDBdriver;
6997
		$query  = "SELECT DISTINCT spotter_output.ident, COUNT(spotter_output.ident) AS callsign_icao_count, spotter_output.airline_name, spotter_output.airline_icao  
6998
                    FROM spotter_output
6999
                    WHERE spotter_output.ident <> ''  ";
7000
		 if ($olderthanmonths > 0) {
7001
			if ($globalDBdriver == 'mysql') $query .= 'AND date < DATE_SUB(UTC_TIMESTAMP(),INTERVAL '.$olderthanmonths.' MONTH) ';
7002
			else $query .= "AND spotter_output.date < CURRENT_TIMESTAMP AT TIME ZONE 'UTC' - INTERVAL '".$olderthanmonths." MONTHS' ";
7003
		}
7004
		if ($sincedate != '') {
7005
			if ($globalDBdriver == 'mysql') $query .= "AND spotter_output.date > '".$sincedate."' ";
7006
			else $query .= "AND spotter_output.date > CAST('".$sincedate."' AS TIMESTAMP) ";
7007
		}
7008
		$query .= "GROUP BY spotter_output.ident, spotter_output.airline_name, spotter_output.airline_icao ORDER BY callsign_icao_count DESC";
7009
		if ($limit) $query .= " LIMIT 10 OFFSET 0";
7010
      		
7011
		$sth = $this->db->prepare($query);
7012
		$sth->execute();
7013
      
7014
		$callsign_array = array();
7015
		$temp_array = array();
7016
        
7017
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
7018
		{
7019
			$temp_array['callsign_icao'] = $row['ident'];
7020
			$temp_array['airline_name'] = $row['airline_name'];
7021
			$temp_array['airline_icao'] = $row['airline_icao'];
7022
			$temp_array['callsign_icao_count'] = $row['callsign_icao_count'];
7023
          
7024
			$callsign_array[] = $temp_array;
7025
		}
7026
7027
		return $callsign_array;
7028
	}
7029
7030
7031
7032
7033
	/**
7034
	* Counts all dates
7035
	*
7036
	* @return Array the date list
7037
	*
7038
	*/
7039
	public function countAllDates()
7040
	{
7041
		global $globalTimezone, $globalDBdriver;
7042
		if ($globalTimezone != '') {
7043
			date_default_timezone_set($globalTimezone);
7044
			$datetime = new DateTime();
7045
			$offset = $datetime->format('P');
7046
		} else $offset = '+00:00';
7047
7048
		if ($globalDBdriver == 'mysql') {
7049
			$query  = "SELECT DATE(CONVERT_TZ(spotter_output.date,'+00:00', :offset)) AS date_name, count(*) as date_count
7050
								FROM spotter_output 
7051
								GROUP BY date_name 
7052
								ORDER BY date_count DESC
7053
								LIMIT 10 OFFSET 0";
7054
		} else {
7055
			$query  = "SELECT to_char(spotter_output.date AT TIME ZONE INTERVAL :offset,'YYYY-mm-dd') AS date_name, count(*) as date_count
7056
								FROM spotter_output 
7057
								GROUP BY date_name 
7058
								ORDER BY date_count DESC
7059
								LIMIT 10 OFFSET 0";
7060
		}
7061
      
7062
		
7063
		$sth = $this->db->prepare($query);
7064
		$sth->execute(array(':offset' => $offset));
7065
      
7066
		$date_array = array();
7067
		$temp_array = array();
7068
        
7069
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
7070
		{
7071
			$temp_array['date_name'] = $row['date_name'];
7072
			$temp_array['date_count'] = $row['date_count'];
7073
7074
			$date_array[] = $temp_array;
7075
		}
7076
7077
		return $date_array;
7078
	}
7079
	
7080
	
7081
	
7082
	/**
7083
	* Counts all dates during the last 7 days
7084
	*
7085
	* @return Array the date list
7086
	*
7087
	*/
7088
	public function countAllDatesLast7Days()
7089
	{
7090
		global $globalTimezone, $globalDBdriver;
7091
		if ($globalTimezone != '') {
7092
			date_default_timezone_set($globalTimezone);
7093
			$datetime = new DateTime();
7094
			$offset = $datetime->format('P');
7095
		} else $offset = '+00:00';
7096
		
7097
		if ($globalDBdriver == 'mysql') {
7098
			$query  = "SELECT DATE(CONVERT_TZ(spotter_output.date,'+00:00', :offset)) AS date_name, count(*) as date_count
7099
								FROM spotter_output 
7100
								WHERE spotter_output.date >= DATE_SUB(UTC_TIMESTAMP(),INTERVAL 7 DAY)
7101
								GROUP BY date_name 
7102
								ORDER BY spotter_output.date ASC";
7103
			$query_data = array(':offset' => $offset);
7104
		} else {
7105
			$query  = "SELECT to_char(spotter_output.date AT TIME ZONE INTERVAL :offset,'YYYY-mm-dd') AS date_name, count(*) as date_count
7106
								FROM spotter_output 
7107
								WHERE spotter_output.date >= CURRENT_TIMESTAMP AT TIME ZONE INTERVAL :offset - INTERVAL '7 DAYS'
7108
								GROUP BY date_name 
7109
								ORDER BY date_name ASC";
7110
			$query_data = array(':offset' => $offset);
7111
    		}
7112
		
7113
		$sth = $this->db->prepare($query);
7114
		$sth->execute($query_data);
7115
      
7116
		$date_array = array();
7117
		$temp_array = array();
7118
        
7119
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
7120
		{
7121
			$temp_array['date_name'] = $row['date_name'];
7122
			$temp_array['date_count'] = $row['date_count'];
7123
          
7124
			$date_array[] = $temp_array;
7125
		}
7126
7127
		return $date_array;
7128
	}
7129
7130
	/**
7131
	* Counts all dates during the last month
7132
	*
7133
	* @return Array the date list
7134
	*
7135
	*/
7136
	public function countAllDatesLastMonth()
7137
	{
7138
		global $globalTimezone, $globalDBdriver;
7139
		if ($globalTimezone != '') {
7140
			date_default_timezone_set($globalTimezone);
7141
			$datetime = new DateTime();
7142
			$offset = $datetime->format('P');
7143
		} else $offset = '+00:00';
7144
		
7145
		if ($globalDBdriver == 'mysql') {
7146
			$query  = "SELECT DATE(CONVERT_TZ(spotter_output.date,'+00:00', :offset)) AS date_name, count(*) as date_count
7147
								FROM spotter_output 
7148
								WHERE spotter_output.date >= DATE_SUB(UTC_TIMESTAMP(),INTERVAL 1 MONTH)
7149
								GROUP BY date_name 
7150
								ORDER BY spotter_output.date ASC";
7151
			$query_data = array(':offset' => $offset);
7152
		} else {
7153
			$query  = "SELECT to_char(spotter_output.date AT TIME ZONE INTERVAL :offset,'YYYY-mm-dd') AS date_name, count(*) as date_count
7154
								FROM spotter_output 
7155
								WHERE spotter_output.date >= CURRENT_TIMESTAMP AT TIME ZONE INTERVAL :offset - INTERVAL '1 MONTHS'
7156
								GROUP BY date_name 
7157
								ORDER BY date_name ASC";
7158
			$query_data = array(':offset' => $offset);
7159
    		}
7160
		
7161
		$sth = $this->db->prepare($query);
7162
		$sth->execute($query_data);
7163
      
7164
		$date_array = array();
7165
		$temp_array = array();
7166
        
7167
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
7168
		{
7169
			$temp_array['date_name'] = $row['date_name'];
7170
			$temp_array['date_count'] = $row['date_count'];
7171
          
7172
			$date_array[] = $temp_array;
7173
		}
7174
7175
		return $date_array;
7176
	}
7177
	
7178
	/**
7179
	* Counts all month
7180
	*
7181
	* @return Array the month list
7182
	*
7183
	*/
7184
	public function countAllMonths()
7185
	{
7186
		global $globalTimezone, $globalDBdriver;
7187
		if ($globalTimezone != '') {
7188
			date_default_timezone_set($globalTimezone);
7189
			$datetime = new DateTime();
7190
			$offset = $datetime->format('P');
7191
		} else $offset = '+00:00';
7192
7193
		if ($globalDBdriver == 'mysql') {
7194
			$query  = "SELECT YEAR(CONVERT_TZ(spotter_output.date,'+00:00', :offset)) AS year_name,MONTH(CONVERT_TZ(spotter_output.date,'+00:00', :offset)) AS month_name, count(*) as date_count
7195
								FROM spotter_output 
7196
								GROUP BY year_name, month_name 
7197
								ORDER BY date_count DESC";
7198
		} else {
7199
			$query  = "SELECT EXTRACT(YEAR FROM spotter_output.date AT TIME ZONE INTERVAL :offset) AS year_name,EXTRACT(MONTH FROM spotter_output.date AT TIME ZONE INTERVAL :offset) AS month_name, count(*) as date_count
7200
								FROM spotter_output 
7201
								GROUP BY year_name, month_name 
7202
								ORDER BY date_count DESC";
7203
		}
7204
      
7205
		
7206
		$sth = $this->db->prepare($query);
7207
		$sth->execute(array(':offset' => $offset));
7208
      
7209
		$date_array = array();
7210
		$temp_array = array();
7211
        
7212
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
7213
		{
7214
			$temp_array['month_name'] = $row['month_name'];
7215
			$temp_array['year_name'] = $row['year_name'];
7216
			$temp_array['date_count'] = $row['date_count'];
7217
7218
			$date_array[] = $temp_array;
7219
		}
7220
7221
		return $date_array;
7222
	}
7223
7224
	/**
7225
	* Counts all military month
7226
	*
7227
	* @return Array the month list
7228
	*
7229
	*/
7230
	public function countAllMilitaryMonths()
7231
	{
7232
		global $globalTimezone, $globalDBdriver;
7233
		if ($globalTimezone != '') {
7234
			date_default_timezone_set($globalTimezone);
7235
			$datetime = new DateTime();
7236
			$offset = $datetime->format('P');
7237
		} else $offset = '+00:00';
7238
7239
		if ($globalDBdriver == 'mysql') {
7240
			$query  = "SELECT YEAR(CONVERT_TZ(s.date,'+00:00', :offset)) AS year_name,MONTH(CONVERT_TZ(s.date,'+00:00', :offset)) AS month_name, count(*) as date_count
7241
								FROM spotter_output s
7242
								WHERE s.airline_type = 'military'
7243
								GROUP BY year_name, month_name 
7244
								ORDER BY date_count DESC";
7245
		} else {
7246
			$query  = "SELECT EXTRACT(YEAR FROM s.date AT TIME ZONE INTERVAL :offset) AS year_name,EXTRACT(MONTH FROM s.date AT TIME ZONE INTERVAL :offset) AS month_name, count(*) as date_count
7247
								FROM spotter_output s
7248
								WHERE s.airline_type = 'military'
7249
								GROUP BY year_name, month_name 
7250
								ORDER BY date_count DESC";
7251
		}
7252
		
7253
		$sth = $this->db->prepare($query);
7254
		$sth->execute(array(':offset' => $offset));
7255
      
7256
		$date_array = array();
7257
		$temp_array = array();
7258
        
7259
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
7260
		{
7261
			$temp_array['month_name'] = $row['month_name'];
7262
			$temp_array['year_name'] = $row['year_name'];
7263
			$temp_array['date_count'] = $row['date_count'];
7264
7265
			$date_array[] = $temp_array;
7266
		}
7267
7268
		return $date_array;
7269
	}
7270
	
7271
	/**
7272
	* Counts all month owners
7273
	*
7274
	* @return Array the month list
7275
	*
7276
	*/
7277
	public function countAllMonthsOwners()
7278
	{
7279
		global $globalTimezone, $globalDBdriver;
7280
		if ($globalTimezone != '') {
7281
			date_default_timezone_set($globalTimezone);
7282
			$datetime = new DateTime();
7283
			$offset = $datetime->format('P');
7284
		} else $offset = '+00:00';
7285
7286
		if ($globalDBdriver == 'mysql') {
7287
			$query  = "SELECT YEAR(CONVERT_TZ(spotter_output.date,'+00:00', :offset)) AS year_name,MONTH(CONVERT_TZ(spotter_output.date,'+00:00', :offset)) AS month_name, count(distinct owner_name) as date_count
7288
								FROM spotter_output 
7289
								WHERE owner_name <> ''
7290
								GROUP BY year_name, month_name
7291
								ORDER BY date_count DESC";
7292
		} else {
7293
			$query  = "SELECT EXTRACT(YEAR FROM spotter_output.date AT TIME ZONE INTERVAL :offset) AS year_name,EXTRACT(MONTH FROM spotter_output.date AT TIME ZONE INTERVAL :offset) AS month_name, count(distinct owner_name) as date_count
7294
								FROM spotter_output 
7295
								WHERE owner_name <> ''
7296
								GROUP BY year_name, month_name
7297
								ORDER BY date_count DESC";
7298
		}
7299
		
7300
		$sth = $this->db->prepare($query);
7301
		$sth->execute(array(':offset' => $offset));
7302
      
7303
		$date_array = array();
7304
		$temp_array = array();
7305
        
7306
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
7307
		{
7308
			$temp_array['month_name'] = $row['month_name'];
7309
			$temp_array['year_name'] = $row['year_name'];
7310
			$temp_array['date_count'] = $row['date_count'];
7311
7312
			$date_array[] = $temp_array;
7313
		}
7314
7315
		return $date_array;
7316
	}
7317
7318
	/**
7319
	* Counts all month pilot
7320
	*
7321
	* @return Array the month list
7322
	*
7323
	*/
7324
	public function countAllMonthsPilots()
7325
	{
7326
		global $globalTimezone, $globalDBdriver;
7327
		if ($globalTimezone != '') {
7328
			date_default_timezone_set($globalTimezone);
7329
			$datetime = new DateTime();
7330
			$offset = $datetime->format('P');
7331
		} else $offset = '+00:00';
7332
7333
		if ($globalDBdriver == 'mysql') {
7334
			$query  = "SELECT YEAR(CONVERT_TZ(spotter_output.date,'+00:00', :offset)) AS year_name,MONTH(CONVERT_TZ(spotter_output.date,'+00:00', :offset)) AS month_name, count(distinct pilot_id) as date_count
7335
								FROM spotter_output 
7336
								WHERE pilot_id <> '' AND pilot_id IS NOT NULL
7337
								GROUP BY year_name, month_name
7338
								ORDER BY date_count DESC";
7339
		} else {
7340
			$query  = "SELECT EXTRACT(YEAR FROM spotter_output.date AT TIME ZONE INTERVAL :offset) AS year_name,EXTRACT(MONTH FROM spotter_output.date AT TIME ZONE INTERVAL :offset) AS month_name, count(distinct pilot_id) as date_count
7341
								FROM spotter_output 
7342
								WHERE pilot_id <> '' AND pilot_id IS NOT NULL
7343
								GROUP BY year_name, month_name
7344
								ORDER BY date_count DESC";
7345
		}
7346
		
7347
		$sth = $this->db->prepare($query);
7348
		$sth->execute(array(':offset' => $offset));
7349
      
7350
		$date_array = array();
7351
		$temp_array = array();
7352
        
7353
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
7354
		{
7355
			$temp_array['month_name'] = $row['month_name'];
7356
			$temp_array['year_name'] = $row['year_name'];
7357
			$temp_array['date_count'] = $row['date_count'];
7358
7359
			$date_array[] = $temp_array;
7360
		}
7361
7362
		return $date_array;
7363
	}
7364
	
7365
7366
	/**
7367
	* Counts all month airline
7368
	*
7369
	* @return Array the month list
7370
	*
7371
	*/
7372
	public function countAllMonthsAirlines()
7373
	{
7374
		global $globalTimezone, $globalDBdriver;
7375
		if ($globalTimezone != '') {
7376
			date_default_timezone_set($globalTimezone);
7377
			$datetime = new DateTime();
7378
			$offset = $datetime->format('P');
7379
		} else $offset = '+00:00';
7380
7381
		if ($globalDBdriver == 'mysql') {
7382
			$query  = "SELECT YEAR(CONVERT_TZ(spotter_output.date,'+00:00', :offset)) AS year_name,MONTH(CONVERT_TZ(spotter_output.date,'+00:00', :offset)) AS month_name, count(distinct airline_icao) as date_count
7383
								FROM spotter_output 
7384
								WHERE airline_icao <> '' 
7385
								GROUP BY year_name, month_name
7386
								ORDER BY date_count DESC";
7387
		} else {
7388
			$query  = "SELECT EXTRACT(YEAR FROM spotter_output.date AT TIME ZONE INTERVAL :offset) AS year_name,EXTRACT(MONTH FROM spotter_output.date AT TIME ZONE INTERVAL :offset) AS month_name, count(distinct airline_icao) as date_count
7389
								FROM spotter_output 
7390
								WHERE airline_icao <> '' 
7391
								GROUP BY year_name, month_name
7392
								ORDER BY date_count DESC";
7393
		}
7394
		
7395
		$sth = $this->db->prepare($query);
7396
		$sth->execute(array(':offset' => $offset));
7397
      
7398
		$date_array = array();
7399
		$temp_array = array();
7400
        
7401
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
7402
		{
7403
			$temp_array['month_name'] = $row['month_name'];
7404
			$temp_array['year_name'] = $row['year_name'];
7405
			$temp_array['date_count'] = $row['date_count'];
7406
7407
			$date_array[] = $temp_array;
7408
		}
7409
7410
		return $date_array;
7411
	}
7412
	
7413
	/**
7414
	* Counts all month aircraft
7415
	*
7416
	* @return Array the month list
7417
	*
7418
	*/
7419
	public function countAllMonthsAircrafts()
7420
	{
7421
		global $globalTimezone, $globalDBdriver;
7422
		if ($globalTimezone != '') {
7423
			date_default_timezone_set($globalTimezone);
7424
			$datetime = new DateTime();
7425
			$offset = $datetime->format('P');
7426
		} else $offset = '+00:00';
7427
7428
		if ($globalDBdriver == 'mysql') {
7429
			$query  = "SELECT YEAR(CONVERT_TZ(spotter_output.date,'+00:00', :offset)) AS year_name,MONTH(CONVERT_TZ(spotter_output.date,'+00:00', :offset)) AS month_name, count(distinct aircraft_icao) as date_count
7430
								FROM spotter_output 
7431
								WHERE aircraft_icao <> '' 
7432
								GROUP BY year_name, month_name
7433
								ORDER BY date_count DESC";
7434
		} else {
7435
			$query  = "SELECT EXTRACT(YEAR FROM spotter_output.date AT TIME ZONE INTERVAL :offset) AS year_name,EXTRACT(MONTH FROM spotter_output.date AT TIME ZONE INTERVAL :offset) AS month_name, count(distinct aircraft_icao) as date_count
7436
								FROM spotter_output 
7437
								WHERE aircraft_icao <> '' 
7438
								GROUP BY year_name, month_name
7439
								ORDER BY date_count DESC";
7440
		}
7441
		
7442
		$sth = $this->db->prepare($query);
7443
		$sth->execute(array(':offset' => $offset));
7444
      
7445
		$date_array = array();
7446
		$temp_array = array();
7447
        
7448
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
7449
		{
7450
			$temp_array['month_name'] = $row['month_name'];
7451
			$temp_array['year_name'] = $row['year_name'];
7452
			$temp_array['date_count'] = $row['date_count'];
7453
7454
			$date_array[] = $temp_array;
7455
		}
7456
7457
		return $date_array;
7458
	}
7459
	
7460
7461
	/**
7462
	* Counts all month real arrival
7463
	*
7464
	* @return Array the month list
7465
	*
7466
	*/
7467
	public function countAllMonthsRealArrivals()
7468
	{
7469
		global $globalTimezone, $globalDBdriver;
7470
		if ($globalTimezone != '') {
7471
			date_default_timezone_set($globalTimezone);
7472
			$datetime = new DateTime();
7473
			$offset = $datetime->format('P');
7474
		} else $offset = '+00:00';
7475
7476
		if ($globalDBdriver == 'mysql') {
7477
			$query  = "SELECT YEAR(CONVERT_TZ(spotter_output.date,'+00:00', :offset)) AS year_name,MONTH(CONVERT_TZ(spotter_output.date,'+00:00', :offset)) AS month_name, count(real_arrival_airport_icao) as date_count
7478
								FROM spotter_output 
7479
								WHERE real_arrival_airport_icao <> '' 
7480
								GROUP BY year_name, month_name
7481
								ORDER BY date_count DESC";
7482
		} else {
7483
			$query  = "SELECT EXTRACT(YEAR FROM spotter_output.date AT TIME ZONE INTERVAL :offset) AS year_name,EXTRACT(MONTH FROM spotter_output.date AT TIME ZONE INTERVAL :offset) AS month_name, count(real_arrival_airport_icao) as date_count
7484
								FROM spotter_output 
7485
								WHERE real_arrival_airport_icao <> '' 
7486
								GROUP BY year_name, month_name
7487
								ORDER BY date_count DESC";
7488
		}
7489
		
7490
		$sth = $this->db->prepare($query);
7491
		$sth->execute(array(':offset' => $offset));
7492
      
7493
		$date_array = array();
7494
		$temp_array = array();
7495
        
7496
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
7497
		{
7498
			$temp_array['month_name'] = $row['month_name'];
7499
			$temp_array['year_name'] = $row['year_name'];
7500
			$temp_array['date_count'] = $row['date_count'];
7501
7502
			$date_array[] = $temp_array;
7503
		}
7504
7505
		return $date_array;
7506
	}
7507
	
7508
7509
7510
	/**
7511
	* Counts all dates during the last year
7512
	*
7513
	* @return Array the date list
7514
	*
7515
	*/
7516
	public function countAllMonthsLastYear()
7517
	{
7518
		global $globalTimezone, $globalDBdriver;
7519
		if ($globalTimezone != '') {
7520
			date_default_timezone_set($globalTimezone);
7521
			$datetime = new DateTime();
7522
			$offset = $datetime->format('P');
7523
		} else $offset = '+00:00';
7524
		
7525
		if ($globalDBdriver == 'mysql') {
7526
			$query  = "SELECT MONTH(CONVERT_TZ(spotter_output.date,'+00:00', :offset)) AS month_name, YEAR(CONVERT_TZ(spotter_output.date,'+00:00', :offset)) AS year_name, count(*) as date_count
7527
								FROM spotter_output 
7528
								WHERE spotter_output.date >= DATE_SUB(UTC_TIMESTAMP(),INTERVAL 1 YEAR)
7529
								GROUP BY year_name, month_name
7530
								ORDER BY year_name, month_name ASC";
7531
			$query_data = array(':offset' => $offset);
7532
		} else {
7533
			$query  = "SELECT EXTRACT(MONTH FROM spotter_output.date AT TIME ZONE INTERVAL :offset) AS month_name, EXTRACT(YEAR FROM spotter_output.date AT TIME ZONE INTERVAL :offset) AS year_name, count(*) as date_count
7534
								FROM spotter_output 
7535
								WHERE spotter_output.date >= CURRENT_TIMESTAMP AT TIME ZONE INTERVAL :offset - INTERVAL '1 YEARS'
7536
								GROUP BY year_name, month_name
7537
								ORDER BY year_name, month_name ASC";
7538
			$query_data = array(':offset' => $offset);
7539
    		}
7540
		
7541
		$sth = $this->db->prepare($query);
7542
		$sth->execute($query_data);
7543
      
7544
		$date_array = array();
7545
		$temp_array = array();
7546
        
7547
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
7548
		{
7549
			$temp_array['year_name'] = $row['year_name'];
7550
			$temp_array['month_name'] = $row['month_name'];
7551
			$temp_array['date_count'] = $row['date_count'];
7552
          
7553
			$date_array[] = $temp_array;
7554
		}
7555
7556
		return $date_array;
7557
	}
7558
	
7559
	
7560
	
7561
	/**
7562
	* Counts all hours
7563
	*
7564
	* @return Array the hour list
7565
	*
7566
	*/
7567
	public function countAllHours($orderby)
7568
	{
7569
		global $globalTimezone, $globalDBdriver;
7570
		if ($globalTimezone != '') {
7571
			date_default_timezone_set($globalTimezone);
7572
			$datetime = new DateTime();
7573
			$offset = $datetime->format('P');
7574
		} else $offset = '+00:00';
7575
7576
		$orderby_sql = '';
7577
		if ($orderby == "hour")
7578
		{
7579
			$orderby_sql = "ORDER BY hour_name ASC";
7580
		}
7581
		if ($orderby == "count")
7582
		{
7583
			$orderby_sql = "ORDER BY hour_count DESC";
7584
		}
7585
		
7586
		if ($globalDBdriver == 'mysql') {
7587
			$query  = "SELECT HOUR(CONVERT_TZ(spotter_output.date,'+00:00', :offset)) AS hour_name, count(*) as hour_count
7588
								FROM spotter_output 
7589
								GROUP BY hour_name 
7590
								".$orderby_sql;
7591
7592
/*		$query  = "SELECT HOUR(spotter_output.date) AS hour_name, count(*) as hour_count
7593
								FROM spotter_output 
7594
								GROUP BY hour_name 
7595
								".$orderby_sql."
7596
								LIMIT 10 OFFSET 00";
7597
  */    
7598
		$query_data = array(':offset' => $offset);
7599
		} else {
7600
			$query  = "SELECT EXTRACT(HOUR FROM spotter_output.date AT TIME ZONE INTERVAL :offset) AS hour_name, count(*) as hour_count
7601
								FROM spotter_output 
7602
								GROUP BY hour_name 
7603
								".$orderby_sql;
7604
			$query_data = array(':offset' => $offset);
7605
		}
7606
		
7607
		$sth = $this->db->prepare($query);
7608
		$sth->execute($query_data);
7609
      
7610
		$hour_array = array();
7611
		$temp_array = array();
7612
        
7613
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
7614
		{
7615
			$temp_array['hour_name'] = $row['hour_name'];
7616
			$temp_array['hour_count'] = $row['hour_count'];
7617
          
7618
			$hour_array[] = $temp_array;
7619
		}
7620
7621
		return $hour_array;
7622
	}
7623
	
7624
	
7625
	/**
7626
	* Counts all hours by airline
7627
	*
7628
	* @return Array the hour list
7629
	*
7630
	*/
7631
	public function countAllHoursByAirline($airline_icao)
7632
	{
7633
		global $globalTimezone, $globalDBdriver;
7634
		if ($globalTimezone != '') {
7635
			date_default_timezone_set($globalTimezone);
7636
			$datetime = new DateTime();
7637
			$offset = $datetime->format('P');
7638
		} else $offset = '+00:00';
7639
7640
		$airline_icao = filter_var($airline_icao,FILTER_SANITIZE_STRING);
7641
7642
		if ($globalDBdriver == 'mysql') {
7643
			$query  = "SELECT HOUR(CONVERT_TZ(spotter_output.date,'+00:00', :offset)) AS hour_name, count(*) as hour_count
7644
								FROM spotter_output 
7645
								WHERE spotter_output.airline_icao = :airline_icao
7646
								GROUP BY hour_name 
7647
								ORDER BY hour_name ASC";
7648
		} else {
7649
			$query  = "SELECT EXTRACT(HOUR FROM spotter_output.date AT TIME ZONE INTERVAL :offset) AS hour_name, count(*) as hour_count
7650
								FROM spotter_output 
7651
								WHERE spotter_output.airline_icao = :airline_icao
7652
								GROUP BY hour_name 
7653
								ORDER BY hour_name ASC";
7654
		}
7655
		
7656
		$sth = $this->db->prepare($query);
7657
		$sth->execute(array(':airline_icao' => $airline_icao,':offset' => $offset));
7658
      
7659
		$hour_array = array();
7660
		$temp_array = array();
7661
        
7662
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
7663
		{
7664
			$temp_array['hour_name'] = $row['hour_name'];
7665
			$temp_array['hour_count'] = $row['hour_count'];
7666
          
7667
			$hour_array[] = $temp_array;
7668
		}
7669
7670
		return $hour_array;
7671
	}
7672
	
7673
	
7674
	
7675
	
7676
	/**
7677
	* Counts all hours by aircraft
7678
	*
7679
	* @return Array the hour list
7680
	*
7681
	*/
7682
	public function countAllHoursByAircraft($aircraft_icao)
7683
	{
7684
		global $globalTimezone, $globalDBdriver;
7685
		$aircraft_icao = filter_var($aircraft_icao,FILTER_SANITIZE_STRING);
7686
		if ($globalTimezone != '') {
7687
			date_default_timezone_set($globalTimezone);
7688
			$datetime = new DateTime();
7689
			$offset = $datetime->format('P');
7690
		} else $offset = '+00:00';
7691
7692
		if ($globalDBdriver == 'mysql') {
7693
			$query  = "SELECT HOUR(CONVERT_TZ(spotter_output.date,'+00:00', :offset)) AS hour_name, count(*) as hour_count
7694
								FROM spotter_output 
7695
								WHERE spotter_output.aircraft_icao = :aircraft_icao
7696
								GROUP BY hour_name 
7697
								ORDER BY hour_name ASC";
7698
		} else {
7699
			$query  = "SELECT EXTRACT(HOUR FROM spotter_output.date AT TIME ZONE INTERVAL :offset) AS hour_name, count(*) as hour_count
7700
								FROM spotter_output 
7701
								WHERE spotter_output.aircraft_icao = :aircraft_icao
7702
								GROUP BY hour_name 
7703
								ORDER BY hour_name ASC";
7704
		}
7705
		
7706
		$sth = $this->db->prepare($query);
7707
		$sth->execute(array(':aircraft_icao' => $aircraft_icao,':offset' => $offset));
7708
      
7709
		$hour_array = array();
7710
		$temp_array = array();
7711
        
7712
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
7713
		{
7714
			$temp_array['hour_name'] = $row['hour_name'];
7715
			$temp_array['hour_count'] = $row['hour_count'];
7716
          
7717
			$hour_array[] = $temp_array;
7718
		}
7719
7720
		return $hour_array;
7721
	}
7722
	
7723
	
7724
	/**
7725
	* Counts all hours by aircraft registration
7726
	*
7727
	* @return Array the hour list
7728
	*
7729
	*/
7730
	public function countAllHoursByRegistration($registration)
7731
	{
7732
		global $globalTimezone, $globalDBdriver;
7733
		$registration = filter_var($registration,FILTER_SANITIZE_STRING);
7734
		if ($globalTimezone != '') {
7735
			date_default_timezone_set($globalTimezone);
7736
			$datetime = new DateTime();
7737
			$offset = $datetime->format('P');
7738
		} else $offset = '+00:00';
7739
7740
		if ($globalDBdriver == 'mysql') {
7741
			$query  = "SELECT HOUR(CONVERT_TZ(spotter_output.date,'+00:00', :offset)) AS hour_name, count(*) as hour_count
7742
								FROM spotter_output 
7743
								WHERE spotter_output.registration = :registration
7744
								GROUP BY hour_name 
7745
								ORDER BY hour_name ASC";
7746
		} else {
7747
			$query  = "SELECT EXTRACT(HOUR FROM spotter_output.date AT TIME ZONE INTERVAL :offset) AS hour_name, count(*) as hour_count
7748
								FROM spotter_output 
7749
								WHERE spotter_output.registration = :registration
7750
								GROUP BY hour_name 
7751
								ORDER BY hour_name ASC";
7752
		}
7753
		
7754
		$sth = $this->db->prepare($query);
7755
		$sth->execute(array(':registration' => $registration,':offset' => $offset));
7756
      
7757
		$hour_array = array();
7758
		$temp_array = array();
7759
        
7760
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
7761
		{
7762
			$temp_array['hour_name'] = $row['hour_name'];
7763
			$temp_array['hour_count'] = $row['hour_count'];
7764
          
7765
			$hour_array[] = $temp_array;
7766
		}
7767
7768
		return $hour_array;
7769
	}
7770
	
7771
	
7772
	/**
7773
	* Counts all hours by airport
7774
	*
7775
	* @return Array the hour list
7776
	*
7777
	*/
7778
	public function countAllHoursByAirport($airport_icao)
7779
	{
7780
		global $globalTimezone, $globalDBdriver;
7781
		$airport_icao = filter_var($airport_icao,FILTER_SANITIZE_STRING);
7782
		if ($globalTimezone != '') {
7783
			date_default_timezone_set($globalTimezone);
7784
			$datetime = new DateTime();
7785
			$offset = $datetime->format('P');
7786
		} else $offset = '+00:00';
7787
7788
		if ($globalDBdriver == 'mysql') {
7789
			$query  = "SELECT HOUR(CONVERT_TZ(spotter_output.date,'+00:00', :offset)) AS hour_name, count(*) as hour_count
7790
								FROM spotter_output 
7791
								WHERE (spotter_output.departure_airport_icao = :airport_icao OR spotter_output.arrival_airport_icao = :airport_icao)
7792
								GROUP BY hour_name 
7793
								ORDER BY hour_name ASC";
7794
		} else {
7795
			$query  = "SELECT EXTRACT(HOUR FROM spotter_output.date AT TIME ZONE INTERVAL :offset) AS hour_name, count(*) as hour_count
7796
								FROM spotter_output 
7797
								WHERE (spotter_output.departure_airport_icao = :airport_icao OR spotter_output.arrival_airport_icao = :airport_icao)
7798
								GROUP BY hour_name 
7799
								ORDER BY hour_name ASC";
7800
		}
7801
		
7802
		$sth = $this->db->prepare($query);
7803
		$sth->execute(array(':airport_icao' => $airport_icao,':offset' => $offset));
7804
      
7805
		$hour_array = array();
7806
		$temp_array = array();
7807
        
7808
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
7809
		{
7810
			$temp_array['hour_name'] = $row['hour_name'];
7811
			$temp_array['hour_count'] = $row['hour_count'];
7812
          
7813
			$hour_array[] = $temp_array;
7814
		}
7815
7816
		return $hour_array;
7817
	}
7818
	
7819
	
7820
	
7821
	/**
7822
	* Counts all hours by manufacturer
7823
	*
7824
	* @return Array the hour list
7825
	*
7826
	*/
7827
	public function countAllHoursByManufacturer($aircraft_manufacturer)
7828
	{
7829
		global $globalTimezone, $globalDBdriver;
7830
		$aircraft_manufacturer = filter_var($aircraft_manufacturer,FILTER_SANITIZE_STRING);
7831
		if ($globalTimezone != '') {
7832
			date_default_timezone_set($globalTimezone);
7833
			$datetime = new DateTime();
7834
			$offset = $datetime->format('P');
7835
		} else $offset = '+00:00';
7836
7837
		if ($globalDBdriver == 'mysql') {
7838
			$query  = "SELECT HOUR(CONVERT_TZ(spotter_output.date,'+00:00', :offset)) AS hour_name, count(*) as hour_count
7839
								FROM spotter_output 
7840
								WHERE spotter_output.aircraft_manufacturer = :aircraft_manufacturer
7841
								GROUP BY hour_name 
7842
								ORDER BY hour_name ASC";
7843
		} else {
7844
			$query  = "SELECT EXTRACT(HOUR FROM spotter_output.date AT TIME ZONE INTERVAL :offset) AS hour_name, count(*) as hour_count
7845
								FROM spotter_output 
7846
								WHERE spotter_output.aircraft_manufacturer = :aircraft_manufacturer
7847
								GROUP BY hour_name 
7848
								ORDER BY hour_name ASC";
7849
		}
7850
		
7851
		$sth = $this->db->prepare($query);
7852
		$sth->execute(array(':aircraft_manufacturer' => $aircraft_manufacturer,':offset' => $offset));
7853
      
7854
		$hour_array = array();
7855
		$temp_array = array();
7856
        
7857
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
7858
		{
7859
			$temp_array['hour_name'] = $row['hour_name'];
7860
			$temp_array['hour_count'] = $row['hour_count'];
7861
          
7862
			$hour_array[] = $temp_array;
7863
		}
7864
7865
		return $hour_array;
7866
	}
7867
	
7868
	
7869
	
7870
	/**
7871
	* Counts all hours by date
7872
	*
7873
	* @return Array the hour list
7874
	*
7875
	*/
7876
	public function countAllHoursByDate($date)
7877
	{
7878
		global $globalTimezone, $globalDBdriver;
7879
		$date = filter_var($date,FILTER_SANITIZE_STRING);
7880
		if ($globalTimezone != '') {
7881
			date_default_timezone_set($globalTimezone);
7882
			$datetime = new DateTime($date);
7883
			$offset = $datetime->format('P');
7884
		} else $offset = '+00:00';
7885
7886
		if ($globalDBdriver == 'mysql') {
7887
			$query  = "SELECT HOUR(CONVERT_TZ(spotter_output.date,'+00:00', :offset)) AS hour_name, count(*) as hour_count
7888
								FROM spotter_output 
7889
								WHERE DATE(CONVERT_TZ(spotter_output.date,'+00:00', :offset)) = :date
7890
								GROUP BY hour_name 
7891
								ORDER BY hour_name ASC";
7892
		} else {
7893
			$query  = "SELECT EXTRACT(HOUR FROM spotter_output.date AT TIME ZONE INTERVAL :offset) AS hour_name, count(*) as hour_count
7894
								FROM spotter_output 
7895
								WHERE to_char(spotter_output.date AT TIME ZONE INTERVAL :offset, 'YYYY-mm-dd') = :date
7896
								GROUP BY hour_name 
7897
								ORDER BY hour_name ASC";
7898
		}
7899
		
7900
		$sth = $this->db->prepare($query);
7901
		$sth->execute(array(':date' => $date, ':offset' => $offset));
7902
      
7903
		$hour_array = array();
7904
		$temp_array = array();
7905
        
7906
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
7907
		{
7908
			$temp_array['hour_name'] = $row['hour_name'];
7909
			$temp_array['hour_count'] = $row['hour_count'];
7910
          
7911
			$hour_array[] = $temp_array;
7912
		}
7913
7914
		return $hour_array;
7915
	}
7916
	
7917
	
7918
	
7919
	/**
7920
	* Counts all hours by a ident/callsign
7921
	*
7922
	* @return Array the hour list
7923
	*
7924
	*/
7925
	public function countAllHoursByIdent($ident)
7926
	{
7927
		global $globalTimezone, $globalDBdriver;
7928
		$ident = filter_var($ident,FILTER_SANITIZE_STRING);
7929
		if ($globalTimezone != '') {
7930
			date_default_timezone_set($globalTimezone);
7931
			$datetime = new DateTime();
7932
			$offset = $datetime->format('P');
7933
		} else $offset = '+00:00';
7934
7935
		if ($globalDBdriver == 'mysql') {
7936
			$query  = "SELECT HOUR(CONVERT_TZ(spotter_output.date,'+00:00', :offset)) AS hour_name, count(*) as hour_count
7937
								FROM spotter_output 
7938
								WHERE spotter_output.ident = :ident 
7939
								GROUP BY hour_name 
7940
								ORDER BY hour_name ASC";
7941
		} else {
7942
			$query  = "SELECT EXTRACT(HOUR FROM spotter_output.date AT TIME ZONE INTERVAL :offset) AS hour_name, count(*) as hour_count
7943
								FROM spotter_output 
7944
								WHERE spotter_output.ident = :ident 
7945
								GROUP BY hour_name 
7946
								ORDER BY hour_name ASC";
7947
		}
7948
      
7949
		
7950
		$sth = $this->db->prepare($query);
7951
		$sth->execute(array(':ident' => $ident,':offset' => $offset));
7952
      
7953
		$hour_array = array();
7954
		$temp_array = array();
7955
        
7956
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
7957
		{
7958
			$temp_array['hour_name'] = $row['hour_name'];
7959
			$temp_array['hour_count'] = $row['hour_count'];
7960
          
7961
			$hour_array[] = $temp_array;
7962
		}
7963
7964
		return $hour_array;
7965
	}
7966
	
7967
	
7968
	
7969
	/**
7970
	* Counts all hours by route
7971
	*
7972
	* @return Array the hour list
7973
	*
7974
	*/
7975
	public function countAllHoursByRoute($departure_airport_icao, $arrival_airport_icao)
7976
	{
7977
		global $globalTimezone, $globalDBdriver;
7978
		$departure_airport_icao = filter_var($departure_airport_icao,FILTER_SANITIZE_STRING);
7979
		$arrival_airport_icao = filter_var($arrival_airport_icao,FILTER_SANITIZE_STRING);
7980
		if ($globalTimezone != '') {
7981
			date_default_timezone_set($globalTimezone);
7982
			$datetime = new DateTime();
7983
			$offset = $datetime->format('P');
7984
		} else $offset = '+00:00';
7985
7986
		if ($globalDBdriver == 'mysql') {
7987
			$query  = "SELECT HOUR(CONVERT_TZ(spotter_output.date,'+00:00', :offset)) AS hour_name, count(*) as hour_count
7988
								FROM spotter_output 
7989
								WHERE (spotter_output.departure_airport_icao = :departure_airport_icao) AND (spotter_output.arrival_airport_icao = :arrival_airport_icao)
7990
								GROUP BY hour_name 
7991
								ORDER BY hour_name ASC";
7992
		} else {
7993
			$query  = "SELECT EXTRACT(HOUR FROM spotter_output.date AT TIME ZONE INTERVAL :offset) AS hour_name, count(*) as hour_count
7994
								FROM spotter_output 
7995
								WHERE (spotter_output.departure_airport_icao = :departure_airport_icao) AND (spotter_output.arrival_airport_icao = :arrival_airport_icao)
7996
								GROUP BY hour_name 
7997
								ORDER BY hour_name ASC";
7998
		}
7999
		
8000
		$sth = $this->db->prepare($query);
8001
		$sth->execute(array(':departure_airport_icao' => $departure_airport_icao,':arrival_airport_icao' => $arrival_airport_icao,':offset' => $offset));
8002
      
8003
		$hour_array = array();
8004
		$temp_array = array();
8005
        
8006
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
8007
		{
8008
			$temp_array['hour_name'] = $row['hour_name'];
8009
			$temp_array['hour_count'] = $row['hour_count'];
8010
          
8011
			$hour_array[] = $temp_array;
8012
		}
8013
8014
		return $hour_array;
8015
	}
8016
	
8017
	
8018
	/**
8019
	* Counts all hours by country
8020
	*
8021
	* @return Array the hour list
8022
	*
8023
	*/
8024
	public function countAllHoursByCountry($country)
8025
	{
8026
		global $globalTimezone, $globalDBdriver;
8027
		$country = filter_var($country,FILTER_SANITIZE_STRING);
8028
		if ($globalTimezone != '') {
8029
			date_default_timezone_set($globalTimezone);
8030
			$datetime = new DateTime();
8031
			$offset = $datetime->format('P');
8032
		} else $offset = '+00:00';
8033
8034
		if ($globalDBdriver == 'mysql') {
8035
			$query  = "SELECT HOUR(CONVERT_TZ(spotter_output.date,'+00:00', :offset)) AS hour_name, count(*) as hour_count
8036
								FROM spotter_output 
8037
								WHERE ((spotter_output.departure_airport_country = :country) OR (spotter_output.arrival_airport_country = :country)) OR spotter_output.airline_country = :country
8038
								GROUP BY hour_name 
8039
								ORDER BY hour_name ASC";
8040
		} else {
8041
			$query  = "SELECT EXTRACT(HOUR FROM spotter_output.date AT TIME ZONE INTERVAL :offset) AS hour_name, count(*) as hour_count
8042
								FROM spotter_output 
8043
								WHERE ((spotter_output.departure_airport_country = :country) OR (spotter_output.arrival_airport_country = :country)) OR spotter_output.airline_country = :country
8044
								GROUP BY hour_name 
8045
								ORDER BY hour_name ASC";
8046
		}
8047
		
8048
		$sth = $this->db->prepare($query);
8049
		$sth->execute(array(':country' => $country,':offset' => $offset));
8050
      
8051
		$hour_array = array();
8052
		$temp_array = array();
8053
        
8054
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
8055
		{
8056
			$temp_array['hour_name'] = $row['hour_name'];
8057
			$temp_array['hour_count'] = $row['hour_count'];
8058
          
8059
			$hour_array[] = $temp_array;
8060
		}
8061
8062
		return $hour_array;
8063
	}
8064
8065
8066
8067
8068
	/**
8069
	* Counts all aircraft that have flown over
8070
	*
8071
	* @return Integer the number of aircrafts
8072
	*
8073
	*/
8074
	public function countOverallAircrafts()
8075
	{
8076
		$query  = "SELECT COUNT(DISTINCT spotter_output.aircraft_icao) AS aircraft_count  
8077
                    FROM spotter_output
8078
                    WHERE spotter_output.ident <> ''";
8079
      
8080
		
8081
		$sth = $this->db->prepare($query);
8082
		$sth->execute();
8083
		return $sth->fetchColumn();
8084
	}
8085
8086
	/**
8087
	* Counts all flight that really arrival
8088
	*
8089
	* @return Integer the number of aircrafts
8090
	*
8091
	*/
8092
	public function countOverallArrival()
8093
	{
8094
		$query  = "SELECT COUNT(spotter_output.real_arrival_airport_icao) AS arrival_count  
8095
                    FROM spotter_output
8096
                    WHERE spotter_output.arrival_airport_icao <> ''";
8097
      
8098
		
8099
		$sth = $this->db->prepare($query);
8100
		$sth->execute();
8101
		return $sth->fetchColumn();
8102
	}
8103
8104
	/**
8105
	* Counts all pilots that have flown over
8106
	*
8107
	* @return Integer the number of pilots
8108
	*
8109
	*/
8110
	public function countOverallPilots()
8111
	{
8112
		$query  = "SELECT COUNT(DISTINCT spotter_output.pilot_id) AS pilot_count  
8113
                    FROM spotter_output
8114
                    WHERE spotter_output.pilot_id <> ''";
8115
      
8116
		
8117
		$sth = $this->db->prepare($query);
8118
		$sth->execute();
8119
		return $sth->fetchColumn();
8120
	}
8121
8122
	/**
8123
	* Counts all owners that have flown over
8124
	*
8125
	* @return Integer the number of owners
8126
	*
8127
	*/
8128
	public function countOverallOwners()
8129
	{
8130
		$query  = "SELECT COUNT(DISTINCT spotter_output.owner_name) AS owner_count  
8131
                    FROM spotter_output
8132
                    WHERE spotter_output.owner_name <> ''";
8133
      
8134
		
8135
		$sth = $this->db->prepare($query);
8136
		$sth->execute();
8137
		return $sth->fetchColumn();
8138
	}
8139
	
8140
	
8141
	/**
8142
	* Counts all flights that have flown over
8143
	*
8144
	* @return Integer the number of flights
8145
	*
8146
	*/
8147
	public function countOverallFlights()
8148
	{
8149
		$query  = "SELECT COUNT(spotter_output.spotter_id) AS flight_count  
8150
                    FROM spotter_output";
8151
      
8152
		
8153
		$sth = $this->db->prepare($query);
8154
		$sth->execute();
8155
		return $sth->fetchColumn();
8156
	}
8157
	
8158
	/**
8159
	* Counts all military flights that have flown over
8160
	*
8161
	* @return Integer the number of flights
8162
	*
8163
	*/
8164
	public function countOverallMilitaryFlights()
8165
	{
8166
		$query  = "SELECT COUNT(s.spotter_id) AS flight_count  
8167
                    FROM spotter_output s, airlines a WHERE s.airline_icao = a.icao AND a.type = 'military'";
8168
      
8169
		
8170
		$sth = $this->db->prepare($query);
8171
		$sth->execute();
8172
		return $sth->fetchColumn();
8173
	}
8174
	
8175
	
8176
	
8177
	/**
8178
	* Counts all airlines that have flown over
8179
	*
8180
	* @return Integer the number of airlines
8181
	*
8182
	*/
8183
	public function countOverallAirlines()
8184
	{
8185
		$query  = "SELECT COUNT(DISTINCT spotter_output.airline_name) AS airline_count 
8186
							FROM spotter_output";
8187
      
8188
		
8189
		$sth = $this->db->prepare($query);
8190
		$sth->execute();
8191
		return $sth->fetchColumn();
8192
	}
8193
8194
  
8195
	/**
8196
	* Counts all hours of today
8197
	*
8198
	* @return Array the hour list
8199
	*
8200
	*/
8201
	public function countAllHoursFromToday()
8202
	{
8203
		global $globalTimezone, $globalDBdriver;
8204
		if ($globalTimezone != '') {
8205
			date_default_timezone_set($globalTimezone);
8206
			$datetime = new DateTime();
8207
			$offset = $datetime->format('P');
8208
		} else $offset = '+00:00';
8209
8210
		if ($globalDBdriver == 'mysql') {
8211
			$query  = "SELECT HOUR(CONVERT_TZ(spotter_output.date,'+00:00', :offset)) AS hour_name, count(*) as hour_count
8212
								FROM spotter_output 
8213
								WHERE DATE(CONVERT_TZ(spotter_output.date,'+00:00', :offset)) = CURDATE()
8214
								GROUP BY hour_name 
8215
								ORDER BY hour_name ASC";
8216
		} else {
8217
			$query  = "SELECT EXTRACT(HOUR FROM spotter_output.date AT TIME ZONE INTERVAL :offset) AS hour_name, count(*) as hour_count
8218
								FROM spotter_output 
8219
								WHERE to_char(spotter_output.date AT TIME ZONE INTERVAL :offset,'YYYY-mm-dd') = CAST(NOW() AS date)
8220
								GROUP BY hour_name 
8221
								ORDER BY hour_name ASC";
8222
		}
8223
		
8224
		$sth = $this->db->prepare($query);
8225
		$sth->execute(array(':offset' => $offset));
8226
      
8227
		$hour_array = array();
8228
		$temp_array = array();
8229
        
8230
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
8231
		{
8232
			$temp_array['hour_name'] = $row['hour_name'];
8233
			$temp_array['hour_count'] = $row['hour_count'];
8234
			$hour_array[] = $temp_array;
8235
		}
8236
8237
		return $hour_array;
8238
	}
8239
    
8240
	/**
8241
	* Gets all the spotter information based on calculated upcoming flights
8242
	*
8243
	* @return Array the spotter information
8244
	*
8245
	*/
8246
	public function getUpcomingFlights($limit = '', $sort = '')
8247
	{
8248
		global $global_query, $globalDBdriver, $globalTimezone;
8249
		date_default_timezone_set('UTC');
8250
		$limit_query = '';
8251
		if ($limit != "")
8252
		{
8253
			$limit_array = explode(",", $limit);
8254
			$limit_array[0] = filter_var($limit_array[0],FILTER_SANITIZE_NUMBER_INT);
8255
			$limit_array[1] = filter_var($limit_array[1],FILTER_SANITIZE_NUMBER_INT);
8256
			if ($limit_array[0] >= 0 && $limit_array[1] >= 0)
8257
			{
8258
				//$limit_query = " LIMIT ".$limit_array[0].",".$limit_array[1];
8259
				$limit_query = " LIMIT ".$limit_array[1]." OFFSET ".$limit_array[0];
8260
			}
8261
		}
8262
		$currentHour = date("G");
8263
		$next3Hours = date("G", strtotime("+3 hour"));
8264
		//if the next 3 hours is already equal to/past midnight, we limit it to stay there, otherwise the query will fail
8265
		if ($currentHour >= 21 && $next3Hours >= 00)
8266
		{
8267
			$next3Hours = 24;
8268
		}
8269
		$currentDayofWeek = date("l");
8270
		if ($globalDBdriver == 'mysql') {
8271
			if ($sort != "")
8272
			{
8273
				$search_orderby_array = $this->getOrderBy();
8274
				$orderby_query = $search_orderby_array[$sort]['sql'];
8275
			} else {
8276
				$orderby_query = " ORDER BY HOUR(spotter_output.date) ASC";
8277
			}
8278
8279
			$query = "SELECT spotter_output.*, count(spotter_output.ident) as ident_count
8280
			    FROM spotter_output
8281
			    WHERE DAYNAME(spotter_output.date) = '$currentDayofWeek' AND HOUR(spotter_output.date) >= '$currentHour' AND HOUR(spotter_output.date) <= '$next3Hours' AND spotter_output.ident <> '' AND format_source <> 'aprs'
8282
			    GROUP BY spotter_output.ident,spotter_output.spotter_id, spotter_output.flightaware_id, spotter_output.registration,spotter_output.airline_name,spotter_output.airline_icao,spotter_output.airline_country,spotter_output.airline_type,spotter_output.aircraft_icao,spotter_output.aircraft_name,spotter_output.aircraft_manufacturer,spotter_output.departure_airport_icao,spotter_output.departure_airport_name,spotter_output.departure_airport_city,spotter_output.departure_airport_country,spotter_output.departure_airport_time,spotter_output.arrival_airport_icao,spotter_output.arrival_airport_name,spotter_output.arrival_airport_city,spotter_output.arrival_airport_country,spotter_output.arrival_airport_time,spotter_output.route_stop,spotter_output.date,spotter_output.latitude,spotter_output.longitude,spotter_output.waypoints,spotter_output.altitude,spotter_output.heading,spotter_output.ground_speed,spotter_output.highlight,spotter_output.squawk,spotter_output.ModeS,spotter_output.pilot_id,spotter_output.pilot_name,spotter_output.verticalrate,spotter_output.owner_name,spotter_output.format_source,spotter_output.source_name,spotter_output.ground,spotter_output.last_ground,spotter_output.last_seen,spotter_output.last_latitude,spotter_output.last_longitude,spotter_output.last_altitude,spotter_output.last_ground_speed,spotter_output.real_arrival_airport_icao,spotter_output.real_arrival_airport_time HAVING count(spotter_output.ident) > 10 $orderby_query";
8283
8284
/*			$query = "SELECT spotter_output.ident, spotter_output.registration,spotter_output.airline_name,spotter_output.airline_icao,spotter_output.airline_country,spotter_output.airline_type,spotter_output.aircraft_icao,spotter_output.aircraft_name,spotter_output.aircraft_manufacturer,spotter_output.departure_airport_icao,spotter_output.departure_airport_name,spotter_output.departure_airport_city,spotter_output.departure_airport_country,spotter_output.departure_airport_time,spotter_output.arrival_airport_icao,spotter_output.arrival_airport_name,spotter_output.arrival_airport_city,spotter_output.arrival_airport_country,spotter_output.arrival_airport_time,spotter_output.route_stop,spotter_output.date,spotter_output.latitude,spotter_output.longitude,spotter_output.waypoints,spotter_output.altitude,spotter_output.heading,spotter_output.ground_speed,spotter_output.highlight,spotter_output.squawk,spotter_output.ModeS,spotter_output.pilot_id,spotter_output.pilot_name,spotter_output.verticalrate,spotter_output.owner_name,spotter_output.format_source,spotter_output.source_name,spotter_output.ground,spotter_output.last_ground,spotter_output.last_seen,spotter_output.last_latitude,spotter_output.last_longitude,spotter_output.last_altitude,spotter_output.last_ground_speed,spotter_output.real_arrival_airport_icao,spotter_output.real_arrival_airport_time, count(spotter_output.ident) as ident_count
8285
			    FROM spotter_output
8286
			    WHERE DAYNAME(spotter_output.date) = '$currentDayofWeek' AND HOUR(spotter_output.date) >= '$currentHour' AND HOUR(spotter_output.date) <= '$next3Hours' AND spotter_output.ident <> '' AND format_source <> 'aprs'
8287
			    GROUP BY spotter_output.ident,spotter_output.spotter_id, spotter_output.flightaware_id, spotter_output.registration,spotter_output.airline_name,spotter_output.airline_icao,spotter_output.airline_country,spotter_output.airline_type,spotter_output.aircraft_icao,spotter_output.aircraft_name,spotter_output.aircraft_manufacturer,spotter_output.departure_airport_icao,spotter_output.departure_airport_name,spotter_output.departure_airport_city,spotter_output.departure_airport_country,spotter_output.departure_airport_time,spotter_output.arrival_airport_icao,spotter_output.arrival_airport_name,spotter_output.arrival_airport_city,spotter_output.arrival_airport_country,spotter_output.arrival_airport_time,spotter_output.route_stop,spotter_output.date,spotter_output.latitude,spotter_output.longitude,spotter_output.waypoints,spotter_output.altitude,spotter_output.heading,spotter_output.ground_speed,spotter_output.highlight,spotter_output.squawk,spotter_output.ModeS,spotter_output.pilot_id,spotter_output.pilot_name,spotter_output.verticalrate,spotter_output.owner_name,spotter_output.format_source,spotter_output.source_name,spotter_output.ground,spotter_output.last_ground,spotter_output.last_seen,spotter_output.last_latitude,spotter_output.last_longitude,spotter_output.last_altitude,spotter_output.last_ground_speed,spotter_output.real_arrival_airport_icao,spotter_output.real_arrival_airport_time HAVING count(spotter_output.ident) > 10 $orderby_query";
8288
*/
8289
			$spotter_array = $this->getDataFromDB($query.$limit_query);
8290
		} else {
8291
			if ($sort != "")
8292
			{
8293
				$search_orderby_array = $this->getOrderBy();
8294
				$orderby_query = $search_orderby_array[$sort]['sql'];
8295
			} else {
8296
				$orderby_query = " ORDER BY EXTRACT (HOUR FROM spotter_output.date) ASC";
8297
			}
8298
			$query = "SELECT spotter_output.*, count(spotter_output.ident) as ident_count
8299
			    FROM spotter_output
8300
			    WHERE DATE_PART('dow', spotter_output.date) = DATE_PART('dow', date 'now' AT TIME ZONE :timezone) AND EXTRACT (HOUR FROM spotter_output.date AT TIME ZONE :timezone) >= '$currentHour' AND EXTRACT (HOUR FROM spotter_output.date AT TIME ZONE :timezone) <= '$next3Hours' AND ident <> '' 
8301
			    GROUP BY spotter_output.ident, spotter_output.spotter_id HAVING count(spotter_output.ident) > 10 $orderby_query";
8302
			$spotter_array = $this->getDataFromDB($query.$limit_query,array(':timezone' => $globalTimezone));
8303
		}
8304
		return $spotter_array;
8305
	}
8306
    
8307
    
8308
     /**
8309
	* Gets the Barrie Spotter ID based on the FlightAware ID
8310
	*
8311
	* @return Integer the Barrie Spotter ID
8312
	*
8313
	*/
8314
	public function getSpotterIDBasedOnFlightAwareID($flightaware_id)
8315
	{
8316
		$flightaware_id = filter_var($flightaware_id,FILTER_SANITIZE_STRING);
8317
8318
		$query  = "SELECT spotter_output.spotter_id
8319
								FROM spotter_output 
8320
								WHERE spotter_output.flightaware_id = '".$flightaware_id."'";
8321
        
8322
		
8323
		$sth = $this->db->prepare($query);
8324
		$sth->execute();
8325
8326
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
8327
		{
8328
			return $row['spotter_id'];
8329
		}
8330
	}
8331
  
8332
 
8333
	/**
8334
	* Parses a date string
8335
	*
8336
	* @param String $dateString the date string
8337
	* @param String $timezone the timezone of a user
8338
	* @return Array the time information
8339
	*
8340
	*/
8341
	public function parseDateString($dateString, $timezone = '')
8342
	{
8343
		$time_array = array();
8344
	
8345
		if ($timezone != "")
8346
		{
8347
			date_default_timezone_set($timezone);
8348
		}
8349
		
8350
		$current_date = date("Y-m-d H:i:s");
8351
		$date = date("Y-m-d H:i:s",strtotime($dateString." UTC"));
8352
		
8353
		$diff = abs(strtotime($current_date) - strtotime($date));
8354
8355
		$time_array['years'] = floor($diff / (365*60*60*24)); 
8356
		$years = $time_array['years'];
8357
		
8358
		$time_array['months'] = floor(($diff - $years * 365*60*60*24) / (30*60*60*24));
8359
		$months = $time_array['months'];
8360
		
8361
		$time_array['days'] = floor(($diff - $years * 365*60*60*24 - $months*30*60*60*24)/ (60*60*24));
8362
		$days = $time_array['days'];
8363
		$time_array['hours'] = floor(($diff - $years * 365*60*60*24 - $months*30*60*60*24 - $days*60*60*24)/ (60*60));
8364
		$hours = $time_array['hours'];
8365
		$time_array['minutes'] = floor(($diff - $years * 365*60*60*24 - $months*30*60*60*24 - $days*60*60*24 - $hours*60*60)/ 60);
8366
		$minutes = $time_array['minutes'];
8367
		$time_array['seconds'] = floor(($diff - $years * 365*60*60*24 - $months*30*60*60*24 - $days*60*60*24 - $hours*60*60 - $minutes*60));  
8368
		
8369
		return $time_array;	
8370
	}	
8371
	
8372
	
8373
	
8374
	
8375
	/**
8376
	* Parses the direction degrees to working
8377
	*
8378
	* @param Float $direction the direction in degrees
8379
	* @return Array the direction information
8380
	*
8381
	*/
8382
	public function parseDirection($direction = 0)
8383
	{
8384
		if ($direction == '') $direction = 0;
8385
		$direction_array = array();
8386
		$temp_array = array();
8387
8388
		if ($direction == 360 || ($direction >= 0 && $direction < 22.5))
8389
		{
8390
			$temp_array['direction_degree'] = $direction;
8391
			$temp_array['direction_shortname'] = "N";
8392
			$temp_array['direction_fullname'] = "North";
8393
		} elseif ($direction >= 22.5 && $direction < 45){
8394
			$temp_array['direction_degree'] = $direction;
8395
			$temp_array['direction_shortname'] = "NNE";
8396
			$temp_array['direction_fullname'] = "North-Northeast";
8397
		} elseif ($direction >= 45 && $direction < 67.5){
8398
			$temp_array['direction_degree'] = $direction;
8399
			$temp_array['direction_shortname'] = "NE";
8400
			$temp_array['direction_fullname'] = "Northeast";
8401
		} elseif ($direction >= 67.5 && $direction < 90){
8402
			$temp_array['direction_degree'] = $direction;
8403
			$temp_array['direction_shortname'] = "ENE";
8404
			$temp_array['direction_fullname'] = "East-Northeast";
8405
		} elseif ($direction >= 90 && $direction < 112.5){
8406
			$temp_array['direction_degree'] = $direction;
8407
			$temp_array['direction_shortname'] = "E";
8408
			$temp_array['direction_fullname'] = "East";
8409
		} elseif ($direction >= 112.5 && $direction < 135){
8410
			$temp_array['direction_degree'] = $direction;
8411
			$temp_array['direction_shortname'] = "ESE";
8412
			$temp_array['direction_fullname'] = "East-Southeast";
8413
		} elseif ($direction >= 135 && $direction < 157.5){
8414
			$temp_array['direction_degree'] = $direction;
8415
			$temp_array['direction_shortname'] = "SE";
8416
			$temp_array['direction_fullname'] = "Southeast";
8417
		} elseif ($direction >= 157.5 && $direction < 180){
8418
			$temp_array['direction_degree'] = $direction;
8419
			$temp_array['direction_shortname'] = "SSE";
8420
			$temp_array['direction_fullname'] = "South-Southeast";
8421
		} elseif ($direction >= 180 && $direction < 202.5){
8422
			$temp_array['direction_degree'] = $direction;
8423
			$temp_array['direction_shortname'] = "S";
8424
			$temp_array['direction_fullname'] = "South";
8425
		} elseif ($direction >= 202.5 && $direction < 225){
8426
			$temp_array['direction_degree'] = $direction;
8427
			$temp_array['direction_shortname'] = "SSW";
8428
			$temp_array['direction_fullname'] = "South-Southwest";
8429
		} elseif ($direction >= 225 && $direction < 247.5){
8430
			$temp_array['direction_degree'] = $direction;
8431
			$temp_array['direction_shortname'] = "SW";
8432
			$temp_array['direction_fullname'] = "Southwest";
8433
		} elseif ($direction >= 247.5 && $direction < 270){
8434
			$temp_array['direction_degree'] = $direction;
8435
			$temp_array['direction_shortname'] = "WSW";
8436
			$temp_array['direction_fullname'] = "West-Southwest";
8437
		} elseif ($direction >= 270 && $direction < 292.5){
8438
			$temp_array['direction_degree'] = $direction;
8439
			$temp_array['direction_shortname'] = "W";
8440
			$temp_array['direction_fullname'] = "West";
8441
		} elseif ($direction >= 292.5 && $direction < 315){
8442
			$temp_array['direction_degree'] = $direction;
8443
			$temp_array['direction_shortname'] = "WNW";
8444
			$temp_array['direction_fullname'] = "West-Northwest";
8445
		} elseif ($direction >= 315 && $direction < 337.5){
8446
			$temp_array['direction_degree'] = $direction;
8447
			$temp_array['direction_shortname'] = "NW";
8448
			$temp_array['direction_fullname'] = "Northwest";
8449
		} elseif ($direction >= 337.5 && $direction < 360){
8450
			$temp_array['direction_degree'] = $direction;
8451
			$temp_array['direction_shortname'] = "NNW";
8452
			$temp_array['direction_fullname'] = "North-Northwest";
8453
		}
8454
		$direction_array[] = $temp_array;
8455
		return $direction_array;
8456
	}
8457
	
8458
	
8459
	/**
8460
	* Gets the aircraft registration
8461
	*
8462
	* @param String $flightaware_id the flight aware id
8463
	* @return String the aircraft registration
8464
	*
8465
	*/
8466
	
8467
	public function getAircraftRegistration($flightaware_id)
8468
	{
8469
		global $globalFlightAwareUsername, $globalFlightAwarePassword;
8470
        
8471
		$options = array(
8472
			'trace' => true,
8473
			'exceptions' => 0,
8474
			'login' => $globalFlightAwareUsername,
8475
			'password' => $globalFlightAwarePassword,
8476
		);
8477
		$client = new SoapClient('http://flightxml.flightaware.com/soap/FlightXML2/wsdl', $options);
8478
		
8479
		$params = array('faFlightID' => $flightaware_id);
8480
		$result = $client->AirlineFlightInfo($params);
8481
		
8482
		if (isset($result->AirlineFlightInfoResult))
8483
		{
8484
			$registration = $result->AirlineFlightInfoResult->tailnumber;
8485
		} else return '';
8486
		
8487
		$registration = $this->convertAircraftRegistration($registration);
8488
		
8489
		return $registration;
8490
	}
8491
8492
8493
	/**
8494
	* Gets the aircraft registration from ModeS
8495
	*
8496
	* @param String $aircraft_modes the flight ModeS in hex
8497
	* @return String the aircraft registration
8498
	*
8499
	*/
8500
	public function getAircraftRegistrationBymodeS($aircraft_modes)
8501
	{
8502
		$aircraft_modes = filter_var($aircraft_modes,FILTER_SANITIZE_STRING);
8503
	
8504
		$query  = "SELECT aircraft_modes.Registration FROM aircraft_modes WHERE aircraft_modes.ModeS = :aircraft_modes LIMIT 1";
8505
		
8506
		$sth = $this->db->prepare($query);
8507
		$sth->execute(array(':aircraft_modes' => $aircraft_modes));
8508
    
8509
		$row = $sth->fetch(PDO::FETCH_ASSOC);
8510
		if (count($row) > 0) {
8511
		    //return $row['Registration'];
8512
		    return $row['registration'];
8513
		} else return '';
8514
	
8515
	}
8516
8517
	/**
8518
	* Gets the aircraft type from ModeS
8519
	*
8520
	* @param String $aircraft_modes the flight ModeS in hex
8521
	* @return String the aircraft type
8522
	*
8523
	*/
8524
	public function getAircraftTypeBymodeS($aircraft_modes)
8525
	{
8526
		$aircraft_modes = filter_var($aircraft_modes,FILTER_SANITIZE_STRING);
8527
	
8528
		$query  = "SELECT aircraft_modes.type_flight FROM aircraft_modes WHERE aircraft_modes.ModeS = :aircraft_modes LIMIT 1";
8529
		
8530
		$sth = $this->db->prepare($query);
8531
		$sth->execute(array(':aircraft_modes' => $aircraft_modes));
8532
    
8533
		$row = $sth->fetch(PDO::FETCH_ASSOC);
8534
		if (count($row) > 0) {
8535
		    if ($row['type_flight'] == null) return '';
8536
		    else return $row['type_flight'];
8537
		} else return '';
8538
	
8539
	}
8540
8541
	/**
8542
	* Gets Countrie from latitude/longitude
8543
	*
8544
	* @param Float $latitude latitute of the flight
8545
	* @param Float $longitude longitute of the flight
8546
	* @return String the countrie
8547
	*/
8548
	public function getCountryFromLatitudeLongitude($latitude,$longitude)
8549
	{
8550
		global $globalDBdriver, $globalDebug;
8551
		$latitude = filter_var($latitude,FILTER_SANITIZE_NUMBER_FLOAT,FILTER_FLAG_ALLOW_FRACTION);
8552
		$longitude = filter_var($longitude,FILTER_SANITIZE_NUMBER_FLOAT,FILTER_FLAG_ALLOW_FRACTION);
8553
	
8554
		try {
8555
			/*
8556
			if ($globalDBdriver == 'mysql') {
8557
				//$query  = "SELECT name, iso2, iso3 FROM countries WHERE Within(GeomFromText('POINT(:latitude :longitude)'), ogc_geom) LIMIT 1";
8558
				$query = "SELECT name, iso2, iso3 FROM countries WHERE Within(GeomFromText('POINT(".$longitude.' '.$latitude.")'), ogc_geom) LIMIT 1";
8559
			}
8560
			*/
8561
			// This query seems to work both for MariaDB and PostgreSQL
8562
			$query = "SELECT name,iso2,iso3 FROM countries WHERE ST_Within(ST_GeomFromText('POINT(".$longitude." ".$latitude.")',4326), ogc_geom) LIMIT 1";
8563
		
8564
			$sth = $this->db->prepare($query);
8565
			//$sth->execute(array(':latitude' => $latitude,':longitude' => $longitude));
8566
			$sth->execute();
8567
    
8568
			$row = $sth->fetch(PDO::FETCH_ASSOC);
8569
			if (count($row) > 0) {
8570
				return $row;
8571
			} else return '';
8572
		} catch (PDOException $e) {
8573
			if (isset($globalDebug) && $globalDebug) echo 'Error : '.$e->getMessage()."\n";
8574
			return '';
8575
		}
8576
	
8577
	}
8578
8579
	/**
8580
	* converts the registration code using the country prefix
8581
	*
8582
	* @param String $registration the aircraft registration
8583
	* @return String the aircraft registration
8584
	*
8585
	*/
8586
	public function convertAircraftRegistration($registration)
8587
	{
8588
		$registration = filter_var($registration,FILTER_SANITIZE_STRING);
8589
		$registration_prefix = '';
8590
		$registration_1 = substr($registration, 0, 1);
8591
		$registration_2 = substr($registration, 0, 2);
8592
8593
		//first get the prefix based on two characters
8594
		$query  = "SELECT aircraft_registration.registration_prefix FROM aircraft_registration WHERE registration_prefix = :registration_2";
8595
      
8596
		
8597
		$sth = $this->db->prepare($query);
8598
		$sth->execute(array(':registration_2' => $registration_2));
8599
        
8600
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
8601
		{
8602
			$registration_prefix = $row['registration_prefix'];
8603
		}
8604
8605
		//if we didn't find a two chracter prefix lets just search the one with one character
8606
		if ($registration_prefix == '')
8607
		{
8608
			$query  = "SELECT aircraft_registration.registration_prefix FROM aircraft_registration WHERE registration_prefix = :registration_1";
8609
			$sth = $this->db->prepare($query);
8610
			$sth->execute(array(':registration_1' => $registration_1));
8611
	        
8612
			while($row = $sth->fetch(PDO::FETCH_ASSOC))
8613
			{
8614
				$registration_prefix = $row['registration_prefix'];
8615
			}
8616
		}
8617
8618
		//determine which characters are being used and convert the registration code appropiately
8619
		if (strlen($registration_prefix) == 1)
8620
		{
8621
			if (0 === strpos($registration, 'N')) {
8622
				$registration = preg_replace("/^(.{1})/", "$1", $registration);
8623
			} else {
8624
				$registration = preg_replace("/^(.{1})/", "$1-", $registration);
8625
			}
8626
		} else if(strlen($registration_prefix) == 2){
8627
			if (0 === strpos($registration, 'N')) {
8628
				$registration = preg_replace("/^(.{2})/", "$1", $registration);
8629
			} else {
8630
				$registration = preg_replace("/^(.{2})/", "$1-", $registration);
8631
			}
8632
		}
8633
		return $registration;
8634
	}
8635
8636
	/**
8637
	* Country from the registration code
8638
	*
8639
	* @param String $registration the aircraft registration
8640
	* @return String the country
8641
	*
8642
	*/
8643
	public function countryFromAircraftRegistration($registration)
8644
	{
8645
		$registration = filter_var($registration,FILTER_SANITIZE_STRING);
8646
		
8647
		$registration_prefix = '';
8648
		$registration_test = explode('-',$registration);
8649
		$country = '';
8650
		if ($registration_test[0] != $registration) {
8651
			$query  = "SELECT aircraft_registration.registration_prefix, aircraft_registration.country FROM aircraft_registration WHERE registration_prefix = :registration_1 LIMIT 1";
8652
	      
8653
			$sth = $this->db->prepare($query);
8654
			$sth->execute(array(':registration_1' => $registration_test[0]));
8655
			while($row = $sth->fetch(PDO::FETCH_ASSOC))
8656
			{
8657
				//$registration_prefix = $row['registration_prefix'];
8658
				$country = $row['country'];
8659
			}
8660
		} else {
8661
    			$registration_1 = substr($registration, 0, 1);
8662
		        $registration_2 = substr($registration, 0, 2);
8663
8664
			$country = '';
8665
			//first get the prefix based on two characters
8666
			$query  = "SELECT aircraft_registration.registration_prefix, aircraft_registration.country FROM aircraft_registration WHERE registration_prefix = :registration_2 LIMIT 1";
8667
      
8668
			
8669
			$sth = $this->db->prepare($query);
8670
			$sth->execute(array(':registration_2' => $registration_2));
8671
        
8672
			while($row = $sth->fetch(PDO::FETCH_ASSOC))
8673
			{
8674
				$registration_prefix = $row['registration_prefix'];
8675
				$country = $row['country'];
8676
			}
8677
8678
			//if we didn't find a two chracter prefix lets just search the one with one character
8679
			if ($registration_prefix == "")
8680
			{
8681
				$query  = "SELECT aircraft_registration.registration_prefix, aircraft_registration.country FROM aircraft_registration WHERE registration_prefix = :registration_1 LIMIT 1";
8682
	      
8683
				$sth = $this->db->prepare($query);
8684
				$sth->execute(array(':registration_1' => $registration_1));
8685
	        
8686
				while($row = $sth->fetch(PDO::FETCH_ASSOC))
8687
				{
8688
					//$registration_prefix = $row['registration_prefix'];
8689
					$country = $row['country'];
8690
				}
8691
			}
8692
		}
8693
    
8694
		return $country;
8695
	}
8696
	
8697
	/**
8698
	* Set a new highlight value for a flight
8699
	*
8700
	* @param String $flightaware_id flightaware_id from spotter_output table
8701
	* @param String $highlight New highlight value
8702
	*/
8703
	public function setHighlightFlight($flightaware_id,$highlight) {
8704
		
8705
		$query  = "UPDATE spotter_output SET highlight = :highlight WHERE flightaware_id = :flightaware_id";
8706
		$sth = $this->db->prepare($query);
8707
		$sth->execute(array(':flightaware_id' => $flightaware_id, ':highlight' => $highlight));
8708
	}
8709
	
8710
	/**
8711
	* Gets the short url from bit.ly
8712
	*
8713
	* @param String $url the full url
8714
	* @return String the bit.ly url
8715
	*
8716
	*/
8717
	public function getBitlyURL($url)
8718
	{
8719
		global $globalBitlyAccessToken;
8720
		
8721
		if ($globalBitlyAccessToken == '') return $url;
8722
        
8723
		$google_url = 'https://api-ssl.bitly.com/v3/shorten?access_token='.$globalBitlyAccessToken.'&longUrl='.$url;
8724
		
8725
		$ch = curl_init();
8726
		curl_setopt($ch, CURLOPT_HEADER, 0);
8727
		curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
8728
		curl_setopt($ch, CURLOPT_URL, $google_url);
8729
		$bitly_data = curl_exec($ch);
8730
		curl_close($ch);
8731
		
8732
		$bitly_data = json_decode($bitly_data);
8733
		$bitly_url = '';
8734
		if ($bitly_data->status_txt = "OK"){
8735
			$bitly_url = $bitly_data->data->url;
8736
		}
8737
8738
		return $bitly_url;
8739
	}
8740
8741
8742
	public function getOrderBy()
8743
	{
8744
		$orderby = array("aircraft_asc" => array("key" => "aircraft_asc", "value" => "Aircraft Type - ASC", "sql" => "ORDER BY spotter_output.aircraft_icao ASC"), "aircraft_desc" => array("key" => "aircraft_desc", "value" => "Aircraft Type - DESC", "sql" => "ORDER BY spotter_output.aircraft_icao DESC"),"manufacturer_asc" => array("key" => "manufacturer_asc", "value" => "Aircraft Manufacturer - ASC", "sql" => "ORDER BY spotter_output.aircraft_manufacturer ASC"), "manufacturer_desc" => array("key" => "manufacturer_desc", "value" => "Aircraft Manufacturer - DESC", "sql" => "ORDER BY spotter_output.aircraft_manufacturer DESC"),"airline_name_asc" => array("key" => "airline_name_asc", "value" => "Airline Name - ASC", "sql" => "ORDER BY spotter_output.airline_name ASC"), "airline_name_desc" => array("key" => "airline_name_desc", "value" => "Airline Name - DESC", "sql" => "ORDER BY spotter_output.airline_name DESC"), "ident_asc" => array("key" => "ident_asc", "value" => "Ident - ASC", "sql" => "ORDER BY spotter_output.ident ASC"), "ident_desc" => array("key" => "ident_desc", "value" => "Ident - DESC", "sql" => "ORDER BY spotter_output.ident DESC"), "airport_departure_asc" => array("key" => "airport_departure_asc", "value" => "Departure Airport - ASC", "sql" => "ORDER BY spotter_output.departure_airport_city ASC"), "airport_departure_desc" => array("key" => "airport_departure_desc", "value" => "Departure Airport - DESC", "sql" => "ORDER BY spotter_output.departure_airport_city DESC"), "airport_arrival_asc" => array("key" => "airport_arrival_asc", "value" => "Arrival Airport - ASC", "sql" => "ORDER BY spotter_output.arrival_airport_city ASC"), "airport_arrival_desc" => array("key" => "airport_arrival_desc", "value" => "Arrival Airport - DESC", "sql" => "ORDER BY spotter_output.arrival_airport_city DESC"), "date_asc" => array("key" => "date_asc", "value" => "Date - ASC", "sql" => "ORDER BY spotter_output.date ASC"), "date_desc" => array("key" => "date_desc", "value" => "Date - DESC", "sql" => "ORDER BY spotter_output.date DESC"),"distance_asc" => array("key" => "distance_asc","value" => "Distance - ASC","sql" => "ORDER BY distance ASC"),"distance_desc" => array("key" => "distance_desc","value" => "Distance - DESC","sql" => "ORDER BY distance DESC"));
8745
		
8746
		return $orderby;
8747
		
8748
	}
8749
    
8750
/*
8751
	public function importFromFlightAware()
8752
	{
8753
		global $globalFlightAwareUsername, $globalFlightAwarePassword, $globalLatitudeMax, $globalLatitudeMin, $globalLongitudeMax, $globalLongitudeMin, $globalAirportIgnore;
8754
		$Spotter = new Spotter($this->db);
8755
		$SpotterLive = new SpotterLive($this->db);
8756
		$options = array(
8757
		            'trace' => true,
8758
		            'exceptions' => 0,
8759
		            'login' => $globalFlightAwareUsername,
8760
		            'password' => $globalFlightAwarePassword,
8761
		);
8762
		$client = new SoapClient('http://flightxml.flightaware.com/soap/FlightXML2/wsdl', $options);
8763
		$params = array('query' => '{range lat '.$globalLatitudeMin.' '.$globalLatitudeMax.'} {range lon '.$globalLongitudeMax.' '.$globalLongitudeMin.'} {true inAir}', 'howMany' => '15', 'offset' => '0');
8764
		$result = $client->SearchBirdseyeInFlight($params);
8765
		$dataFound = false;
8766
		$ignoreImport = false;
8767
		if (isset($result->SearchBirdseyeInFlightResult))
8768
		{
8769
			if (is_array($result->SearchBirdseyeInFlightResult->aircraft))
8770
			{
8771
				foreach($result->SearchBirdseyeInFlightResult->aircraft as $aircraft)
8772
				{
8773
					if (!strstr($aircraft->origin, 'L ') && !strstr($aircraft->destination, 'L '))
8774
					{
8775
						foreach($globalAirportIgnore as $airportIgnore)
8776
						{
8777
							if ($aircraft->origin == $airportIgnore || $aircraft->destination == $airportIgnore)
8778
							{
8779
								$ignoreImport = true; 
8780
							}
8781
						}
8782
						if ($ignoreImport == false)
8783
						{
8784
							$flightaware_id = $aircraft->faFlightID;
8785
							$ident = $aircraft->ident;
8786
							$aircraft_type = $aircraft->type;
8787
							$departure_airport = $aircraft->origin;
8788
							$arrival_airport = $aircraft->destination;
8789
							$latitude = $aircraft->latitude;
8790
							$longitude = $aircraft->longitude;
8791
							$waypoints = $aircraft->waypoints;
8792
							$altitude = $aircraft->altitude;
8793
							$heading = $aircraft->heading;
8794
							$groundspeed = $aircraft->groundspeed;
8795
							$dataFound = true;
8796
							//gets the callsign from the last hour
8797
							$last_hour_ident = $this->getIdentFromLastHour($ident);
8798
							//change the departure/arrival airport to NA if its not available
8799
							if ($departure_airport == "" || $departure_airport == "---" || $departure_airport == "ZZZ" || $departure_airport == "ZZZZ") { $departure_airport = "NA"; }
8800
							if ($arrival_airport == "" || $arrival_airport == "---" || $arrival_airport == "ZZZ" || $arrival_airport == "ZZZZ") { $arrival_airport = "NA"; }
8801
							//if there was no aircraft with the same callsign within the last hour and go post it into the archive
8802
							if($last_hour_ident == "")
8803
							{
8804
								//adds the spotter data for the archive
8805
								$Spotter->addSpotterData($flightaware_id, $ident, $aircraft_type, $departure_airport, $arrival_airport, $latitude, $longitude, $waypoints, $altitude, $heading, $groundspeed);
8806
							}
8807
8808
							//adds the spotter LIVE data
8809
							$SpotterLive->addLiveSpotterData($flightaware_id, $ident, $aircraft_type, $departure_airport, $arrival_airport, $latitude, $longitude, $waypoints, $altitude, $heading, $groundspeed);
8810
						}
8811
					}
8812
					$ignoreImport = false;
8813
				}
8814
			} else {
8815
				if (!strstr($result->SearchBirdseyeInFlightResult->aircraft->origin, 'L ') && !strstr($result->SearchBirdseyeInFlightResult->aircraft->destination, 'L '))
8816
				{
8817
					foreach($globalAirportIgnore as $airportIgnore)
8818
					{
8819
						foreach($globalAirportIgnore as $airportIgnore)
8820
						{
8821
							if ($aircraft->origin == $airportIgnore || $aircraft->destination == $airportIgnore)
8822
							{
8823
								$ignoreImport = true; 
8824
							}
8825
						}
8826
						if ($ignoreImport == false)
8827
						{
8828
							$flightaware_id = $result->SearchBirdseyeInFlightResult->aircraft->faFlightID;
8829
							$ident = $result->SearchBirdseyeInFlightResult->aircraft->ident;
8830
							$aircraft_type = $result->SearchBirdseyeInFlightResult->aircraft->type;
8831
							$departure_airport = $result->SearchBirdseyeInFlightResult->aircraft->origin;
8832
							$arrival_airport = $result->SearchBirdseyeInFlightResult->aircraft->destination;
8833
							$latitude = $result->SearchBirdseyeInFlightResult->aircraft->latitude;
8834
							$longitude = $result->SearchBirdseyeInFlightResult->aircraft->longitude;
8835
							$waypoints = $result->SearchBirdseyeInFlightResult->aircraft->waypoints;
8836
							$altitude = $result->SearchBirdseyeInFlightResult->aircraft->altitude;
8837
							$heading = $result->SearchBirdseyeInFlightResult->aircraft->heading;
8838
							$groundspeed = $result->SearchBirdseyeInFlightResult->aircraft->groundspeed;
8839
							$dataFound = true;
8840
							//gets the callsign from the last hour
8841
							$last_hour_ident = $this->getIdentFromLastHour($ident);
8842
							//change the departure/arrival airport to NA if its not available
8843
							if ($departure_airport == "" || $departure_airport == "---" || $departure_airport == "ZZZ" || $departure_airport == "ZZZZ") { $departure_airport = "NA"; }
8844
							if ($arrival_airport == "" || $arrival_airport == "---" || $arrival_airport == "ZZZ" || $arrival_airport == "ZZZZ") { $arrival_airport = "NA"; }
8845
							//if there was no aircraft with the same callsign within the last hour and go post it into the archive
8846
							if($last_hour_ident == "")
8847
							{
8848
								//adds the spotter data for the archive
8849
								$Spotter->addSpotterData($flightaware_id, $ident, $aircraft_type, $departure_airport, $arrival_airport, $latitude, $longitude, $waypoints, $altitude, $heading, $groundspeed);
8850
							}
8851
							//adds the spotter LIVE data
8852
							$SpotterLive->addLiveSpotterData($flightaware_id, $ident, $aircraft_type, $departure_airport, $arrival_airport, $latitude, $longitude, $waypoints, $altitude, $heading, $groundspeed);
8853
						}
8854
						$ignoreImport = false;
8855
					}
8856
				}
8857
			}
8858
		} 
8859
	}
8860
*/
8861
8862
	// Update flights data when new data in DB
8863
	public function updateFieldsFromOtherTables()
8864
	{
8865
		global $globalDebug, $globalDBdriver;
8866
		$Image = new Image($this->db);
8867
		
8868
8869
		// routes
8870
		if ($globalDebug) print "Routes...\n";
8871
		if ($globalDBdriver == 'mysql') {
8872
			$query = "SELECT spotter_output.spotter_id, routes.FromAirport_ICAO, routes.ToAirport_ICAO FROM spotter_output, routes WHERE spotter_output.ident = routes.CallSign AND ( spotter_output.departure_airport_icao != routes.FromAirport_ICAO OR spotter_output.arrival_airport_icao != routes.ToAirport_ICAO) AND routes.FromAirport_ICAO != '' AND spotter_output.date >= DATE_SUB(UTC_TIMESTAMP(),INTERVAL 15 DAY)";
8873
		} else {
8874
			$query = "SELECT spotter_output.spotter_id, routes.FromAirport_ICAO, routes.ToAirport_ICAO FROM spotter_output, routes WHERE spotter_output.ident = routes.CallSign AND ( spotter_output.departure_airport_icao != routes.FromAirport_ICAO OR spotter_output.arrival_airport_icao != routes.ToAirport_ICAO) AND routes.FromAirport_ICAO != '' AND spotter_output.date >= now() AT TIME ZONE 'UTC' - INTERVAL '15 DAYS'";
8875
		}
8876
		$sth = $this->db->prepare($query);
8877
		$sth->execute();
8878
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
8879
		{
8880
			$departure_airport_array = $this->getAllAirportInfo($row['fromairport_icao']);
8881
			$arrival_airport_array = $this->getAllAirportInfo($row['toairport_icao']);
8882
			if (count($departure_airport_array) > 0 && count($arrival_airport_array) > 0) {
8883
				$update_query="UPDATE spotter_output SET departure_airport_icao = :fromicao, arrival_airport_icao = :toicao, departure_airport_name = :departure_airport_name, departure_airport_city = :departure_airport_city, departure_airport_country = :departure_airport_country, arrival_airport_name = :arrival_airport_name, arrival_airport_city = :arrival_airport_city, arrival_airport_country = :arrival_airport_country WHERE spotter_id = :spotter_id";
8884
				$sthu = $this->db->prepare($update_query);
8885
				$sthu->execute(array(':fromicao' => $row['fromairport_icao'],':toicao' => $row['toairport_icao'],':spotter_id' => $row['spotter_id'],':departure_airport_name' => $departure_airport_array[0]['name'],':departure_airport_city' => $departure_airport_array[0]['city'],':departure_airport_country' => $departure_airport_array[0]['country'],':arrival_airport_name' => $arrival_airport_array[0]['name'],':arrival_airport_city' => $arrival_airport_array[0]['city'],':arrival_airport_country' => $arrival_airport_array[0]['country']));
8886
			}
8887
		}
8888
		
8889
		if ($globalDebug) print "Airlines...\n";
8890
		//airlines
8891
		if ($globalDBdriver == 'mysql') {
8892
			$query  = "SELECT spotter_output.spotter_id, spotter_output.ident FROM spotter_output WHERE (spotter_output.airline_name = '' OR spotter_output.airline_name = 'Not Available') AND spotter_output.date >= DATE_SUB(UTC_TIMESTAMP(),INTERVAL 15 DAY)";
8893
		} elseif ($globalDBdriver == 'pgsql') {
8894
			$query  = "SELECT spotter_output.spotter_id, spotter_output.ident FROM spotter_output WHERE (spotter_output.airline_name = '' OR spotter_output.airline_name = 'Not Available') AND spotter_output.date >= now() AT TIME ZONE 'UTC' - INTERVAL '15 DAYS'";
8895
		}
8896
		$sth = $this->db->prepare($query);
8897
		$sth->execute();
8898
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
8899
		{
8900
			if (is_numeric(substr($row['ident'], -1, 1)))
8901
			{
8902
				$airline_array = $this->getAllAirlineInfo(substr($row['ident'], 0, 3));
8903
				if (isset($airline_array[0]['name'])) {
8904
					$update_query  = "UPDATE spotter_output SET spotter_output.airline_name = :airline_name, spotter_output.airline_icao = :airline_icao, spotter_output.airline_country = :airline_country, spotter_output.airline_type = :airline_type WHERE spotter_output.spotter_id = :spotter_id";
8905
					$sthu = $this->db->prepare($update_query);
8906
					$sthu->execute(array(':airline_name' => $airline_array[0]['name'],':airline_icao' => $airline_array[0]['icao'], ':airline_country' => $airline_array[0]['country'], ':airline_type' => $airline_array[0]['type'], ':spotter_id' => $row['spotter_id']));
8907
				}
8908
			}
8909
		}
8910
8911
		if ($globalDebug) print "Remove Duplicate in aircraft_modes...\n";
8912
		//duplicate modes
8913
		$query = "DELETE aircraft_modes FROM aircraft_modes LEFT OUTER JOIN (SELECT max(`AircraftID`) as `AircraftID`,`ModeS` FROM `aircraft_modes` group by ModeS) as KeepRows ON aircraft_modes.AircraftID = KeepRows.AircraftID WHERE KeepRows.AircraftID IS NULL";
8914
		$sth = $this->db->prepare($query);
8915
		$sth->execute();
8916
		
8917
		if ($globalDebug) print "Aircraft...\n";
8918
		//aircraft
8919
		if ($globalDBdriver == 'mysql') {
8920
			$query  = "SELECT spotter_output.spotter_id, spotter_output.aircraft_icao, spotter_output.registration FROM spotter_output WHERE (spotter_output.aircraft_name = '' OR spotter_output.aircraft_name = 'Not Available') AND spotter_output.date >= DATE_SUB(UTC_TIMESTAMP(),INTERVAL 7 DAY)";
8921
		} elseif ($globalDBdriver == 'pgsql') {
8922
			$query  = "SELECT spotter_output.spotter_id, spotter_output.aircraft_icao, spotter_output.registration FROM spotter_output WHERE (spotter_output.aircraft_name = '' OR spotter_output.aircraft_name = 'Not Available') AND spotter_output.date >= now() AT TIME ZONE 'UTC' - INERVAL '15 DAYS'";
8923
		}
8924
		$sth = $this->db->prepare($query);
8925
		$sth->execute();
8926
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
8927
		{
8928
			if ($row['aircraft_icao'] != '') {
8929
				$aircraft_name = $this->getAllAircraftInfo($row['aircraft_icao']);
8930
				if ($row['registration'] != ""){
8931
					$image_array = $Image->getSpotterImage($row['registration']);
8932
					if (count($image_array) == 0) {
8933
						$Image->addSpotterImage($row['registration']);
8934
					}
8935
				}
8936
				if (count($aircraft_name) > 0) {
8937
					$update_query  = "UPDATE spotter_output SET spotter_output.aircraft_name = :aircraft_name, spotter_output.aircraft_manufacturer = :aircraft_manufacturer WHERE spotter_output.spotter_id = :spotter_id";
8938
					$sthu = $this->db->prepare($update_query);
8939
					$sthu->execute(array(':aircraft_name' => $aircraft_name[0]['type'], ':aircraft_manufacturer' => $aircraft_name[0]['manufacturer'], ':spotter_id' => $row['spotter_id']));
8940
				}
8941
			}
8942
		}
8943
	}	
8944
8945
	// Update arrival airports for data already in DB
8946
	public function updateArrivalAirports()
8947
	{
8948
		global $globalDebug, $globalDBdriver, $globalClosestMinDist;
8949
		$query = "SELECT spotter_output.spotter_id, spotter_output.last_latitude, spotter_output.last_longitude, spotter_output.last_altitude, spotter_output.arrival_airport_icao, spotter_output.real_arrival_airport_icao FROM spotter_output";
8950
		$sth = $this->db->prepare($query);
8951
		$sth->execute();
8952
		while($row = $sth->fetch(PDO::FETCH_ASSOC))
8953
		{
8954
			if ($row['last_latitude'] != '' && $row['last_longitude'] != '') {
8955
				$closestAirports = $this->closestAirports($row['last_latitude'],$row['last_longitude'],$globalClosestMinDist);
8956
				$airport_icao = '';
8957
				 if (isset($closestAirports[0])) {
8958
					if ($row['arrival_airport_icao'] == $closestAirports[0]['icao']) {
8959
						$airport_icao = $closestAirports[0]['icao'];
8960
						if ($globalDebug) echo "\o/ 1st ---++ Find arrival airport. airport_icao : ".$airport_icao."\n";
8961
					} elseif (count($closestAirports > 1) && $row['arrival_airport_icao'] != '' && $row['arrival_airport_icao'] != 'NA') {
8962
						foreach ($closestAirports as $airport) {
8963
							if ($row['arrival_airport_icao'] == $airport['icao']) {
8964
								$airport_icao = $airport['icao'];
8965
								if ($globalDebug) echo "\o/ try --++ Find arrival airport. airport_icao : ".$airport_icao."\n";
8966
								break;
8967
							}
8968
						}
8969
					} elseif ($row['last_altitude'] == 0 || ($row['last_altitude'] != '' && ($closestAirports[0]['altitude'] <= $row['last_altitude']*100+1000 && $row['last_altitude']*100 < $closestAirports[0]['altitude']+5000))) {
8970
						$airport_icao = $closestAirports[0]['icao'];
8971
						if ($globalDebug) echo "\o/ NP --++ Find arrival airport. Airport ICAO : ".$airport_icao." !  Latitude : ".$row['last_latitude'].' - Longitude : '.$row['last_longitude'].' - MinDist : '.$globalClosestMinDist." - Airport altitude : ".$closestAirports[0]['altitude'].' - flight altitude : '.($row['last_altitude']*100)."\n";
8972
					} else {
8973
						if ($globalDebug) echo "----- Can't find arrival airport. Latitude : ".$row['last_latitude'].' - Longitude : '.$row['last_longitude'].' - MinDist : '.$globalClosestMinDist." - Airport altitude : ".$closestAirports[0]['altitude'].' - flight altitude : '.($row['last_altitude']*100)."\n";
8974
					}
8975
				} else {
8976
					if ($globalDebug) echo "----- No Airport near last coord. Latitude : ".$row['last_latitude'].' - Longitude : '.$row['last_longitude'].' - MinDist : '.$globalClosestMinDist."\n";
8977
				}
8978
				if ($row['real_arrival_airport_icao'] != $airport_icao) {
8979
					if ($globalDebug) echo "Updating airport to ".$airport_icao."...\n";
8980
					$update_query="UPDATE spotter_output SET real_arrival_airport_icao = :airport_icao WHERE spotter_id = :spotter_id";
8981
					$sthu = $this->db->prepare($update_query);
8982
					$sthu->execute(array(':airport_icao' => $airport_icao,':spotter_id' => $row['spotter_id']));
8983
				}
8984
			}
8985
		}
8986
	}
8987
	
8988
	public function closestAirports($origLat,$origLon,$dist = 10) {
8989
		global $globalDBdriver;
8990
		$dist = number_format($dist*0.621371,2,'.',''); // convert km to mile
8991
/*
8992
		$query="SELECT name, icao, latitude, longitude, altitude, 3956 * 2 * ASIN(SQRT( POWER(SIN(($origLat - abs(latitude))*pi()/180/2),2)+COS( $origLat *pi()/180)*COS(abs(latitude)*pi()/180)*POWER(SIN(($origLon-longitude)*pi()/180/2),2))) as distance 
8993
                      FROM airport WHERE longitude between ($origLon-$dist/abs(cos(radians($origLat))*69)) and ($origLon+$dist/abs(cos(radians($origLat))*69)) and latitude between ($origLat-($dist/69)) and ($origLat+($dist/69)) 
8994
                      having distance < $dist ORDER BY distance limit 100;";
8995
*/
8996
		if ($globalDBdriver == 'mysql') {
8997
			$query="SELECT name, icao, latitude, longitude, altitude, 3956 * 2 * ASIN(SQRT( POWER(SIN(($origLat - latitude)*pi()/180/2),2)+COS( $origLat *pi()/180)*COS(latitude*pi()/180)*POWER(SIN(($origLon-longitude)*pi()/180/2),2))) as distance 
8998
	                      FROM airport WHERE longitude between ($origLon-$dist/cos(radians($origLat))*69) and ($origLon+$dist/cos(radians($origLat)*69)) and latitude between ($origLat-($dist/69)) and ($origLat+($dist/69)) 
8999
	                      AND (3956 * 2 * ASIN(SQRT( POWER(SIN(($origLat - latitude)*pi()/180/2),2)+COS( $origLat *pi()/180)*COS(latitude*pi()/180)*POWER(SIN(($origLon-longitude)*pi()/180/2),2)))) < $dist ORDER BY distance limit 100;";
9000
                } else {
9001
			$query="SELECT name, icao, latitude, longitude, altitude, 3956 * 2 * ASIN(SQRT( POWER(SIN(($origLat - CAST(latitude as double precision))*pi()/180/2),2)+COS( $origLat *pi()/180)*COS(CAST(latitude as double precision)*pi()/180)*POWER(SIN(($origLon-CAST(longitude as double precision))*pi()/180/2),2))) as distance 
9002
	                      FROM airport WHERE CAST(longitude as double precision) between ($origLon-$dist/cos(radians($origLat))*69) and ($origLon+$dist/cos(radians($origLat))*69) and CAST(latitude as double precision) between ($origLat-($dist/69)) and ($origLat+($dist/69)) 
9003
	                      AND (3956 * 2 * ASIN(SQRT( POWER(SIN(($origLat - CAST(latitude as double precision))*pi()/180/2),2)+COS( $origLat *pi()/180)*COS(CAST(latitude as double precision)*pi()/180)*POWER(SIN(($origLon-CAST(longitude as double precision))*pi()/180/2),2)))) < $dist ORDER BY distance limit 100;";
9004
    		}
9005
		$sth = $this->db->prepare($query);
9006
		$sth->execute();
9007
		return $sth->fetchAll(PDO::FETCH_ASSOC);
9008
	}
9009
}
9010
/*
9011
$Spotter = new Spotter();
9012
print_r($Spotter->closestAirports('-19.9813','-47.8286',10));
9013
*/
9014
/*
9015
$Spotter = new Spotter();
9016
$da = $Spotter->countAllDetectedArrivalAirports(true,0,'',true);
9017
$aa = $Spotter->countAllArrivalAirports(true,0,'',true);
9018
print_r($da);
9019
print_r($aa);
9020
print_r(array_merge($da,$aa));
9021
*/
9022
?>