← Back to branch summary

~vcs-imports/helix/helix

« back to all changes in this revision

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