1: <?php
2:
3: namespace Thelia\Model\om;
4:
5: use \Criteria;
6: use \Exception;
7: use \ModelCriteria;
8: use \ModelJoin;
9: use \PDO;
10: use \Propel;
11: use \PropelCollection;
12: use \PropelException;
13: use \PropelObjectCollection;
14: use \PropelPDO;
15: use Thelia\Model\Category;
16: use Thelia\Model\Content;
17: use Thelia\Model\Document;
18: use Thelia\Model\DocumentI18n;
19: use Thelia\Model\DocumentPeer;
20: use Thelia\Model\DocumentQuery;
21: use Thelia\Model\Folder;
22: use Thelia\Model\Product;
23:
24: /**
25: * Base class that represents a query for the 'document' table.
26: *
27: *
28: *
29: * @method DocumentQuery orderById($order = Criteria::ASC) Order by the id column
30: * @method DocumentQuery orderByProductId($order = Criteria::ASC) Order by the product_id column
31: * @method DocumentQuery orderByCategoryId($order = Criteria::ASC) Order by the category_id column
32: * @method DocumentQuery orderByFolderId($order = Criteria::ASC) Order by the folder_id column
33: * @method DocumentQuery orderByContentId($order = Criteria::ASC) Order by the content_id column
34: * @method DocumentQuery orderByFile($order = Criteria::ASC) Order by the file column
35: * @method DocumentQuery orderByPosition($order = Criteria::ASC) Order by the position column
36: * @method DocumentQuery orderByCreatedAt($order = Criteria::ASC) Order by the created_at column
37: * @method DocumentQuery orderByUpdatedAt($order = Criteria::ASC) Order by the updated_at column
38: *
39: * @method DocumentQuery groupById() Group by the id column
40: * @method DocumentQuery groupByProductId() Group by the product_id column
41: * @method DocumentQuery groupByCategoryId() Group by the category_id column
42: * @method DocumentQuery groupByFolderId() Group by the folder_id column
43: * @method DocumentQuery groupByContentId() Group by the content_id column
44: * @method DocumentQuery groupByFile() Group by the file column
45: * @method DocumentQuery groupByPosition() Group by the position column
46: * @method DocumentQuery groupByCreatedAt() Group by the created_at column
47: * @method DocumentQuery groupByUpdatedAt() Group by the updated_at column
48: *
49: * @method DocumentQuery leftJoin($relation) Adds a LEFT JOIN clause to the query
50: * @method DocumentQuery rightJoin($relation) Adds a RIGHT JOIN clause to the query
51: * @method DocumentQuery innerJoin($relation) Adds a INNER JOIN clause to the query
52: *
53: * @method DocumentQuery leftJoinProduct($relationAlias = null) Adds a LEFT JOIN clause to the query using the Product relation
54: * @method DocumentQuery rightJoinProduct($relationAlias = null) Adds a RIGHT JOIN clause to the query using the Product relation
55: * @method DocumentQuery innerJoinProduct($relationAlias = null) Adds a INNER JOIN clause to the query using the Product relation
56: *
57: * @method DocumentQuery leftJoinCategory($relationAlias = null) Adds a LEFT JOIN clause to the query using the Category relation
58: * @method DocumentQuery rightJoinCategory($relationAlias = null) Adds a RIGHT JOIN clause to the query using the Category relation
59: * @method DocumentQuery innerJoinCategory($relationAlias = null) Adds a INNER JOIN clause to the query using the Category relation
60: *
61: * @method DocumentQuery leftJoinContent($relationAlias = null) Adds a LEFT JOIN clause to the query using the Content relation
62: * @method DocumentQuery rightJoinContent($relationAlias = null) Adds a RIGHT JOIN clause to the query using the Content relation
63: * @method DocumentQuery innerJoinContent($relationAlias = null) Adds a INNER JOIN clause to the query using the Content relation
64: *
65: * @method DocumentQuery leftJoinFolder($relationAlias = null) Adds a LEFT JOIN clause to the query using the Folder relation
66: * @method DocumentQuery rightJoinFolder($relationAlias = null) Adds a RIGHT JOIN clause to the query using the Folder relation
67: * @method DocumentQuery innerJoinFolder($relationAlias = null) Adds a INNER JOIN clause to the query using the Folder relation
68: *
69: * @method DocumentQuery leftJoinDocumentI18n($relationAlias = null) Adds a LEFT JOIN clause to the query using the DocumentI18n relation
70: * @method DocumentQuery rightJoinDocumentI18n($relationAlias = null) Adds a RIGHT JOIN clause to the query using the DocumentI18n relation
71: * @method DocumentQuery innerJoinDocumentI18n($relationAlias = null) Adds a INNER JOIN clause to the query using the DocumentI18n relation
72: *
73: * @method Document findOne(PropelPDO $con = null) Return the first Document matching the query
74: * @method Document findOneOrCreate(PropelPDO $con = null) Return the first Document matching the query, or a new Document object populated from the query conditions when no match is found
75: *
76: * @method Document findOneByProductId(int $product_id) Return the first Document filtered by the product_id column
77: * @method Document findOneByCategoryId(int $category_id) Return the first Document filtered by the category_id column
78: * @method Document findOneByFolderId(int $folder_id) Return the first Document filtered by the folder_id column
79: * @method Document findOneByContentId(int $content_id) Return the first Document filtered by the content_id column
80: * @method Document findOneByFile(string $file) Return the first Document filtered by the file column
81: * @method Document findOneByPosition(int $position) Return the first Document filtered by the position column
82: * @method Document findOneByCreatedAt(string $created_at) Return the first Document filtered by the created_at column
83: * @method Document findOneByUpdatedAt(string $updated_at) Return the first Document filtered by the updated_at column
84: *
85: * @method array findById(int $id) Return Document objects filtered by the id column
86: * @method array findByProductId(int $product_id) Return Document objects filtered by the product_id column
87: * @method array findByCategoryId(int $category_id) Return Document objects filtered by the category_id column
88: * @method array findByFolderId(int $folder_id) Return Document objects filtered by the folder_id column
89: * @method array findByContentId(int $content_id) Return Document objects filtered by the content_id column
90: * @method array findByFile(string $file) Return Document objects filtered by the file column
91: * @method array findByPosition(int $position) Return Document objects filtered by the position column
92: * @method array findByCreatedAt(string $created_at) Return Document objects filtered by the created_at column
93: * @method array findByUpdatedAt(string $updated_at) Return Document objects filtered by the updated_at column
94: *
95: * @package propel.generator.Thelia.Model.om
96: */
97: abstract class BaseDocumentQuery extends ModelCriteria
98: {
99: /**
100: * Initializes internal state of BaseDocumentQuery object.
101: *
102: * @param string $dbName The dabase name
103: * @param string $modelName The phpName of a model, e.g. 'Book'
104: * @param string $modelAlias The alias for the model in this query, e.g. 'b'
105: */
106: public function __construct($dbName = 'thelia', $modelName = 'Thelia\\Model\\Document', $modelAlias = null)
107: {
108: parent::__construct($dbName, $modelName, $modelAlias);
109: }
110:
111: /**
112: * Returns a new DocumentQuery object.
113: *
114: * @param string $modelAlias The alias of a model in the query
115: * @param DocumentQuery|Criteria $criteria Optional Criteria to build the query from
116: *
117: * @return DocumentQuery
118: */
119: public static function create($modelAlias = null, $criteria = null)
120: {
121: if ($criteria instanceof DocumentQuery) {
122: return $criteria;
123: }
124: $query = new DocumentQuery();
125: if (null !== $modelAlias) {
126: $query->setModelAlias($modelAlias);
127: }
128: if ($criteria instanceof Criteria) {
129: $query->mergeWith($criteria);
130: }
131:
132: return $query;
133: }
134:
135: /**
136: * Find object by primary key.
137: * Propel uses the instance pool to skip the database if the object exists.
138: * Go fast if the query is untouched.
139: *
140: * <code>
141: * $obj = $c->findPk(12, $con);
142: * </code>
143: *
144: * @param mixed $key Primary key to use for the query
145: * @param PropelPDO $con an optional connection object
146: *
147: * @return Document|Document[]|mixed the result, formatted by the current formatter
148: */
149: public function findPk($key, $con = null)
150: {
151: if ($key === null) {
152: return null;
153: }
154: if ((null !== ($obj = DocumentPeer::getInstanceFromPool((string) $key))) && !$this->formatter) {
155: // the object is alredy in the instance pool
156: return $obj;
157: }
158: if ($con === null) {
159: $con = Propel::getConnection(DocumentPeer::DATABASE_NAME, Propel::CONNECTION_READ);
160: }
161: $this->basePreSelect($con);
162: if ($this->formatter || $this->modelAlias || $this->with || $this->select
163: || $this->selectColumns || $this->asColumns || $this->selectModifiers
164: || $this->map || $this->having || $this->joins) {
165: return $this->findPkComplex($key, $con);
166: } else {
167: return $this->findPkSimple($key, $con);
168: }
169: }
170:
171: /**
172: * Alias of findPk to use instance pooling
173: *
174: * @param mixed $key Primary key to use for the query
175: * @param PropelPDO $con A connection object
176: *
177: * @return Document A model object, or null if the key is not found
178: * @throws PropelException
179: */
180: public function findOneById($key, $con = null)
181: {
182: return $this->findPk($key, $con);
183: }
184:
185: /**
186: * Find object by primary key using raw SQL to go fast.
187: * Bypass doSelect() and the object formatter by using generated code.
188: *
189: * @param mixed $key Primary key to use for the query
190: * @param PropelPDO $con A connection object
191: *
192: * @return Document A model object, or null if the key is not found
193: * @throws PropelException
194: */
195: protected function findPkSimple($key, $con)
196: {
197: $sql = 'SELECT `id`, `product_id`, `category_id`, `folder_id`, `content_id`, `file`, `position`, `created_at`, `updated_at` FROM `document` WHERE `id` = :p0';
198: try {
199: $stmt = $con->prepare($sql);
200: $stmt->bindValue(':p0', $key, PDO::PARAM_INT);
201: $stmt->execute();
202: } catch (Exception $e) {
203: Propel::log($e->getMessage(), Propel::LOG_ERR);
204: throw new PropelException(sprintf('Unable to execute SELECT statement [%s]', $sql), $e);
205: }
206: $obj = null;
207: if ($row = $stmt->fetch(PDO::FETCH_NUM)) {
208: $obj = new Document();
209: $obj->hydrate($row);
210: DocumentPeer::addInstanceToPool($obj, (string) $key);
211: }
212: $stmt->closeCursor();
213:
214: return $obj;
215: }
216:
217: /**
218: * Find object by primary key.
219: *
220: * @param mixed $key Primary key to use for the query
221: * @param PropelPDO $con A connection object
222: *
223: * @return Document|Document[]|mixed the result, formatted by the current formatter
224: */
225: protected function findPkComplex($key, $con)
226: {
227: // As the query uses a PK condition, no limit(1) is necessary.
228: $criteria = $this->isKeepQuery() ? clone $this : $this;
229: $stmt = $criteria
230: ->filterByPrimaryKey($key)
231: ->doSelect($con);
232:
233: return $criteria->getFormatter()->init($criteria)->formatOne($stmt);
234: }
235:
236: /**
237: * Find objects by primary key
238: * <code>
239: * $objs = $c->findPks(array(12, 56, 832), $con);
240: * </code>
241: * @param array $keys Primary keys to use for the query
242: * @param PropelPDO $con an optional connection object
243: *
244: * @return PropelObjectCollection|Document[]|mixed the list of results, formatted by the current formatter
245: */
246: public function findPks($keys, $con = null)
247: {
248: if ($con === null) {
249: $con = Propel::getConnection($this->getDbName(), Propel::CONNECTION_READ);
250: }
251: $this->basePreSelect($con);
252: $criteria = $this->isKeepQuery() ? clone $this : $this;
253: $stmt = $criteria
254: ->filterByPrimaryKeys($keys)
255: ->doSelect($con);
256:
257: return $criteria->getFormatter()->init($criteria)->format($stmt);
258: }
259:
260: /**
261: * Filter the query by primary key
262: *
263: * @param mixed $key Primary key to use for the query
264: *
265: * @return DocumentQuery The current query, for fluid interface
266: */
267: public function filterByPrimaryKey($key)
268: {
269:
270: return $this->addUsingAlias(DocumentPeer::ID, $key, Criteria::EQUAL);
271: }
272:
273: /**
274: * Filter the query by a list of primary keys
275: *
276: * @param array $keys The list of primary key to use for the query
277: *
278: * @return DocumentQuery The current query, for fluid interface
279: */
280: public function filterByPrimaryKeys($keys)
281: {
282:
283: return $this->addUsingAlias(DocumentPeer::ID, $keys, Criteria::IN);
284: }
285:
286: /**
287: * Filter the query on the id column
288: *
289: * Example usage:
290: * <code>
291: * $query->filterById(1234); // WHERE id = 1234
292: * $query->filterById(array(12, 34)); // WHERE id IN (12, 34)
293: * $query->filterById(array('min' => 12)); // WHERE id >= 12
294: * $query->filterById(array('max' => 12)); // WHERE id <= 12
295: * </code>
296: *
297: * @param mixed $id The value to use as filter.
298: * Use scalar values for equality.
299: * Use array values for in_array() equivalent.
300: * Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
301: * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
302: *
303: * @return DocumentQuery The current query, for fluid interface
304: */
305: public function filterById($id = null, $comparison = null)
306: {
307: if (is_array($id)) {
308: $useMinMax = false;
309: if (isset($id['min'])) {
310: $this->addUsingAlias(DocumentPeer::ID, $id['min'], Criteria::GREATER_EQUAL);
311: $useMinMax = true;
312: }
313: if (isset($id['max'])) {
314: $this->addUsingAlias(DocumentPeer::ID, $id['max'], Criteria::LESS_EQUAL);
315: $useMinMax = true;
316: }
317: if ($useMinMax) {
318: return $this;
319: }
320: if (null === $comparison) {
321: $comparison = Criteria::IN;
322: }
323: }
324:
325: return $this->addUsingAlias(DocumentPeer::ID, $id, $comparison);
326: }
327:
328: /**
329: * Filter the query on the product_id column
330: *
331: * Example usage:
332: * <code>
333: * $query->filterByProductId(1234); // WHERE product_id = 1234
334: * $query->filterByProductId(array(12, 34)); // WHERE product_id IN (12, 34)
335: * $query->filterByProductId(array('min' => 12)); // WHERE product_id >= 12
336: * $query->filterByProductId(array('max' => 12)); // WHERE product_id <= 12
337: * </code>
338: *
339: * @see filterByProduct()
340: *
341: * @param mixed $productId The value to use as filter.
342: * Use scalar values for equality.
343: * Use array values for in_array() equivalent.
344: * Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
345: * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
346: *
347: * @return DocumentQuery The current query, for fluid interface
348: */
349: public function filterByProductId($productId = null, $comparison = null)
350: {
351: if (is_array($productId)) {
352: $useMinMax = false;
353: if (isset($productId['min'])) {
354: $this->addUsingAlias(DocumentPeer::PRODUCT_ID, $productId['min'], Criteria::GREATER_EQUAL);
355: $useMinMax = true;
356: }
357: if (isset($productId['max'])) {
358: $this->addUsingAlias(DocumentPeer::PRODUCT_ID, $productId['max'], Criteria::LESS_EQUAL);
359: $useMinMax = true;
360: }
361: if ($useMinMax) {
362: return $this;
363: }
364: if (null === $comparison) {
365: $comparison = Criteria::IN;
366: }
367: }
368:
369: return $this->addUsingAlias(DocumentPeer::PRODUCT_ID, $productId, $comparison);
370: }
371:
372: /**
373: * Filter the query on the category_id column
374: *
375: * Example usage:
376: * <code>
377: * $query->filterByCategoryId(1234); // WHERE category_id = 1234
378: * $query->filterByCategoryId(array(12, 34)); // WHERE category_id IN (12, 34)
379: * $query->filterByCategoryId(array('min' => 12)); // WHERE category_id >= 12
380: * $query->filterByCategoryId(array('max' => 12)); // WHERE category_id <= 12
381: * </code>
382: *
383: * @see filterByCategory()
384: *
385: * @param mixed $categoryId The value to use as filter.
386: * Use scalar values for equality.
387: * Use array values for in_array() equivalent.
388: * Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
389: * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
390: *
391: * @return DocumentQuery The current query, for fluid interface
392: */
393: public function filterByCategoryId($categoryId = null, $comparison = null)
394: {
395: if (is_array($categoryId)) {
396: $useMinMax = false;
397: if (isset($categoryId['min'])) {
398: $this->addUsingAlias(DocumentPeer::CATEGORY_ID, $categoryId['min'], Criteria::GREATER_EQUAL);
399: $useMinMax = true;
400: }
401: if (isset($categoryId['max'])) {
402: $this->addUsingAlias(DocumentPeer::CATEGORY_ID, $categoryId['max'], Criteria::LESS_EQUAL);
403: $useMinMax = true;
404: }
405: if ($useMinMax) {
406: return $this;
407: }
408: if (null === $comparison) {
409: $comparison = Criteria::IN;
410: }
411: }
412:
413: return $this->addUsingAlias(DocumentPeer::CATEGORY_ID, $categoryId, $comparison);
414: }
415:
416: /**
417: * Filter the query on the folder_id column
418: *
419: * Example usage:
420: * <code>
421: * $query->filterByFolderId(1234); // WHERE folder_id = 1234
422: * $query->filterByFolderId(array(12, 34)); // WHERE folder_id IN (12, 34)
423: * $query->filterByFolderId(array('min' => 12)); // WHERE folder_id >= 12
424: * $query->filterByFolderId(array('max' => 12)); // WHERE folder_id <= 12
425: * </code>
426: *
427: * @see filterByFolder()
428: *
429: * @param mixed $folderId The value to use as filter.
430: * Use scalar values for equality.
431: * Use array values for in_array() equivalent.
432: * Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
433: * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
434: *
435: * @return DocumentQuery The current query, for fluid interface
436: */
437: public function filterByFolderId($folderId = null, $comparison = null)
438: {
439: if (is_array($folderId)) {
440: $useMinMax = false;
441: if (isset($folderId['min'])) {
442: $this->addUsingAlias(DocumentPeer::FOLDER_ID, $folderId['min'], Criteria::GREATER_EQUAL);
443: $useMinMax = true;
444: }
445: if (isset($folderId['max'])) {
446: $this->addUsingAlias(DocumentPeer::FOLDER_ID, $folderId['max'], Criteria::LESS_EQUAL);
447: $useMinMax = true;
448: }
449: if ($useMinMax) {
450: return $this;
451: }
452: if (null === $comparison) {
453: $comparison = Criteria::IN;
454: }
455: }
456:
457: return $this->addUsingAlias(DocumentPeer::FOLDER_ID, $folderId, $comparison);
458: }
459:
460: /**
461: * Filter the query on the content_id column
462: *
463: * Example usage:
464: * <code>
465: * $query->filterByContentId(1234); // WHERE content_id = 1234
466: * $query->filterByContentId(array(12, 34)); // WHERE content_id IN (12, 34)
467: * $query->filterByContentId(array('min' => 12)); // WHERE content_id >= 12
468: * $query->filterByContentId(array('max' => 12)); // WHERE content_id <= 12
469: * </code>
470: *
471: * @see filterByContent()
472: *
473: * @param mixed $contentId The value to use as filter.
474: * Use scalar values for equality.
475: * Use array values for in_array() equivalent.
476: * Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
477: * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
478: *
479: * @return DocumentQuery The current query, for fluid interface
480: */
481: public function filterByContentId($contentId = null, $comparison = null)
482: {
483: if (is_array($contentId)) {
484: $useMinMax = false;
485: if (isset($contentId['min'])) {
486: $this->addUsingAlias(DocumentPeer::CONTENT_ID, $contentId['min'], Criteria::GREATER_EQUAL);
487: $useMinMax = true;
488: }
489: if (isset($contentId['max'])) {
490: $this->addUsingAlias(DocumentPeer::CONTENT_ID, $contentId['max'], Criteria::LESS_EQUAL);
491: $useMinMax = true;
492: }
493: if ($useMinMax) {
494: return $this;
495: }
496: if (null === $comparison) {
497: $comparison = Criteria::IN;
498: }
499: }
500:
501: return $this->addUsingAlias(DocumentPeer::CONTENT_ID, $contentId, $comparison);
502: }
503:
504: /**
505: * Filter the query on the file column
506: *
507: * Example usage:
508: * <code>
509: * $query->filterByFile('fooValue'); // WHERE file = 'fooValue'
510: * $query->filterByFile('%fooValue%'); // WHERE file LIKE '%fooValue%'
511: * </code>
512: *
513: * @param string $file The value to use as filter.
514: * Accepts wildcards (* and % trigger a LIKE)
515: * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
516: *
517: * @return DocumentQuery The current query, for fluid interface
518: */
519: public function filterByFile($file = null, $comparison = null)
520: {
521: if (null === $comparison) {
522: if (is_array($file)) {
523: $comparison = Criteria::IN;
524: } elseif (preg_match('/[\%\*]/', $file)) {
525: $file = str_replace('*', '%', $file);
526: $comparison = Criteria::LIKE;
527: }
528: }
529:
530: return $this->addUsingAlias(DocumentPeer::FILE, $file, $comparison);
531: }
532:
533: /**
534: * Filter the query on the position column
535: *
536: * Example usage:
537: * <code>
538: * $query->filterByPosition(1234); // WHERE position = 1234
539: * $query->filterByPosition(array(12, 34)); // WHERE position IN (12, 34)
540: * $query->filterByPosition(array('min' => 12)); // WHERE position >= 12
541: * $query->filterByPosition(array('max' => 12)); // WHERE position <= 12
542: * </code>
543: *
544: * @param mixed $position The value to use as filter.
545: * Use scalar values for equality.
546: * Use array values for in_array() equivalent.
547: * Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
548: * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
549: *
550: * @return DocumentQuery The current query, for fluid interface
551: */
552: public function filterByPosition($position = null, $comparison = null)
553: {
554: if (is_array($position)) {
555: $useMinMax = false;
556: if (isset($position['min'])) {
557: $this->addUsingAlias(DocumentPeer::POSITION, $position['min'], Criteria::GREATER_EQUAL);
558: $useMinMax = true;
559: }
560: if (isset($position['max'])) {
561: $this->addUsingAlias(DocumentPeer::POSITION, $position['max'], Criteria::LESS_EQUAL);
562: $useMinMax = true;
563: }
564: if ($useMinMax) {
565: return $this;
566: }
567: if (null === $comparison) {
568: $comparison = Criteria::IN;
569: }
570: }
571:
572: return $this->addUsingAlias(DocumentPeer::POSITION, $position, $comparison);
573: }
574:
575: /**
576: * Filter the query on the created_at column
577: *
578: * Example usage:
579: * <code>
580: * $query->filterByCreatedAt('2011-03-14'); // WHERE created_at = '2011-03-14'
581: * $query->filterByCreatedAt('now'); // WHERE created_at = '2011-03-14'
582: * $query->filterByCreatedAt(array('max' => 'yesterday')); // WHERE created_at > '2011-03-13'
583: * </code>
584: *
585: * @param mixed $createdAt The value to use as filter.
586: * Values can be integers (unix timestamps), DateTime objects, or strings.
587: * Empty strings are treated as NULL.
588: * Use scalar values for equality.
589: * Use array values for in_array() equivalent.
590: * Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
591: * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
592: *
593: * @return DocumentQuery The current query, for fluid interface
594: */
595: public function filterByCreatedAt($createdAt = null, $comparison = null)
596: {
597: if (is_array($createdAt)) {
598: $useMinMax = false;
599: if (isset($createdAt['min'])) {
600: $this->addUsingAlias(DocumentPeer::CREATED_AT, $createdAt['min'], Criteria::GREATER_EQUAL);
601: $useMinMax = true;
602: }
603: if (isset($createdAt['max'])) {
604: $this->addUsingAlias(DocumentPeer::CREATED_AT, $createdAt['max'], Criteria::LESS_EQUAL);
605: $useMinMax = true;
606: }
607: if ($useMinMax) {
608: return $this;
609: }
610: if (null === $comparison) {
611: $comparison = Criteria::IN;
612: }
613: }
614:
615: return $this->addUsingAlias(DocumentPeer::CREATED_AT, $createdAt, $comparison);
616: }
617:
618: /**
619: * Filter the query on the updated_at column
620: *
621: * Example usage:
622: * <code>
623: * $query->filterByUpdatedAt('2011-03-14'); // WHERE updated_at = '2011-03-14'
624: * $query->filterByUpdatedAt('now'); // WHERE updated_at = '2011-03-14'
625: * $query->filterByUpdatedAt(array('max' => 'yesterday')); // WHERE updated_at > '2011-03-13'
626: * </code>
627: *
628: * @param mixed $updatedAt The value to use as filter.
629: * Values can be integers (unix timestamps), DateTime objects, or strings.
630: * Empty strings are treated as NULL.
631: * Use scalar values for equality.
632: * Use array values for in_array() equivalent.
633: * Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
634: * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
635: *
636: * @return DocumentQuery The current query, for fluid interface
637: */
638: public function filterByUpdatedAt($updatedAt = null, $comparison = null)
639: {
640: if (is_array($updatedAt)) {
641: $useMinMax = false;
642: if (isset($updatedAt['min'])) {
643: $this->addUsingAlias(DocumentPeer::UPDATED_AT, $updatedAt['min'], Criteria::GREATER_EQUAL);
644: $useMinMax = true;
645: }
646: if (isset($updatedAt['max'])) {
647: $this->addUsingAlias(DocumentPeer::UPDATED_AT, $updatedAt['max'], Criteria::LESS_EQUAL);
648: $useMinMax = true;
649: }
650: if ($useMinMax) {
651: return $this;
652: }
653: if (null === $comparison) {
654: $comparison = Criteria::IN;
655: }
656: }
657:
658: return $this->addUsingAlias(DocumentPeer::UPDATED_AT, $updatedAt, $comparison);
659: }
660:
661: /**
662: * Filter the query by a related Product object
663: *
664: * @param Product|PropelObjectCollection $product The related object(s) to use as filter
665: * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
666: *
667: * @return DocumentQuery The current query, for fluid interface
668: * @throws PropelException - if the provided filter is invalid.
669: */
670: public function filterByProduct($product, $comparison = null)
671: {
672: if ($product instanceof Product) {
673: return $this
674: ->addUsingAlias(DocumentPeer::PRODUCT_ID, $product->getId(), $comparison);
675: } elseif ($product instanceof PropelObjectCollection) {
676: if (null === $comparison) {
677: $comparison = Criteria::IN;
678: }
679:
680: return $this
681: ->addUsingAlias(DocumentPeer::PRODUCT_ID, $product->toKeyValue('PrimaryKey', 'Id'), $comparison);
682: } else {
683: throw new PropelException('filterByProduct() only accepts arguments of type Product or PropelCollection');
684: }
685: }
686:
687: /**
688: * Adds a JOIN clause to the query using the Product relation
689: *
690: * @param string $relationAlias optional alias for the relation
691: * @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
692: *
693: * @return DocumentQuery The current query, for fluid interface
694: */
695: public function joinProduct($relationAlias = null, $joinType = Criteria::LEFT_JOIN)
696: {
697: $tableMap = $this->getTableMap();
698: $relationMap = $tableMap->getRelation('Product');
699:
700: // create a ModelJoin object for this join
701: $join = new ModelJoin();
702: $join->setJoinType($joinType);
703: $join->setRelationMap($relationMap, $this->useAliasInSQL ? $this->getModelAlias() : null, $relationAlias);
704: if ($previousJoin = $this->getPreviousJoin()) {
705: $join->setPreviousJoin($previousJoin);
706: }
707:
708: // add the ModelJoin to the current object
709: if ($relationAlias) {
710: $this->addAlias($relationAlias, $relationMap->getRightTable()->getName());
711: $this->addJoinObject($join, $relationAlias);
712: } else {
713: $this->addJoinObject($join, 'Product');
714: }
715:
716: return $this;
717: }
718:
719: /**
720: * Use the Product relation Product object
721: *
722: * @see useQuery()
723: *
724: * @param string $relationAlias optional alias for the relation,
725: * to be used as main alias in the secondary query
726: * @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
727: *
728: * @return \Thelia\Model\ProductQuery A secondary query class using the current class as primary query
729: */
730: public function useProductQuery($relationAlias = null, $joinType = Criteria::LEFT_JOIN)
731: {
732: return $this
733: ->joinProduct($relationAlias, $joinType)
734: ->useQuery($relationAlias ? $relationAlias : 'Product', '\Thelia\Model\ProductQuery');
735: }
736:
737: /**
738: * Filter the query by a related Category object
739: *
740: * @param Category|PropelObjectCollection $category The related object(s) to use as filter
741: * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
742: *
743: * @return DocumentQuery The current query, for fluid interface
744: * @throws PropelException - if the provided filter is invalid.
745: */
746: public function filterByCategory($category, $comparison = null)
747: {
748: if ($category instanceof Category) {
749: return $this
750: ->addUsingAlias(DocumentPeer::CATEGORY_ID, $category->getId(), $comparison);
751: } elseif ($category instanceof PropelObjectCollection) {
752: if (null === $comparison) {
753: $comparison = Criteria::IN;
754: }
755:
756: return $this
757: ->addUsingAlias(DocumentPeer::CATEGORY_ID, $category->toKeyValue('PrimaryKey', 'Id'), $comparison);
758: } else {
759: throw new PropelException('filterByCategory() only accepts arguments of type Category or PropelCollection');
760: }
761: }
762:
763: /**
764: * Adds a JOIN clause to the query using the Category relation
765: *
766: * @param string $relationAlias optional alias for the relation
767: * @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
768: *
769: * @return DocumentQuery The current query, for fluid interface
770: */
771: public function joinCategory($relationAlias = null, $joinType = Criteria::LEFT_JOIN)
772: {
773: $tableMap = $this->getTableMap();
774: $relationMap = $tableMap->getRelation('Category');
775:
776: // create a ModelJoin object for this join
777: $join = new ModelJoin();
778: $join->setJoinType($joinType);
779: $join->setRelationMap($relationMap, $this->useAliasInSQL ? $this->getModelAlias() : null, $relationAlias);
780: if ($previousJoin = $this->getPreviousJoin()) {
781: $join->setPreviousJoin($previousJoin);
782: }
783:
784: // add the ModelJoin to the current object
785: if ($relationAlias) {
786: $this->addAlias($relationAlias, $relationMap->getRightTable()->getName());
787: $this->addJoinObject($join, $relationAlias);
788: } else {
789: $this->addJoinObject($join, 'Category');
790: }
791:
792: return $this;
793: }
794:
795: /**
796: * Use the Category relation Category object
797: *
798: * @see useQuery()
799: *
800: * @param string $relationAlias optional alias for the relation,
801: * to be used as main alias in the secondary query
802: * @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
803: *
804: * @return \Thelia\Model\CategoryQuery A secondary query class using the current class as primary query
805: */
806: public function useCategoryQuery($relationAlias = null, $joinType = Criteria::LEFT_JOIN)
807: {
808: return $this
809: ->joinCategory($relationAlias, $joinType)
810: ->useQuery($relationAlias ? $relationAlias : 'Category', '\Thelia\Model\CategoryQuery');
811: }
812:
813: /**
814: * Filter the query by a related Content object
815: *
816: * @param Content|PropelObjectCollection $content The related object(s) to use as filter
817: * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
818: *
819: * @return DocumentQuery The current query, for fluid interface
820: * @throws PropelException - if the provided filter is invalid.
821: */
822: public function filterByContent($content, $comparison = null)
823: {
824: if ($content instanceof Content) {
825: return $this
826: ->addUsingAlias(DocumentPeer::CONTENT_ID, $content->getId(), $comparison);
827: } elseif ($content instanceof PropelObjectCollection) {
828: if (null === $comparison) {
829: $comparison = Criteria::IN;
830: }
831:
832: return $this
833: ->addUsingAlias(DocumentPeer::CONTENT_ID, $content->toKeyValue('PrimaryKey', 'Id'), $comparison);
834: } else {
835: throw new PropelException('filterByContent() only accepts arguments of type Content or PropelCollection');
836: }
837: }
838:
839: /**
840: * Adds a JOIN clause to the query using the Content relation
841: *
842: * @param string $relationAlias optional alias for the relation
843: * @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
844: *
845: * @return DocumentQuery The current query, for fluid interface
846: */
847: public function joinContent($relationAlias = null, $joinType = Criteria::LEFT_JOIN)
848: {
849: $tableMap = $this->getTableMap();
850: $relationMap = $tableMap->getRelation('Content');
851:
852: // create a ModelJoin object for this join
853: $join = new ModelJoin();
854: $join->setJoinType($joinType);
855: $join->setRelationMap($relationMap, $this->useAliasInSQL ? $this->getModelAlias() : null, $relationAlias);
856: if ($previousJoin = $this->getPreviousJoin()) {
857: $join->setPreviousJoin($previousJoin);
858: }
859:
860: // add the ModelJoin to the current object
861: if ($relationAlias) {
862: $this->addAlias($relationAlias, $relationMap->getRightTable()->getName());
863: $this->addJoinObject($join, $relationAlias);
864: } else {
865: $this->addJoinObject($join, 'Content');
866: }
867:
868: return $this;
869: }
870:
871: /**
872: * Use the Content relation Content object
873: *
874: * @see useQuery()
875: *
876: * @param string $relationAlias optional alias for the relation,
877: * to be used as main alias in the secondary query
878: * @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
879: *
880: * @return \Thelia\Model\ContentQuery A secondary query class using the current class as primary query
881: */
882: public function useContentQuery($relationAlias = null, $joinType = Criteria::LEFT_JOIN)
883: {
884: return $this
885: ->joinContent($relationAlias, $joinType)
886: ->useQuery($relationAlias ? $relationAlias : 'Content', '\Thelia\Model\ContentQuery');
887: }
888:
889: /**
890: * Filter the query by a related Folder object
891: *
892: * @param Folder|PropelObjectCollection $folder The related object(s) to use as filter
893: * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
894: *
895: * @return DocumentQuery The current query, for fluid interface
896: * @throws PropelException - if the provided filter is invalid.
897: */
898: public function filterByFolder($folder, $comparison = null)
899: {
900: if ($folder instanceof Folder) {
901: return $this
902: ->addUsingAlias(DocumentPeer::FOLDER_ID, $folder->getId(), $comparison);
903: } elseif ($folder instanceof PropelObjectCollection) {
904: if (null === $comparison) {
905: $comparison = Criteria::IN;
906: }
907:
908: return $this
909: ->addUsingAlias(DocumentPeer::FOLDER_ID, $folder->toKeyValue('PrimaryKey', 'Id'), $comparison);
910: } else {
911: throw new PropelException('filterByFolder() only accepts arguments of type Folder or PropelCollection');
912: }
913: }
914:
915: /**
916: * Adds a JOIN clause to the query using the Folder relation
917: *
918: * @param string $relationAlias optional alias for the relation
919: * @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
920: *
921: * @return DocumentQuery The current query, for fluid interface
922: */
923: public function joinFolder($relationAlias = null, $joinType = Criteria::LEFT_JOIN)
924: {
925: $tableMap = $this->getTableMap();
926: $relationMap = $tableMap->getRelation('Folder');
927:
928: // create a ModelJoin object for this join
929: $join = new ModelJoin();
930: $join->setJoinType($joinType);
931: $join->setRelationMap($relationMap, $this->useAliasInSQL ? $this->getModelAlias() : null, $relationAlias);
932: if ($previousJoin = $this->getPreviousJoin()) {
933: $join->setPreviousJoin($previousJoin);
934: }
935:
936: // add the ModelJoin to the current object
937: if ($relationAlias) {
938: $this->addAlias($relationAlias, $relationMap->getRightTable()->getName());
939: $this->addJoinObject($join, $relationAlias);
940: } else {
941: $this->addJoinObject($join, 'Folder');
942: }
943:
944: return $this;
945: }
946:
947: /**
948: * Use the Folder relation Folder object
949: *
950: * @see useQuery()
951: *
952: * @param string $relationAlias optional alias for the relation,
953: * to be used as main alias in the secondary query
954: * @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
955: *
956: * @return \Thelia\Model\FolderQuery A secondary query class using the current class as primary query
957: */
958: public function useFolderQuery($relationAlias = null, $joinType = Criteria::LEFT_JOIN)
959: {
960: return $this
961: ->joinFolder($relationAlias, $joinType)
962: ->useQuery($relationAlias ? $relationAlias : 'Folder', '\Thelia\Model\FolderQuery');
963: }
964:
965: /**
966: * Filter the query by a related DocumentI18n object
967: *
968: * @param DocumentI18n|PropelObjectCollection $documentI18n the related object to use as filter
969: * @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
970: *
971: * @return DocumentQuery The current query, for fluid interface
972: * @throws PropelException - if the provided filter is invalid.
973: */
974: public function filterByDocumentI18n($documentI18n, $comparison = null)
975: {
976: if ($documentI18n instanceof DocumentI18n) {
977: return $this
978: ->addUsingAlias(DocumentPeer::ID, $documentI18n->getId(), $comparison);
979: } elseif ($documentI18n instanceof PropelObjectCollection) {
980: return $this
981: ->useDocumentI18nQuery()
982: ->filterByPrimaryKeys($documentI18n->getPrimaryKeys())
983: ->endUse();
984: } else {
985: throw new PropelException('filterByDocumentI18n() only accepts arguments of type DocumentI18n or PropelCollection');
986: }
987: }
988:
989: /**
990: * Adds a JOIN clause to the query using the DocumentI18n relation
991: *
992: * @param string $relationAlias optional alias for the relation
993: * @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
994: *
995: * @return DocumentQuery The current query, for fluid interface
996: */
997: public function joinDocumentI18n($relationAlias = null, $joinType = 'LEFT JOIN')
998: {
999: $tableMap = $this->getTableMap();
1000: $relationMap = $tableMap->getRelation('DocumentI18n');
1001:
1002: // create a ModelJoin object for this join
1003: $join = new ModelJoin();
1004: $join->setJoinType($joinType);
1005: $join->setRelationMap($relationMap, $this->useAliasInSQL ? $this->getModelAlias() : null, $relationAlias);
1006: if ($previousJoin = $this->getPreviousJoin()) {
1007: $join->setPreviousJoin($previousJoin);
1008: }
1009:
1010: // add the ModelJoin to the current object
1011: if ($relationAlias) {
1012: $this->addAlias($relationAlias, $relationMap->getRightTable()->getName());
1013: $this->addJoinObject($join, $relationAlias);
1014: } else {
1015: $this->addJoinObject($join, 'DocumentI18n');
1016: }
1017:
1018: return $this;
1019: }
1020:
1021: /**
1022: * Use the DocumentI18n relation DocumentI18n object
1023: *
1024: * @see useQuery()
1025: *
1026: * @param string $relationAlias optional alias for the relation,
1027: * to be used as main alias in the secondary query
1028: * @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
1029: *
1030: * @return \Thelia\Model\DocumentI18nQuery A secondary query class using the current class as primary query
1031: */
1032: public function useDocumentI18nQuery($relationAlias = null, $joinType = 'LEFT JOIN')
1033: {
1034: return $this
1035: ->joinDocumentI18n($relationAlias, $joinType)
1036: ->useQuery($relationAlias ? $relationAlias : 'DocumentI18n', '\Thelia\Model\DocumentI18nQuery');
1037: }
1038:
1039: /**
1040: * Exclude object from result
1041: *
1042: * @param Document $document Object to remove from the list of results
1043: *
1044: * @return DocumentQuery The current query, for fluid interface
1045: */
1046: public function prune($document = null)
1047: {
1048: if ($document) {
1049: $this->addUsingAlias(DocumentPeer::ID, $document->getId(), Criteria::NOT_EQUAL);
1050: }
1051:
1052: return $this;
1053: }
1054:
1055: // timestampable behavior
1056:
1057: /**
1058: * Filter by the latest updated
1059: *
1060: * @param int $nbDays Maximum age of the latest update in days
1061: *
1062: * @return DocumentQuery The current query, for fluid interface
1063: */
1064: public function recentlyUpdated($nbDays = 7)
1065: {
1066: return $this->addUsingAlias(DocumentPeer::UPDATED_AT, time() - $nbDays * 24 * 60 * 60, Criteria::GREATER_EQUAL);
1067: }
1068:
1069: /**
1070: * Order by update date desc
1071: *
1072: * @return DocumentQuery The current query, for fluid interface
1073: */
1074: public function lastUpdatedFirst()
1075: {
1076: return $this->addDescendingOrderByColumn(DocumentPeer::UPDATED_AT);
1077: }
1078:
1079: /**
1080: * Order by update date asc
1081: *
1082: * @return DocumentQuery The current query, for fluid interface
1083: */
1084: public function firstUpdatedFirst()
1085: {
1086: return $this->addAscendingOrderByColumn(DocumentPeer::UPDATED_AT);
1087: }
1088:
1089: /**
1090: * Filter by the latest created
1091: *
1092: * @param int $nbDays Maximum age of in days
1093: *
1094: * @return DocumentQuery The current query, for fluid interface
1095: */
1096: public function recentlyCreated($nbDays = 7)
1097: {
1098: return $this->addUsingAlias(DocumentPeer::CREATED_AT, time() - $nbDays * 24 * 60 * 60, Criteria::GREATER_EQUAL);
1099: }
1100:
1101: /**
1102: * Order by create date desc
1103: *
1104: * @return DocumentQuery The current query, for fluid interface
1105: */
1106: public function lastCreatedFirst()
1107: {
1108: return $this->addDescendingOrderByColumn(DocumentPeer::CREATED_AT);
1109: }
1110:
1111: /**
1112: * Order by create date asc
1113: *
1114: * @return DocumentQuery The current query, for fluid interface
1115: */
1116: public function firstCreatedFirst()
1117: {
1118: return $this->addAscendingOrderByColumn(DocumentPeer::CREATED_AT);
1119: }
1120: // i18n behavior
1121:
1122: /**
1123: * Adds a JOIN clause to the query using the i18n relation
1124: *
1125: * @param string $locale Locale to use for the join condition, e.g. 'fr_FR'
1126: * @param string $relationAlias optional alias for the relation
1127: * @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'. Defaults to left join.
1128: *
1129: * @return DocumentQuery The current query, for fluid interface
1130: */
1131: public function joinI18n($locale = 'en_US', $relationAlias = null, $joinType = Criteria::LEFT_JOIN)
1132: {
1133: $relationName = $relationAlias ? $relationAlias : 'DocumentI18n';
1134:
1135: return $this
1136: ->joinDocumentI18n($relationAlias, $joinType)
1137: ->addJoinCondition($relationName, $relationName . '.Locale = ?', $locale);
1138: }
1139:
1140: /**
1141: * Adds a JOIN clause to the query and hydrates the related I18n object.
1142: * Shortcut for $c->joinI18n($locale)->with()
1143: *
1144: * @param string $locale Locale to use for the join condition, e.g. 'fr_FR'
1145: * @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'. Defaults to left join.
1146: *
1147: * @return DocumentQuery The current query, for fluid interface
1148: */
1149: public function joinWithI18n($locale = 'en_US', $joinType = Criteria::LEFT_JOIN)
1150: {
1151: $this
1152: ->joinI18n($locale, null, $joinType)
1153: ->with('DocumentI18n');
1154: $this->with['DocumentI18n']->setIsWithOneToMany(false);
1155:
1156: return $this;
1157: }
1158:
1159: /**
1160: * Use the I18n relation query object
1161: *
1162: * @see useQuery()
1163: *
1164: * @param string $locale Locale to use for the join condition, e.g. 'fr_FR'
1165: * @param string $relationAlias optional alias for the relation
1166: * @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'. Defaults to left join.
1167: *
1168: * @return DocumentI18nQuery A secondary query class using the current class as primary query
1169: */
1170: public function useI18nQuery($locale = 'en_US', $relationAlias = null, $joinType = Criteria::LEFT_JOIN)
1171: {
1172: return $this
1173: ->joinI18n($locale, $relationAlias, $joinType)
1174: ->useQuery($relationAlias ? $relationAlias : 'DocumentI18n', 'Thelia\Model\DocumentI18nQuery');
1175: }
1176:
1177: }
1178: