← Back to branch summary

~vcs-imports/helix/helix

« back to all changes in this revision

Viewing changes to trunk/modules/Calendar/Generated/Objects/EventdateTable.php

  • Committer: damianobrien
  • Date: 2015-06-12 05:13:06 UTC
  • Revision ID: svn-v4:05b9009a-c606-4cef-bdc0-1359a4facf5f::417

Show diffs side-by-side

added added

removed removed

Lines of Context:
trunk/modules/Calendar/Generated/Objects/EventdateTable.php
 
1
<?php
 
2
/**
 
3
 * DO NOT EDIT -- This is an auto-generated class from the Helix Class Generator
 
4
 * 
 
5
 * This class represents the eventdate table in the Helix database schema.
 
6
 * Use this class to select, insert, update and delete data in the eventdate
 
7
 * table, as well as access related data in other tables.
 
8
 * 
 
9
 * If you need to extend the functionality of this class, code should be placed in a
 
10
 * class called EventdateExtension, and should extend the EventdateTable
 
11
 * class.  The custom code file should be in the helix/modules/Calendar folder
 
12
 * and should be called EventdateExtension.php
 
13
 * 
 
14
 * Object -> Eventdate
 
15
 */
 
16
class EventdateTable extends Object {
 
17
        public $logSequence;
 
18
        public $fdate;
 
19
        public $tdate;
 
20
 
 
21
        protected $_cache = array();
 
22
        protected $_initial = array();
 
23
        protected $_snapshot;
 
24
 
 
25
        public $id;
 
26
        public $value;
 
27
        public $updatedById;
 
28
        public $mdate;
 
29
        public $cdate;
 
30
        public $deleted;
 
31
 
 
32
        public function __construct($id=null) {
 
33
                $db = Database::getInstance();
 
34
                $this->id = $id;
 
35
                $this->value = null;
 
36
                $this->updatedById = null;
 
37
                $this->mdate = new Date();
 
38
                $this->cdate = new Date();
 
39
                $this->deleted = false;
 
40
 
 
41
                if (isset($id)) {
 
42
                        $condition = "{$db->le}eventdate{$db->re}.{$db->le}id{$db->re}={$db->queryValue($id)}";
 
43
                }
 
44
 
 
45
                if (isset($condition)) {
 
46
                        $query = implode(NL, array(
 
47
                                "SELECT {$db->le}eventdate{$db->re}.{$db->le}id{$db->re}, {$db->le}eventdate{$db->re}.{$db->le}value{$db->re}, {$db->le}eventdate{$db->re}.{$db->le}updated_by_id{$db->re}, {$db->le}eventdate{$db->re}.{$db->le}mdate{$db->re}, {$db->le}eventdate{$db->re}.{$db->le}cdate{$db->re}, {$db->le}eventdate{$db->re}.{$db->le}deleted{$db->re}",
 
48
                                "FROM {$db->le}eventdate{$db->re}",
 
49
                                "WHERE {$condition}"
 
50
                        ));
 
51
 
 
52
                        $db->query($query);
 
53
 
 
54
                        if ($db->getRecord() && $db->getNumRows()===1) {
 
55
                                $this->id = $db->record["id"];
 
56
                                $this->value = is_null(($db->record["value"]))?null:new Date($db->record["value"]);
 
57
                                $this->updatedById = $db->record["updated_by_id"];
 
58
                                $this->mdate = is_null(($db->record["mdate"]))?null:new Date($db->record["mdate"]);
 
59
                                $this->cdate = is_null(($db->record["cdate"]))?null:new Date($db->record["cdate"]);
 
60
                                $this->deleted = $db->record["deleted"];
 
61
                        } else {
 
62
                                $this->id = null;
 
63
                        }
 
64
                }
 
65
 
 
66
                $this->_initial["id"] = $this->id;
 
67
                $this->_initial["value"] = $this->value;
 
68
                $this->_initial["deleted"] = $this->deleted;
 
69
        }
 
70
 
 
71
        public static function snapshot($date, $id=null) {
 
72
                $object = new Eventdate();
 
73
                $object->_snapshot = $date;
 
74
                $db = Database::getInstance();
 
75
                $database = $db->getDatabase();
 
76
                $db->changeDatabase($database . "_log");
 
77
 
 
78
                if (isset($id)) {
 
79
                        $condition = "{$db->le}eventdate{$db->re}.{$db->le}id{$db->re}={$db->queryValue($id)}";
 
80
                }
 
81
 
 
82
                if (isset($condition)) {
 
83
                        $condition .= " AND ({$db->le}eventdate{$db->re}.{$db->le}tdate{$db->re} IS NOT NULL AND {$db->le}eventdate{$db->re}.{$db->le}fdate{$db->re}<={$db->queryValue($date)} AND {$db->queryValue($date)}<={$db->le}eventdate{$db->re}.{$db->le}tdate{$db->re}) ";
 
84
                        $query = implode(NL, array(
 
85
                                "SELECT {$db->le}eventdate{$db->re}.{$db->le}log_sequence{$db->re}, {$db->le}eventdate{$db->re}.{$db->le}fdate{$db->re}, {$db->le}eventdate{$db->re}.{$db->le}tdate{$db->re}, {$db->le}eventdate{$db->re}.{$db->le}id{$db->re}, {$db->le}eventdate{$db->re}.{$db->le}value{$db->re}, {$db->le}eventdate{$db->re}.{$db->le}updated_by_id{$db->re}, {$db->le}eventdate{$db->re}.{$db->le}mdate{$db->re}, {$db->le}eventdate{$db->re}.{$db->le}cdate{$db->re}, {$db->le}eventdate{$db->re}.{$db->le}deleted{$db->re}",
 
86
                                "FROM {$db->le}eventdate{$db->re}",
 
87
                                "WHERE {$condition}"
 
88
                        ));
 
89
 
 
90
                        $query .= "ORDER BY {$db->le}eventdate{$db->re}.log_sequence desc limit 1";
 
91
                        $db->query($query);
 
92
 
 
93
                        if ($db->getRecord() && $db->getNumRows()===1) {
 
94
                                $object->logSequence = $db->record["log_sequence"];
 
95
                                $object->fdate = new Date($db->record["fdate"]);
 
96
                                $object->tdate = new Date($db->record["tdate"]);
 
97
                                $object->id = $db->record["id"];
 
98
                                $object->value = is_null(($db->record["value"]))?null:new Date($db->record["value"]);
 
99
                                $object->updatedById = $db->record["updated_by_id"];
 
100
                                $object->mdate = is_null(($db->record["mdate"]))?null:new Date($db->record["mdate"]);
 
101
                                $object->cdate = is_null(($db->record["cdate"]))?null:new Date($db->record["cdate"]);
 
102
                                $object->deleted = $db->record["deleted"];
 
103
                        } else {
 
104
                                $object->id = null;
 
105
                        }
 
106
                }
 
107
                
 
108
                $db->changeDatabase($database);
 
109
                return $object;
 
110
        }
 
111
 
 
112
        public function __call($method, $arguments) {
 
113
                if (preg_match('/^set(.*)$/', $method, $matches)) {
 
114
                        $property = lcfirst($matches[1]);
 
115
                        $this->{$property} = $arguments[0];
 
116
                }
 
117
                return $this;
 
118
        }
 
119
 
 
120
        public function __get($property) {
 
121
                if (method_exists($this, "get{$property}")) {
 
122
                        return $this->{"get{$property}"}();
 
123
                } else if (strstr($property, "_")) {
 
124
                        list($type, $method) = explode("_", $property, 2);
 
125
                        return method_exists($this, "get{$method}") ? $this->{"get{$method}"}($type) : null;
 
126
                } else {
 
127
                        return null;
 
128
                }
 
129
        }
 
130
 
 
131
        public function __set($property, $value) {
 
132
                if (isset($this->_snapshot)) {return false;}
 
133
                if (method_exists($this, "set{$property}")) {
 
134
                        $this->{"set{$property}"}($value);
 
135
                } else if (strstr($property, "_")) {
 
136
                        list($type, $method) = explode("_", $property, 2);
 
137
                        if (method_exists($this, "set{$method}")) {
 
138
                                $this->{"set{$method}"}($value, $type);
 
139
                        }
 
140
                }
 
141
                return $this;
 
142
        }
 
143
 
 
144
        public function isDirty() {
 
145
                $isDirty = false;
 
146
 
 
147
                $isDirty = $isDirty || ((int)$this->id !== (int)$this->_initial["id"]);
 
148
                $isDirty = $isDirty || ((string)$this->value != (string)$this->_initial["value"]);
 
149
                $isDirty = $isDirty || ((int)$this->deleted !== (int)$this->_initial["deleted"]);
 
150
 
 
151
                return $isDirty;
 
152
        }
 
153
 
 
154
        public function save() {
 
155
                if (isset($this->_snapshot)) {return false;}
 
156
                $status = $this->id>0 ? $this->update() : $this->insert();
 
157
 
 
158
                foreach ($this->_cache as $class=>$list) {
 
159
                        foreach ($list as $type=>$object) {
 
160
                                $object->save();
 
161
                                $this->{"add" . $object->getClass()}($object, $type);
 
162
                        }
 
163
                        unset($this->_cache[$class]);
 
164
                }
 
165
 
 
166
                return $status;
 
167
        }
 
168
 
 
169
        public function insert() {
 
170
                if (isset($this->_snapshot)) {return false;}
 
171
                global $session, $config;
 
172
 
 
173
                $db = Database::getInstance();
 
174
                $query = implode(NL, array(
 
175
                        "INSERT INTO {$db->le}eventdate{$db->re} (",
 
176
                        "       {$db->le}value{$db->re}, {$db->le}updated_by_id{$db->re}, {$db->le}mdate{$db->re}, {$db->le}cdate{$db->re}, {$db->le}deleted{$db->re}",
 
177
                        ") VALUES (",
 
178
                                $db->queryValue($this->value) . ",",
 
179
                                $db->queryValue((int)$session->getUserId()) . ",",
 
180
                                $db->queryValue(timestamp()) . ",",
 
181
                                $db->queryValue(timestamp()) . ",",
 
182
                                $db->queryValue(is_null($this->deleted)?null:(int)$this->deleted),
 
183
                        ")"
 
184
                ));
 
185
                $status = $db->query($query);
 
186
                $this->id = $db->getInsertedId();
 
187
 
 
188
                if ($config["enable_database_log"]) {
 
189
                        $this->log();
 
190
                }
 
191
 
 
192
                return $status;
 
193
        }
 
194
 
 
195
        public function update() {
 
196
                if (isset($this->_snapshot)) {return false;}
 
197
                global $session, $config;
 
198
 
 
199
                if ($this->isDirty()) {
 
200
                        $db = Database::getInstance();
 
201
                        $query = implode(NL, array(
 
202
                                "UPDATE {$db->le}eventdate{$db->re} SET",
 
203
                                        "{$db->le}value{$db->re}={$db->queryValue($this->value)},",
 
204
                                        "{$db->le}updated_by_id{$db->re}={$db->queryValue((int)$session->getUserId())},",
 
205
                                        "{$db->le}mdate{$db->re}={$db->queryValue(timestamp())},",
 
206
                                        "{$db->le}deleted{$db->re}={$db->queryValue(is_null($this->deleted)?null:(int)$this->deleted)}",
 
207
                                "WHERE id={$db->queryValue((int)$this->id)}"
 
208
                        ));
 
209
                        $status = $db->query($query);
 
210
 
 
211
                        if ($config["enable_database_log"]) {
 
212
                                $this->log();
 
213
                        }
 
214
 
 
215
                        return $status;
 
216
                } else {
 
217
                        return false;
 
218
                }
 
219
        }
 
220
 
 
221
        protected function log() {
 
222
                if (isset($this->_snapshot)) {return false;}
 
223
                parent::log();
 
224
                $db = Database::getInstance();
 
225
                $database = $db->getDatabase();
 
226
                $record = Eventdate::select($db->encapsulate("eventdate") . ".mdate as fdate,null as tdate,{$db->encapsulate("eventdate")}.*",null,$db->encapsulate("eventdate").".id={$this->id}")->first();
 
227
                $log = "{$database}_log";
 
228
                $dbLog = Database::getInstance(null,null,null,null,$log);
 
229
                foreach($record as $k=>$v){
 
230
                    if(!is_int($v)){
 
231
                        $record[$k] = $dbLog->queryValue($v);
 
232
                    }
 
233
                }
 
234
                $insertColumns = $dbLog->le.implode("{$dbLog->le},{$dbLog->re}",array_keys($record)).$dbLog->re;
 
235
                $insertValues = implode(",",$record);
 
236
                $query = implode(NL, array(
 
237
                        "INSERT INTO {$dbLog->le}eventdate{$dbLog->re} (",
 
238
                        $insertColumns,
 
239
                        ") VALUES (",
 
240
                        $insertValues,
 
241
                        ")"
 
242
                ));
 
243
                $status = $dbLog->query($query);
 
244
 
 
245
                $logSequence = $dbLog->getInsertedId();
 
246
 
 
247
                if ($logSequence){
 
248
                        $query = implode(NL, array(
 
249
                                "SELECT {$dbLog->le}log_sequence{$dbLog->re}",
 
250
                                "FROM {$dbLog->le}eventdate{$dbLog->re}",
 
251
                                "WHERE {$dbLog->le}eventdate{$dbLog->re}.{$dbLog->le}id{$dbLog->re}={$this->id}",
 
252
                                "       AND {$dbLog->le}log_sequence{$dbLog->re}<{$logSequence}",
 
253
                                "ORDER BY {$dbLog->le}log_sequence{$dbLog->re} DESC",
 
254
                                $dbLog::limitOffsetString(1,0)
 
255
                        ));
 
256
                        $dbLog->query($query);
 
257
 
 
258
                        if ($dbLog->getRecord()) {
 
259
                                $updateSequence = (int)$dbLog->record["log_sequence"];
 
260
                                $query = implode(NL, array(
 
261
                                        "UPDATE {$dbLog->le}eventdate{$dbLog->re}",
 
262
                                        "SET {$dbLog->le}tdate{$dbLog->re}={$record["mdate"]}",
 
263
                                        "where log_sequence={$updateSequence}"
 
264
                                ));
 
265
                                $dbLog->query($query);
 
266
                        }
 
267
                }
 
268
                $db->changeDatabase($database);
 
269
                return $status;
 
270
        }
 
271
 
 
272
        public function delete() {
 
273
                if (isset($this->_snapshot)) {return false;}
 
274
                $this->deleted = true;
 
275
                $status = $this->update();
 
276
                return $status;
 
277
        }
 
278
 
 
279
        public function unDelete() {
 
280
                if (isset($this->_snapshot)) {return false;}
 
281
                $this->deleted = false;
 
282
                $status = $this->update();
 
283
                return $status;
 
284
        }
 
285
 
 
286
        public function purge() {
 
287
                if (isset($this->_snapshot)) {return false;}
 
288
                $db = Database::getInstance();
 
289
                $query = "DELETE FROM " . $db->encapsulate("eventdate") . " WHERE id={$db->queryValue($this->id)}";
 
290
                $status = $db->query($query);
 
291
                return $status;
 
292
        }
 
293
 
 
294
        public static function deleteAll($where=null) {
 
295
                $db = Database::getInstance();
 
296
                $condition = isset($where) ? "WHERE {$where}" : "";
 
297
                $query = "UPDATE " . $db->encapsulate("eventdate") . " SET deleted=1 {$condition}";
 
298
                $status = $db->query($query);
 
299
                return $status;
 
300
        }
 
301
 
 
302
        public static function select($columns, $order=null, $where=null, $limit=null, $offset=0) {
 
303
                $db = Database::getInstance();
 
304
 
 
305
                $records = array();
 
306
                $columns = is_array($columns) ? $columns : explode(",", $columns);
 
307
 
 
308
                $query = implode(NL, array(
 
309
                        "SELECT " . implode(",", $columns),
 
310
                        "FROM {$db->le}eventdate{$db->le}",
 
311
 
 
312
                        "WHERE {$db->le}eventdate{$db->re}.{$db->le}deleted{$db->re}=0" . (isset($where) ? " AND ({$where})" : ""),
 
313
                        (isset($order) ? "ORDER BY {$order}" : ""),
 
314
                        (isset($limit) ? $db::limitOffsetString($limit,$offset) : "")
 
315
                ));
 
316
 
 
317
                $db->query($query);
 
318
 
 
319
                if (count($columns)>1) {
 
320
                        while ($db->getRecord()) {
 
321
                                $records[] = $db->record;
 
322
                        }
 
323
                } else {
 
324
                        while ($db->getRecord(false)) {
 
325
                                $records[] = $db->record[0];
 
326
                        }
 
327
                }
 
328
 
 
329
                return new Collection($records);
 
330
        }
 
331
 
 
332
        public static function ids($order=null, $where=null, $limit=null, $offset=0) {
 
333
                $db = Database::getInstance();
 
334
                return Eventdate::select("{$db->le}eventdate{$db->le}.id", $order, $where, $limit, $offset);
 
335
        }
 
336
 
 
337
        public static function objects($order=null, $where=null, $limit=null, $offset=0) {
 
338
                $db = Database::getInstance();
 
339
                $objects = array();
 
340
                foreach (Eventdate::select("{$db->le}eventdate{$db->re}.{$db->le}id{$db->re}, {$db->le}eventdate{$db->re}.{$db->le}value{$db->re}, {$db->le}eventdate{$db->re}.{$db->le}updated_by_id{$db->re}, {$db->le}eventdate{$db->re}.{$db->le}mdate{$db->re}, {$db->le}eventdate{$db->re}.{$db->le}cdate{$db->re}, {$db->le}eventdate{$db->re}.{$db->le}deleted{$db->re}", $order, $where, $limit, $offset) as $record) {
 
341
                        $object = new Eventdate();
 
342
                                $object->id = $record["id"];
 
343
                                $object->value = is_null(($record["value"]))?null:new Date($record["value"]);
 
344
                                $object->updatedById = $record["updated_by_id"];
 
345
                                $object->mdate = is_null(($record["mdate"]))?null:new Date($record["mdate"]);
 
346
                                $object->cdate = is_null(($record["cdate"]))?null:new Date($record["cdate"]);
 
347
                                $object->deleted = $record["deleted"];
 
348
                        $objects[] = $object;
 
349
                }
 
350
                return new Collection($objects);
 
351
        }
 
352
 
 
353
        public static function search($query=null, $order=null, $where=null, $limit=null, $offset=0) {
 
354
                $keywords = array();
 
355
                $clauses = array();
 
356
 
 
357
                preg_match_all('/"([^"]+)"/i', $query, $matches, PREG_SET_ORDER);
 
358
                foreach ($matches as $match) {
 
359
                        $keywords[] = $match[1];
 
360
                }
 
361
 
 
362
                $query = preg_replace('/"[^"]+"/i', '', $query);
 
363
                foreach (preg_split('/ +/i',$query) as $keyword) {
 
364
                        $keywords[] = $keyword;
 
365
                }
 
366
 
 
367
                foreach ($keywords as $keyword) {
 
368
                        $clauses[] = "id LIKE '%{$keyword}%'";
 
369
                }
 
370
 
 
371
                $search = implode(" AND ", $clauses);
 
372
                $where = isset($where) ? "{$where} AND ({$search})" : "({$search})";
 
373
                return Eventdate::objects($order, $where, $limit, $offset);
 
374
        }
 
375
 
 
376
        public function __toString() {
 
377
                return "Eventdate Object [" . alt($this->id, "null") . "]";
 
378
        }
 
379
 
 
380
        public function string() {
 
381
                return $this->__toString();
 
382
        }
 
383
 
 
384
 
 
385
        public function getEventEventdate($eventId, $type="default") {
 
386
                return new EventEventdate(null, $eventId, $this->id, EventEventdate::typeId($type));
 
387
        }
 
388
 
 
389
 
 
390
        public function setEvent($event=null, $type="default") {
 
391
                if (isset($this->_snapshot)) {return false;}
 
392
                $this->removeEventList($type);
 
393
                $this->addEvent($event, $type);
 
394
                return $this;
 
395
        }
 
396
        public function removeEvent($event, $type="default", $deleteObject=true) {
 
397
                if (isset($this->_snapshot)) {return false;}
 
398
                $list = is_array($event) ? $event : array($event);
 
399
                foreach ($list as $item) {
 
400
                        $id = is_object($item) ? $item->id : $item;
 
401
                        $relationship = $this->getEventEventdate($id, $type);
 
402
                        if ($deleteObject) {
 
403
                                $relationship->getEvent()->delete();
 
404
                        }
 
405
                        $relationship->delete();
 
406
                }
 
407
                return $this;
 
408
        }
 
409
        public function removeEventList($type=null) {
 
410
                if (isset($this->_snapshot)) {return false;}
 
411
                if ($this->id>0) {
 
412
                        return EventEventdate::deleteAll(null, $this->id, $type);
 
413
                }
 
414
        }
 
415
        public function addEvent($event=null, $type="default") {
 
416
                if (isset($this->_snapshot)) {return false;}
 
417
                if (isset($event)) {
 
418
                        if (!$this->id) {
 
419
                                $this->save();
 
420
                        }
 
421
                        $list = is_array($event) ? $event : array($event);
 
422
                        $order = 0;
 
423
                        foreach ($list as $item) {
 
424
                                if (is_object($item) && !$item->id) {
 
425
                                        $item->save();
 
426
                                }
 
427
                                $id = is_object($item) ? $item->id : $item;
 
428
                                $relationship = $this->getEventEventdate($id, $type);
 
429
                                $relationship->deleted = false;
 
430
                                $relationship->save();
 
431
                        }
 
432
                }
 
433
                return $this;
 
434
        }
 
435
        public function getEvent($type="default") {
 
436
                if (isset($this->_cache["Event"]) && isset($this->_cache["Event"][$type])) {
 
437
                        $event = $this->_cache["Event"][$type];
 
438
                } else {
 
439
                        $event = new Event($this->getEventId($type));
 
440
                }
 
441
                $this->_cache["Event"][$type] = $event;
 
442
                return $this->_cache["Event"][$type];
 
443
        }
 
444
        public function getEventList($type=null, $order=null, $where=null, $limit=null, $offset=0, $primary=false) {
 
445
                $db = Database::getInstance();
 
446
                $ids = $this->getEventIds($type, $order, $where, $limit, $offset, $primary);
 
447
                $list = $ids->count()===0 ? new Collection() : Event::objects($order, "{$db->le}event{$db->le}.{$db->re}id{$db->re} IN (" . $ids->join(",") . ")");
 
448
                return $list;
 
449
        }
 
450
        public function getEventId($type="default") {
 
451
                return $this->getEventIds($type)->get(0);
 
452
        }
 
453
        public function getEventIds($type=null, $order=null, $where=null, $limit=null, $offset=0, $primary=false) {
 
454
                $db = Database::getInstance();
 
455
                $ids = array();
 
456
                
 
457
                if (isset($this->_snapshot)) {
 
458
                        $date = $this->_snapshot;
 
459
                        $condition = " {$db->le}event{$db->re}.{$db->le}tdate{$db->re} IS NOT NULL AND {$db->le}event{$db->re}.{$db->le}fdate{$db->re}<={$db->queryValue($date)} AND {$db->queryValue($date)}<={$db->le}event{$db->re}.{$db->le}tdate{$db->re} ";
 
460
                        $where = isset($where) ? "{$where} AND ({$condition})" : $condition;
 
461
                }
 
462
                
 
463
                $query = implode(NL, array(
 
464
                        "SELECT {$db->le}event{$db->re}.{$db->le}id{$db->re} ",
 
465
                        "FROM {$db->le}event{$db->re} ",
 
466
                        "INNER JOIN {$db->le}event_eventdate{$db->re} ON {$db->le}event_eventdate{$db->re}.{$db->le}event_id{$db->re}={$db->le}event{$db->re}.{$db->le}id{$db->re} ",
 
467
                        "       AND {$db->le}event_eventdate{$db->re}.{$db->le}deleted{$db->re}=0 ",
 
468
                        "       AND {$db->le}event{$db->re}.{$db->le}deleted{$db->re}=0 ",
 
469
                        "       AND {$db->le}event_eventdate{$db->re}.{$db->le}eventdate_id{$db->re}={$db->queryValue($this->id)} ",
 
470
                        (isset($type) ? "       AND {$db->le}event_eventdate{$db->re}.{$db->le}event_eventdate_type_id{$db->re}=" . $db->queryValue(EventEventdate::typeId($type)) . " " : ""),
 
471
                        ($primary ? "   AND {$db->le}event_eventdate{$db->re}.{$db->le}primary{$db->re}=1 " : ""),
 
472
                        (isset($where) ? " WHERE {$where} " : ""),
 
473
                        (isset($order) ? " ORDER BY {$order}" : ""),
 
474
                        (isset($limit) ? $db::limitOffsetString($limit,$offset) : "")
 
475
                ));
 
476
                
 
477
                $db->query($query);
 
478
                
 
479
                while ($db->getRecord()) {
 
480
                        $ids[] = $db->record["id"];
 
481
                }
 
482
                
 
483
                return new Collection($ids);
 
484
        }
 
485
 
 
486
}
 
487
?>
 
 
b'\\ No newline at end of file'