1: <?php
2:
3: namespace Thelia\Model\om;
4:
5: use \BaseObject;
6: use \BasePeer;
7: use \Criteria;
8: use \DateTime;
9: use \Exception;
10: use \PDO;
11: use \Persistent;
12: use \Propel;
13: use \PropelCollection;
14: use \PropelDateTime;
15: use \PropelException;
16: use \PropelObjectCollection;
17: use \PropelPDO;
18: use Thelia\Model\Content;
19: use Thelia\Model\ContentAssoc;
20: use Thelia\Model\ContentAssocQuery;
21: use Thelia\Model\ContentFolder;
22: use Thelia\Model\ContentFolderQuery;
23: use Thelia\Model\ContentI18n;
24: use Thelia\Model\ContentI18nQuery;
25: use Thelia\Model\ContentPeer;
26: use Thelia\Model\ContentQuery;
27: use Thelia\Model\ContentVersion;
28: use Thelia\Model\ContentVersionPeer;
29: use Thelia\Model\ContentVersionQuery;
30: use Thelia\Model\Document;
31: use Thelia\Model\DocumentQuery;
32: use Thelia\Model\Image;
33: use Thelia\Model\ImageQuery;
34: use Thelia\Model\Rewriting;
35: use Thelia\Model\RewritingQuery;
36:
37: /**
38: * Base class that represents a row from the 'content' table.
39: *
40: *
41: *
42: * @package propel.generator.Thelia.Model.om
43: */
44: abstract class BaseContent extends BaseObject implements Persistent
45: {
46: /**
47: * Peer class name
48: */
49: const PEER = 'Thelia\\Model\\ContentPeer';
50:
51: /**
52: * The Peer class.
53: * Instance provides a convenient way of calling static methods on a class
54: * that calling code may not be able to identify.
55: * @var ContentPeer
56: */
57: protected static $peer;
58:
59: /**
60: * The flag var to prevent infinit loop in deep copy
61: * @var boolean
62: */
63: protected $startCopy = false;
64:
65: /**
66: * The value for the id field.
67: * @var int
68: */
69: protected $id;
70:
71: /**
72: * The value for the visible field.
73: * @var int
74: */
75: protected $visible;
76:
77: /**
78: * The value for the position field.
79: * @var int
80: */
81: protected $position;
82:
83: /**
84: * The value for the created_at field.
85: * @var string
86: */
87: protected $created_at;
88:
89: /**
90: * The value for the updated_at field.
91: * @var string
92: */
93: protected $updated_at;
94:
95: /**
96: * The value for the version field.
97: * Note: this column has a database default value of: 0
98: * @var int
99: */
100: protected $version;
101:
102: /**
103: * The value for the version_created_at field.
104: * @var string
105: */
106: protected $version_created_at;
107:
108: /**
109: * The value for the version_created_by field.
110: * @var string
111: */
112: protected $version_created_by;
113:
114: /**
115: * @var PropelObjectCollection|ContentAssoc[] Collection to store aggregation of ContentAssoc objects.
116: */
117: protected $collContentAssocs;
118: protected $collContentAssocsPartial;
119:
120: /**
121: * @var PropelObjectCollection|Image[] Collection to store aggregation of Image objects.
122: */
123: protected $collImages;
124: protected $collImagesPartial;
125:
126: /**
127: * @var PropelObjectCollection|Document[] Collection to store aggregation of Document objects.
128: */
129: protected $collDocuments;
130: protected $collDocumentsPartial;
131:
132: /**
133: * @var PropelObjectCollection|Rewriting[] Collection to store aggregation of Rewriting objects.
134: */
135: protected $collRewritings;
136: protected $collRewritingsPartial;
137:
138: /**
139: * @var PropelObjectCollection|ContentFolder[] Collection to store aggregation of ContentFolder objects.
140: */
141: protected $collContentFolders;
142: protected $collContentFoldersPartial;
143:
144: /**
145: * @var PropelObjectCollection|ContentI18n[] Collection to store aggregation of ContentI18n objects.
146: */
147: protected $collContentI18ns;
148: protected $collContentI18nsPartial;
149:
150: /**
151: * @var PropelObjectCollection|ContentVersion[] Collection to store aggregation of ContentVersion objects.
152: */
153: protected $collContentVersions;
154: protected $collContentVersionsPartial;
155:
156: /**
157: * Flag to prevent endless save loop, if this object is referenced
158: * by another object which falls in this transaction.
159: * @var boolean
160: */
161: protected $alreadyInSave = false;
162:
163: /**
164: * Flag to prevent endless validation loop, if this object is referenced
165: * by another object which falls in this transaction.
166: * @var boolean
167: */
168: protected $alreadyInValidation = false;
169:
170: // i18n behavior
171:
172: /**
173: * Current locale
174: * @var string
175: */
176: protected $currentLocale = 'en_EN';
177:
178: /**
179: * Current translation objects
180: * @var array[ContentI18n]
181: */
182: protected $currentTranslations;
183:
184: // versionable behavior
185:
186:
187: /**
188: * @var bool
189: */
190: protected $enforceVersion = false;
191:
192: /**
193: * An array of objects scheduled for deletion.
194: * @var PropelObjectCollection
195: */
196: protected $contentAssocsScheduledForDeletion = null;
197:
198: /**
199: * An array of objects scheduled for deletion.
200: * @var PropelObjectCollection
201: */
202: protected $imagesScheduledForDeletion = null;
203:
204: /**
205: * An array of objects scheduled for deletion.
206: * @var PropelObjectCollection
207: */
208: protected $documentsScheduledForDeletion = null;
209:
210: /**
211: * An array of objects scheduled for deletion.
212: * @var PropelObjectCollection
213: */
214: protected $rewritingsScheduledForDeletion = null;
215:
216: /**
217: * An array of objects scheduled for deletion.
218: * @var PropelObjectCollection
219: */
220: protected $contentFoldersScheduledForDeletion = null;
221:
222: /**
223: * An array of objects scheduled for deletion.
224: * @var PropelObjectCollection
225: */
226: protected $contentI18nsScheduledForDeletion = null;
227:
228: /**
229: * An array of objects scheduled for deletion.
230: * @var PropelObjectCollection
231: */
232: protected $contentVersionsScheduledForDeletion = null;
233:
234: /**
235: * Applies default values to this object.
236: * This method should be called from the object's constructor (or
237: * equivalent initialization method).
238: * @see __construct()
239: */
240: public function applyDefaultValues()
241: {
242: $this->version = 0;
243: }
244:
245: /**
246: * Initializes internal state of BaseContent object.
247: * @see applyDefaults()
248: */
249: public function __construct()
250: {
251: parent::__construct();
252: $this->applyDefaultValues();
253: }
254:
255: /**
256: * Get the [id] column value.
257: *
258: * @return int
259: */
260: public function getId()
261: {
262: return $this->id;
263: }
264:
265: /**
266: * Get the [visible] column value.
267: *
268: * @return int
269: */
270: public function getVisible()
271: {
272: return $this->visible;
273: }
274:
275: /**
276: * Get the [position] column value.
277: *
278: * @return int
279: */
280: public function getPosition()
281: {
282: return $this->position;
283: }
284:
285: /**
286: * Get the [optionally formatted] temporal [created_at] column value.
287: *
288: *
289: * @param string $format The date/time format string (either date()-style or strftime()-style).
290: * If format is null, then the raw DateTime object will be returned.
291: * @return mixed Formatted date/time value as string or DateTime object (if format is null), null if column is null, and 0 if column value is 0000-00-00 00:00:00
292: * @throws PropelException - if unable to parse/validate the date/time value.
293: */
294: public function getCreatedAt($format = 'Y-m-d H:i:s')
295: {
296: if ($this->created_at === null) {
297: return null;
298: }
299:
300: if ($this->created_at === '0000-00-00 00:00:00') {
301: // while technically this is not a default value of null,
302: // this seems to be closest in meaning.
303: return null;
304: } else {
305: try {
306: $dt = new DateTime($this->created_at);
307: } catch (Exception $x) {
308: throw new PropelException("Internally stored date/time/timestamp value could not be converted to DateTime: " . var_export($this->created_at, true), $x);
309: }
310: }
311:
312: if ($format === null) {
313: // Because propel.useDateTimeClass is true, we return a DateTime object.
314: return $dt;
315: } elseif (strpos($format, '%') !== false) {
316: return strftime($format, $dt->format('U'));
317: } else {
318: return $dt->format($format);
319: }
320: }
321:
322: /**
323: * Get the [optionally formatted] temporal [updated_at] column value.
324: *
325: *
326: * @param string $format The date/time format string (either date()-style or strftime()-style).
327: * If format is null, then the raw DateTime object will be returned.
328: * @return mixed Formatted date/time value as string or DateTime object (if format is null), null if column is null, and 0 if column value is 0000-00-00 00:00:00
329: * @throws PropelException - if unable to parse/validate the date/time value.
330: */
331: public function getUpdatedAt($format = 'Y-m-d H:i:s')
332: {
333: if ($this->updated_at === null) {
334: return null;
335: }
336:
337: if ($this->updated_at === '0000-00-00 00:00:00') {
338: // while technically this is not a default value of null,
339: // this seems to be closest in meaning.
340: return null;
341: } else {
342: try {
343: $dt = new DateTime($this->updated_at);
344: } catch (Exception $x) {
345: throw new PropelException("Internally stored date/time/timestamp value could not be converted to DateTime: " . var_export($this->updated_at, true), $x);
346: }
347: }
348:
349: if ($format === null) {
350: // Because propel.useDateTimeClass is true, we return a DateTime object.
351: return $dt;
352: } elseif (strpos($format, '%') !== false) {
353: return strftime($format, $dt->format('U'));
354: } else {
355: return $dt->format($format);
356: }
357: }
358:
359: /**
360: * Get the [version] column value.
361: *
362: * @return int
363: */
364: public function getVersion()
365: {
366: return $this->version;
367: }
368:
369: /**
370: * Get the [optionally formatted] temporal [version_created_at] column value.
371: *
372: *
373: * @param string $format The date/time format string (either date()-style or strftime()-style).
374: * If format is null, then the raw DateTime object will be returned.
375: * @return mixed Formatted date/time value as string or DateTime object (if format is null), null if column is null, and 0 if column value is 0000-00-00 00:00:00
376: * @throws PropelException - if unable to parse/validate the date/time value.
377: */
378: public function getVersionCreatedAt($format = 'Y-m-d H:i:s')
379: {
380: if ($this->version_created_at === null) {
381: return null;
382: }
383:
384: if ($this->version_created_at === '0000-00-00 00:00:00') {
385: // while technically this is not a default value of null,
386: // this seems to be closest in meaning.
387: return null;
388: } else {
389: try {
390: $dt = new DateTime($this->version_created_at);
391: } catch (Exception $x) {
392: throw new PropelException("Internally stored date/time/timestamp value could not be converted to DateTime: " . var_export($this->version_created_at, true), $x);
393: }
394: }
395:
396: if ($format === null) {
397: // Because propel.useDateTimeClass is true, we return a DateTime object.
398: return $dt;
399: } elseif (strpos($format, '%') !== false) {
400: return strftime($format, $dt->format('U'));
401: } else {
402: return $dt->format($format);
403: }
404: }
405:
406: /**
407: * Get the [version_created_by] column value.
408: *
409: * @return string
410: */
411: public function getVersionCreatedBy()
412: {
413: return $this->version_created_by;
414: }
415:
416: /**
417: * Set the value of [id] column.
418: *
419: * @param int $v new value
420: * @return Content The current object (for fluent API support)
421: */
422: public function setId($v)
423: {
424: if ($v !== null) {
425: $v = (int) $v;
426: }
427:
428: if ($this->id !== $v) {
429: $this->id = $v;
430: $this->modifiedColumns[] = ContentPeer::ID;
431: }
432:
433:
434: return $this;
435: } // setId()
436:
437: /**
438: * Set the value of [visible] column.
439: *
440: * @param int $v new value
441: * @return Content The current object (for fluent API support)
442: */
443: public function setVisible($v)
444: {
445: if ($v !== null) {
446: $v = (int) $v;
447: }
448:
449: if ($this->visible !== $v) {
450: $this->visible = $v;
451: $this->modifiedColumns[] = ContentPeer::VISIBLE;
452: }
453:
454:
455: return $this;
456: } // setVisible()
457:
458: /**
459: * Set the value of [position] column.
460: *
461: * @param int $v new value
462: * @return Content The current object (for fluent API support)
463: */
464: public function setPosition($v)
465: {
466: if ($v !== null) {
467: $v = (int) $v;
468: }
469:
470: if ($this->position !== $v) {
471: $this->position = $v;
472: $this->modifiedColumns[] = ContentPeer::POSITION;
473: }
474:
475:
476: return $this;
477: } // setPosition()
478:
479: /**
480: * Sets the value of [created_at] column to a normalized version of the date/time value specified.
481: *
482: * @param mixed $v string, integer (timestamp), or DateTime value.
483: * Empty strings are treated as null.
484: * @return Content The current object (for fluent API support)
485: */
486: public function setCreatedAt($v)
487: {
488: $dt = PropelDateTime::newInstance($v, null, 'DateTime');
489: if ($this->created_at !== null || $dt !== null) {
490: $currentDateAsString = ($this->created_at !== null && $tmpDt = new DateTime($this->created_at)) ? $tmpDt->format('Y-m-d H:i:s') : null;
491: $newDateAsString = $dt ? $dt->format('Y-m-d H:i:s') : null;
492: if ($currentDateAsString !== $newDateAsString) {
493: $this->created_at = $newDateAsString;
494: $this->modifiedColumns[] = ContentPeer::CREATED_AT;
495: }
496: } // if either are not null
497:
498:
499: return $this;
500: } // setCreatedAt()
501:
502: /**
503: * Sets the value of [updated_at] column to a normalized version of the date/time value specified.
504: *
505: * @param mixed $v string, integer (timestamp), or DateTime value.
506: * Empty strings are treated as null.
507: * @return Content The current object (for fluent API support)
508: */
509: public function setUpdatedAt($v)
510: {
511: $dt = PropelDateTime::newInstance($v, null, 'DateTime');
512: if ($this->updated_at !== null || $dt !== null) {
513: $currentDateAsString = ($this->updated_at !== null && $tmpDt = new DateTime($this->updated_at)) ? $tmpDt->format('Y-m-d H:i:s') : null;
514: $newDateAsString = $dt ? $dt->format('Y-m-d H:i:s') : null;
515: if ($currentDateAsString !== $newDateAsString) {
516: $this->updated_at = $newDateAsString;
517: $this->modifiedColumns[] = ContentPeer::UPDATED_AT;
518: }
519: } // if either are not null
520:
521:
522: return $this;
523: } // setUpdatedAt()
524:
525: /**
526: * Set the value of [version] column.
527: *
528: * @param int $v new value
529: * @return Content The current object (for fluent API support)
530: */
531: public function setVersion($v)
532: {
533: if ($v !== null) {
534: $v = (int) $v;
535: }
536:
537: if ($this->version !== $v) {
538: $this->version = $v;
539: $this->modifiedColumns[] = ContentPeer::VERSION;
540: }
541:
542:
543: return $this;
544: } // setVersion()
545:
546: /**
547: * Sets the value of [version_created_at] column to a normalized version of the date/time value specified.
548: *
549: * @param mixed $v string, integer (timestamp), or DateTime value.
550: * Empty strings are treated as null.
551: * @return Content The current object (for fluent API support)
552: */
553: public function setVersionCreatedAt($v)
554: {
555: $dt = PropelDateTime::newInstance($v, null, 'DateTime');
556: if ($this->version_created_at !== null || $dt !== null) {
557: $currentDateAsString = ($this->version_created_at !== null && $tmpDt = new DateTime($this->version_created_at)) ? $tmpDt->format('Y-m-d H:i:s') : null;
558: $newDateAsString = $dt ? $dt->format('Y-m-d H:i:s') : null;
559: if ($currentDateAsString !== $newDateAsString) {
560: $this->version_created_at = $newDateAsString;
561: $this->modifiedColumns[] = ContentPeer::VERSION_CREATED_AT;
562: }
563: } // if either are not null
564:
565:
566: return $this;
567: } // setVersionCreatedAt()
568:
569: /**
570: * Set the value of [version_created_by] column.
571: *
572: * @param string $v new value
573: * @return Content The current object (for fluent API support)
574: */
575: public function setVersionCreatedBy($v)
576: {
577: if ($v !== null) {
578: $v = (string) $v;
579: }
580:
581: if ($this->version_created_by !== $v) {
582: $this->version_created_by = $v;
583: $this->modifiedColumns[] = ContentPeer::VERSION_CREATED_BY;
584: }
585:
586:
587: return $this;
588: } // setVersionCreatedBy()
589:
590: /**
591: * Indicates whether the columns in this object are only set to default values.
592: *
593: * This method can be used in conjunction with isModified() to indicate whether an object is both
594: * modified _and_ has some values set which are non-default.
595: *
596: * @return boolean Whether the columns in this object are only been set with default values.
597: */
598: public function hasOnlyDefaultValues()
599: {
600: if ($this->version !== 0) {
601: return false;
602: }
603:
604: // otherwise, everything was equal, so return true
605: return true;
606: } // hasOnlyDefaultValues()
607:
608: /**
609: * Hydrates (populates) the object variables with values from the database resultset.
610: *
611: * An offset (0-based "start column") is specified so that objects can be hydrated
612: * with a subset of the columns in the resultset rows. This is needed, for example,
613: * for results of JOIN queries where the resultset row includes columns from two or
614: * more tables.
615: *
616: * @param array $row The row returned by PDOStatement->fetch(PDO::FETCH_NUM)
617: * @param int $startcol 0-based offset column which indicates which restultset column to start with.
618: * @param boolean $rehydrate Whether this object is being re-hydrated from the database.
619: * @return int next starting column
620: * @throws PropelException - Any caught Exception will be rewrapped as a PropelException.
621: */
622: public function hydrate($row, $startcol = 0, $rehydrate = false)
623: {
624: try {
625:
626: $this->id = ($row[$startcol + 0] !== null) ? (int) $row[$startcol + 0] : null;
627: $this->visible = ($row[$startcol + 1] !== null) ? (int) $row[$startcol + 1] : null;
628: $this->position = ($row[$startcol + 2] !== null) ? (int) $row[$startcol + 2] : null;
629: $this->created_at = ($row[$startcol + 3] !== null) ? (string) $row[$startcol + 3] : null;
630: $this->updated_at = ($row[$startcol + 4] !== null) ? (string) $row[$startcol + 4] : null;
631: $this->version = ($row[$startcol + 5] !== null) ? (int) $row[$startcol + 5] : null;
632: $this->version_created_at = ($row[$startcol + 6] !== null) ? (string) $row[$startcol + 6] : null;
633: $this->version_created_by = ($row[$startcol + 7] !== null) ? (string) $row[$startcol + 7] : null;
634: $this->resetModified();
635:
636: $this->setNew(false);
637:
638: if ($rehydrate) {
639: $this->ensureConsistency();
640: }
641:
642: return $startcol + 8; // 8 = ContentPeer::NUM_HYDRATE_COLUMNS.
643:
644: } catch (Exception $e) {
645: throw new PropelException("Error populating Content object", $e);
646: }
647: }
648:
649: /**
650: * Checks and repairs the internal consistency of the object.
651: *
652: * This method is executed after an already-instantiated object is re-hydrated
653: * from the database. It exists to check any foreign keys to make sure that
654: * the objects related to the current object are correct based on foreign key.
655: *
656: * You can override this method in the stub class, but you should always invoke
657: * the base method from the overridden method (i.e. parent::ensureConsistency()),
658: * in case your model changes.
659: *
660: * @throws PropelException
661: */
662: public function ensureConsistency()
663: {
664:
665: } // ensureConsistency
666:
667: /**
668: * Reloads this object from datastore based on primary key and (optionally) resets all associated objects.
669: *
670: * This will only work if the object has been saved and has a valid primary key set.
671: *
672: * @param boolean $deep (optional) Whether to also de-associated any related objects.
673: * @param PropelPDO $con (optional) The PropelPDO connection to use.
674: * @return void
675: * @throws PropelException - if this object is deleted, unsaved or doesn't have pk match in db
676: */
677: public function reload($deep = false, PropelPDO $con = null)
678: {
679: if ($this->isDeleted()) {
680: throw new PropelException("Cannot reload a deleted object.");
681: }
682:
683: if ($this->isNew()) {
684: throw new PropelException("Cannot reload an unsaved object.");
685: }
686:
687: if ($con === null) {
688: $con = Propel::getConnection(ContentPeer::DATABASE_NAME, Propel::CONNECTION_READ);
689: }
690:
691: // We don't need to alter the object instance pool; we're just modifying this instance
692: // already in the pool.
693:
694: $stmt = ContentPeer::doSelectStmt($this->buildPkeyCriteria(), $con);
695: $row = $stmt->fetch(PDO::FETCH_NUM);
696: $stmt->closeCursor();
697: if (!$row) {
698: throw new PropelException('Cannot find matching row in the database to reload object values.');
699: }
700: $this->hydrate($row, 0, true); // rehydrate
701:
702: if ($deep) { // also de-associate any related objects?
703:
704: $this->collContentAssocs = null;
705:
706: $this->collImages = null;
707:
708: $this->collDocuments = null;
709:
710: $this->collRewritings = null;
711:
712: $this->collContentFolders = null;
713:
714: $this->collContentI18ns = null;
715:
716: $this->collContentVersions = null;
717:
718: } // if (deep)
719: }
720:
721: /**
722: * Removes this object from datastore and sets delete attribute.
723: *
724: * @param PropelPDO $con
725: * @return void
726: * @throws PropelException
727: * @throws Exception
728: * @see BaseObject::setDeleted()
729: * @see BaseObject::isDeleted()
730: */
731: public function delete(PropelPDO $con = null)
732: {
733: if ($this->isDeleted()) {
734: throw new PropelException("This object has already been deleted.");
735: }
736:
737: if ($con === null) {
738: $con = Propel::getConnection(ContentPeer::DATABASE_NAME, Propel::CONNECTION_WRITE);
739: }
740:
741: $con->beginTransaction();
742: try {
743: $deleteQuery = ContentQuery::create()
744: ->filterByPrimaryKey($this->getPrimaryKey());
745: $ret = $this->preDelete($con);
746: if ($ret) {
747: $deleteQuery->delete($con);
748: $this->postDelete($con);
749: $con->commit();
750: $this->setDeleted(true);
751: } else {
752: $con->commit();
753: }
754: } catch (Exception $e) {
755: $con->rollBack();
756: throw $e;
757: }
758: }
759:
760: /**
761: * Persists this object to the database.
762: *
763: * If the object is new, it inserts it; otherwise an update is performed.
764: * All modified related objects will also be persisted in the doSave()
765: * method. This method wraps all precipitate database operations in a
766: * single transaction.
767: *
768: * @param PropelPDO $con
769: * @return int The number of rows affected by this insert/update and any referring fk objects' save() operations.
770: * @throws PropelException
771: * @throws Exception
772: * @see doSave()
773: */
774: public function save(PropelPDO $con = null)
775: {
776: if ($this->isDeleted()) {
777: throw new PropelException("You cannot save an object that has been deleted.");
778: }
779:
780: if ($con === null) {
781: $con = Propel::getConnection(ContentPeer::DATABASE_NAME, Propel::CONNECTION_WRITE);
782: }
783:
784: $con->beginTransaction();
785: $isInsert = $this->isNew();
786: try {
787: $ret = $this->preSave($con);
788: // versionable behavior
789: if ($this->isVersioningNecessary()) {
790: $this->setVersion($this->isNew() ? 1 : $this->getLastVersionNumber($con) + 1);
791: if (!$this->isColumnModified(ContentPeer::VERSION_CREATED_AT)) {
792: $this->setVersionCreatedAt(time());
793: }
794: $createVersion = true; // for postSave hook
795: }
796: if ($isInsert) {
797: $ret = $ret && $this->preInsert($con);
798: // timestampable behavior
799: if (!$this->isColumnModified(ContentPeer::CREATED_AT)) {
800: $this->setCreatedAt(time());
801: }
802: if (!$this->isColumnModified(ContentPeer::UPDATED_AT)) {
803: $this->setUpdatedAt(time());
804: }
805: } else {
806: $ret = $ret && $this->preUpdate($con);
807: // timestampable behavior
808: if ($this->isModified() && !$this->isColumnModified(ContentPeer::UPDATED_AT)) {
809: $this->setUpdatedAt(time());
810: }
811: }
812: if ($ret) {
813: $affectedRows = $this->doSave($con);
814: if ($isInsert) {
815: $this->postInsert($con);
816: } else {
817: $this->postUpdate($con);
818: }
819: $this->postSave($con);
820: // versionable behavior
821: if (isset($createVersion)) {
822: $this->addVersion($con);
823: }
824: ContentPeer::addInstanceToPool($this);
825: } else {
826: $affectedRows = 0;
827: }
828: $con->commit();
829:
830: return $affectedRows;
831: } catch (Exception $e) {
832: $con->rollBack();
833: throw $e;
834: }
835: }
836:
837: /**
838: * Performs the work of inserting or updating the row in the database.
839: *
840: * If the object is new, it inserts it; otherwise an update is performed.
841: * All related objects are also updated in this method.
842: *
843: * @param PropelPDO $con
844: * @return int The number of rows affected by this insert/update and any referring fk objects' save() operations.
845: * @throws PropelException
846: * @see save()
847: */
848: protected function doSave(PropelPDO $con)
849: {
850: $affectedRows = 0; // initialize var to track total num of affected rows
851: if (!$this->alreadyInSave) {
852: $this->alreadyInSave = true;
853:
854: if ($this->isNew() || $this->isModified()) {
855: // persist changes
856: if ($this->isNew()) {
857: $this->doInsert($con);
858: } else {
859: $this->doUpdate($con);
860: }
861: $affectedRows += 1;
862: $this->resetModified();
863: }
864:
865: if ($this->contentAssocsScheduledForDeletion !== null) {
866: if (!$this->contentAssocsScheduledForDeletion->isEmpty()) {
867: foreach ($this->contentAssocsScheduledForDeletion as $contentAssoc) {
868: // need to save related object because we set the relation to null
869: $contentAssoc->save($con);
870: }
871: $this->contentAssocsScheduledForDeletion = null;
872: }
873: }
874:
875: if ($this->collContentAssocs !== null) {
876: foreach ($this->collContentAssocs as $referrerFK) {
877: if (!$referrerFK->isDeleted()) {
878: $affectedRows += $referrerFK->save($con);
879: }
880: }
881: }
882:
883: if ($this->imagesScheduledForDeletion !== null) {
884: if (!$this->imagesScheduledForDeletion->isEmpty()) {
885: foreach ($this->imagesScheduledForDeletion as $image) {
886: // need to save related object because we set the relation to null
887: $image->save($con);
888: }
889: $this->imagesScheduledForDeletion = null;
890: }
891: }
892:
893: if ($this->collImages !== null) {
894: foreach ($this->collImages as $referrerFK) {
895: if (!$referrerFK->isDeleted()) {
896: $affectedRows += $referrerFK->save($con);
897: }
898: }
899: }
900:
901: if ($this->documentsScheduledForDeletion !== null) {
902: if (!$this->documentsScheduledForDeletion->isEmpty()) {
903: foreach ($this->documentsScheduledForDeletion as $document) {
904: // need to save related object because we set the relation to null
905: $document->save($con);
906: }
907: $this->documentsScheduledForDeletion = null;
908: }
909: }
910:
911: if ($this->collDocuments !== null) {
912: foreach ($this->collDocuments as $referrerFK) {
913: if (!$referrerFK->isDeleted()) {
914: $affectedRows += $referrerFK->save($con);
915: }
916: }
917: }
918:
919: if ($this->rewritingsScheduledForDeletion !== null) {
920: if (!$this->rewritingsScheduledForDeletion->isEmpty()) {
921: foreach ($this->rewritingsScheduledForDeletion as $rewriting) {
922: // need to save related object because we set the relation to null
923: $rewriting->save($con);
924: }
925: $this->rewritingsScheduledForDeletion = null;
926: }
927: }
928:
929: if ($this->collRewritings !== null) {
930: foreach ($this->collRewritings as $referrerFK) {
931: if (!$referrerFK->isDeleted()) {
932: $affectedRows += $referrerFK->save($con);
933: }
934: }
935: }
936:
937: if ($this->contentFoldersScheduledForDeletion !== null) {
938: if (!$this->contentFoldersScheduledForDeletion->isEmpty()) {
939: ContentFolderQuery::create()
940: ->filterByPrimaryKeys($this->contentFoldersScheduledForDeletion->getPrimaryKeys(false))
941: ->delete($con);
942: $this->contentFoldersScheduledForDeletion = null;
943: }
944: }
945:
946: if ($this->collContentFolders !== null) {
947: foreach ($this->collContentFolders as $referrerFK) {
948: if (!$referrerFK->isDeleted()) {
949: $affectedRows += $referrerFK->save($con);
950: }
951: }
952: }
953:
954: if ($this->contentI18nsScheduledForDeletion !== null) {
955: if (!$this->contentI18nsScheduledForDeletion->isEmpty()) {
956: ContentI18nQuery::create()
957: ->filterByPrimaryKeys($this->contentI18nsScheduledForDeletion->getPrimaryKeys(false))
958: ->delete($con);
959: $this->contentI18nsScheduledForDeletion = null;
960: }
961: }
962:
963: if ($this->collContentI18ns !== null) {
964: foreach ($this->collContentI18ns as $referrerFK) {
965: if (!$referrerFK->isDeleted()) {
966: $affectedRows += $referrerFK->save($con);
967: }
968: }
969: }
970:
971: if ($this->contentVersionsScheduledForDeletion !== null) {
972: if (!$this->contentVersionsScheduledForDeletion->isEmpty()) {
973: ContentVersionQuery::create()
974: ->filterByPrimaryKeys($this->contentVersionsScheduledForDeletion->getPrimaryKeys(false))
975: ->delete($con);
976: $this->contentVersionsScheduledForDeletion = null;
977: }
978: }
979:
980: if ($this->collContentVersions !== null) {
981: foreach ($this->collContentVersions as $referrerFK) {
982: if (!$referrerFK->isDeleted()) {
983: $affectedRows += $referrerFK->save($con);
984: }
985: }
986: }
987:
988: $this->alreadyInSave = false;
989:
990: }
991:
992: return $affectedRows;
993: } // doSave()
994:
995: /**
996: * Insert the row in the database.
997: *
998: * @param PropelPDO $con
999: *
1000: * @throws PropelException
1001: * @see doSave()
1002: */
1003: protected function doInsert(PropelPDO $con)
1004: {
1005: $modifiedColumns = array();
1006: $index = 0;
1007:
1008: $this->modifiedColumns[] = ContentPeer::ID;
1009: if (null !== $this->id) {
1010: throw new PropelException('Cannot insert a value for auto-increment primary key (' . ContentPeer::ID . ')');
1011: }
1012:
1013: // check the columns in natural order for more readable SQL queries
1014: if ($this->isColumnModified(ContentPeer::ID)) {
1015: $modifiedColumns[':p' . $index++] = '`ID`';
1016: }
1017: if ($this->isColumnModified(ContentPeer::VISIBLE)) {
1018: $modifiedColumns[':p' . $index++] = '`VISIBLE`';
1019: }
1020: if ($this->isColumnModified(ContentPeer::POSITION)) {
1021: $modifiedColumns[':p' . $index++] = '`POSITION`';
1022: }
1023: if ($this->isColumnModified(ContentPeer::CREATED_AT)) {
1024: $modifiedColumns[':p' . $index++] = '`CREATED_AT`';
1025: }
1026: if ($this->isColumnModified(ContentPeer::UPDATED_AT)) {
1027: $modifiedColumns[':p' . $index++] = '`UPDATED_AT`';
1028: }
1029: if ($this->isColumnModified(ContentPeer::VERSION)) {
1030: $modifiedColumns[':p' . $index++] = '`VERSION`';
1031: }
1032: if ($this->isColumnModified(ContentPeer::VERSION_CREATED_AT)) {
1033: $modifiedColumns[':p' . $index++] = '`VERSION_CREATED_AT`';
1034: }
1035: if ($this->isColumnModified(ContentPeer::VERSION_CREATED_BY)) {
1036: $modifiedColumns[':p' . $index++] = '`VERSION_CREATED_BY`';
1037: }
1038:
1039: $sql = sprintf(
1040: 'INSERT INTO `content` (%s) VALUES (%s)',
1041: implode(', ', $modifiedColumns),
1042: implode(', ', array_keys($modifiedColumns))
1043: );
1044:
1045: try {
1046: $stmt = $con->prepare($sql);
1047: foreach ($modifiedColumns as $identifier => $columnName) {
1048: switch ($columnName) {
1049: case '`ID`':
1050: $stmt->bindValue($identifier, $this->id, PDO::PARAM_INT);
1051: break;
1052: case '`VISIBLE`':
1053: $stmt->bindValue($identifier, $this->visible, PDO::PARAM_INT);
1054: break;
1055: case '`POSITION`':
1056: $stmt->bindValue($identifier, $this->position, PDO::PARAM_INT);
1057: break;
1058: case '`CREATED_AT`':
1059: $stmt->bindValue($identifier, $this->created_at, PDO::PARAM_STR);
1060: break;
1061: case '`UPDATED_AT`':
1062: $stmt->bindValue($identifier, $this->updated_at, PDO::PARAM_STR);
1063: break;
1064: case '`VERSION`':
1065: $stmt->bindValue($identifier, $this->version, PDO::PARAM_INT);
1066: break;
1067: case '`VERSION_CREATED_AT`':
1068: $stmt->bindValue($identifier, $this->version_created_at, PDO::PARAM_STR);
1069: break;
1070: case '`VERSION_CREATED_BY`':
1071: $stmt->bindValue($identifier, $this->version_created_by, PDO::PARAM_STR);
1072: break;
1073: }
1074: }
1075: $stmt->execute();
1076: } catch (Exception $e) {
1077: Propel::log($e->getMessage(), Propel::LOG_ERR);
1078: throw new PropelException(sprintf('Unable to execute INSERT statement [%s]', $sql), $e);
1079: }
1080:
1081: try {
1082: $pk = $con->lastInsertId();
1083: } catch (Exception $e) {
1084: throw new PropelException('Unable to get autoincrement id.', $e);
1085: }
1086: $this->setId($pk);
1087:
1088: $this->setNew(false);
1089: }
1090:
1091: /**
1092: * Update the row in the database.
1093: *
1094: * @param PropelPDO $con
1095: *
1096: * @see doSave()
1097: */
1098: protected function doUpdate(PropelPDO $con)
1099: {
1100: $selectCriteria = $this->buildPkeyCriteria();
1101: $valuesCriteria = $this->buildCriteria();
1102: BasePeer::doUpdate($selectCriteria, $valuesCriteria, $con);
1103: }
1104:
1105: /**
1106: * Array of ValidationFailed objects.
1107: * @var array ValidationFailed[]
1108: */
1109: protected $validationFailures = array();
1110:
1111: /**
1112: * Gets any ValidationFailed objects that resulted from last call to validate().
1113: *
1114: *
1115: * @return array ValidationFailed[]
1116: * @see validate()
1117: */
1118: public function getValidationFailures()
1119: {
1120: return $this->validationFailures;
1121: }
1122:
1123: /**
1124: * Validates the objects modified field values and all objects related to this table.
1125: *
1126: * If $columns is either a column name or an array of column names
1127: * only those columns are validated.
1128: *
1129: * @param mixed $columns Column name or an array of column names.
1130: * @return boolean Whether all columns pass validation.
1131: * @see doValidate()
1132: * @see getValidationFailures()
1133: */
1134: public function validate($columns = null)
1135: {
1136: $res = $this->doValidate($columns);
1137: if ($res === true) {
1138: $this->validationFailures = array();
1139:
1140: return true;
1141: } else {
1142: $this->validationFailures = $res;
1143:
1144: return false;
1145: }
1146: }
1147:
1148: /**
1149: * This function performs the validation work for complex object models.
1150: *
1151: * In addition to checking the current object, all related objects will
1152: * also be validated. If all pass then <code>true</code> is returned; otherwise
1153: * an aggreagated array of ValidationFailed objects will be returned.
1154: *
1155: * @param array $columns Array of column names to validate.
1156: * @return mixed <code>true</code> if all validations pass; array of <code>ValidationFailed</code> objets otherwise.
1157: */
1158: protected function doValidate($columns = null)
1159: {
1160: if (!$this->alreadyInValidation) {
1161: $this->alreadyInValidation = true;
1162: $retval = null;
1163:
1164: $failureMap = array();
1165:
1166:
1167: if (($retval = ContentPeer::doValidate($this, $columns)) !== true) {
1168: $failureMap = array_merge($failureMap, $retval);
1169: }
1170:
1171:
1172: if ($this->collContentAssocs !== null) {
1173: foreach ($this->collContentAssocs as $referrerFK) {
1174: if (!$referrerFK->validate($columns)) {
1175: $failureMap = array_merge($failureMap, $referrerFK->getValidationFailures());
1176: }
1177: }
1178: }
1179:
1180: if ($this->collImages !== null) {
1181: foreach ($this->collImages as $referrerFK) {
1182: if (!$referrerFK->validate($columns)) {
1183: $failureMap = array_merge($failureMap, $referrerFK->getValidationFailures());
1184: }
1185: }
1186: }
1187:
1188: if ($this->collDocuments !== null) {
1189: foreach ($this->collDocuments as $referrerFK) {
1190: if (!$referrerFK->validate($columns)) {
1191: $failureMap = array_merge($failureMap, $referrerFK->getValidationFailures());
1192: }
1193: }
1194: }
1195:
1196: if ($this->collRewritings !== null) {
1197: foreach ($this->collRewritings as $referrerFK) {
1198: if (!$referrerFK->validate($columns)) {
1199: $failureMap = array_merge($failureMap, $referrerFK->getValidationFailures());
1200: }
1201: }
1202: }
1203:
1204: if ($this->collContentFolders !== null) {
1205: foreach ($this->collContentFolders as $referrerFK) {
1206: if (!$referrerFK->validate($columns)) {
1207: $failureMap = array_merge($failureMap, $referrerFK->getValidationFailures());
1208: }
1209: }
1210: }
1211:
1212: if ($this->collContentI18ns !== null) {
1213: foreach ($this->collContentI18ns as $referrerFK) {
1214: if (!$referrerFK->validate($columns)) {
1215: $failureMap = array_merge($failureMap, $referrerFK->getValidationFailures());
1216: }
1217: }
1218: }
1219:
1220: if ($this->collContentVersions !== null) {
1221: foreach ($this->collContentVersions as $referrerFK) {
1222: if (!$referrerFK->validate($columns)) {
1223: $failureMap = array_merge($failureMap, $referrerFK->getValidationFailures());
1224: }
1225: }
1226: }
1227:
1228:
1229: $this->alreadyInValidation = false;
1230: }
1231:
1232: return (!empty($failureMap) ? $failureMap : true);
1233: }
1234:
1235: /**
1236: * Retrieves a field from the object by name passed in as a string.
1237: *
1238: * @param string $name name
1239: * @param string $type The type of fieldname the $name is of:
1240: * one of the class type constants BasePeer::TYPE_PHPNAME, BasePeer::TYPE_STUDLYPHPNAME
1241: * BasePeer::TYPE_COLNAME, BasePeer::TYPE_FIELDNAME, BasePeer::TYPE_NUM.
1242: * Defaults to BasePeer::TYPE_PHPNAME
1243: * @return mixed Value of field.
1244: */
1245: public function getByName($name, $type = BasePeer::TYPE_PHPNAME)
1246: {
1247: $pos = ContentPeer::translateFieldName($name, $type, BasePeer::TYPE_NUM);
1248: $field = $this->getByPosition($pos);
1249:
1250: return $field;
1251: }
1252:
1253: /**
1254: * Retrieves a field from the object by Position as specified in the xml schema.
1255: * Zero-based.
1256: *
1257: * @param int $pos position in xml schema
1258: * @return mixed Value of field at $pos
1259: */
1260: public function getByPosition($pos)
1261: {
1262: switch ($pos) {
1263: case 0:
1264: return $this->getId();
1265: break;
1266: case 1:
1267: return $this->getVisible();
1268: break;
1269: case 2:
1270: return $this->getPosition();
1271: break;
1272: case 3:
1273: return $this->getCreatedAt();
1274: break;
1275: case 4:
1276: return $this->getUpdatedAt();
1277: break;
1278: case 5:
1279: return $this->getVersion();
1280: break;
1281: case 6:
1282: return $this->getVersionCreatedAt();
1283: break;
1284: case 7:
1285: return $this->getVersionCreatedBy();
1286: break;
1287: default:
1288: return null;
1289: break;
1290: } // switch()
1291: }
1292:
1293: /**
1294: * Exports the object as an array.
1295: *
1296: * You can specify the key type of the array by passing one of the class
1297: * type constants.
1298: *
1299: * @param string $keyType (optional) One of the class type constants BasePeer::TYPE_PHPNAME, BasePeer::TYPE_STUDLYPHPNAME,
1300: * BasePeer::TYPE_COLNAME, BasePeer::TYPE_FIELDNAME, BasePeer::TYPE_NUM.
1301: * Defaults to BasePeer::TYPE_PHPNAME.
1302: * @param boolean $includeLazyLoadColumns (optional) Whether to include lazy loaded columns. Defaults to true.
1303: * @param array $alreadyDumpedObjects List of objects to skip to avoid recursion
1304: * @param boolean $includeForeignObjects (optional) Whether to include hydrated related objects. Default to FALSE.
1305: *
1306: * @return array an associative array containing the field names (as keys) and field values
1307: */
1308: public function toArray($keyType = BasePeer::TYPE_PHPNAME, $includeLazyLoadColumns = true, $alreadyDumpedObjects = array(), $includeForeignObjects = false)
1309: {
1310: if (isset($alreadyDumpedObjects['Content'][$this->getPrimaryKey()])) {
1311: return '*RECURSION*';
1312: }
1313: $alreadyDumpedObjects['Content'][$this->getPrimaryKey()] = true;
1314: $keys = ContentPeer::getFieldNames($keyType);
1315: $result = array(
1316: $keys[0] => $this->getId(),
1317: $keys[1] => $this->getVisible(),
1318: $keys[2] => $this->getPosition(),
1319: $keys[3] => $this->getCreatedAt(),
1320: $keys[4] => $this->getUpdatedAt(),
1321: $keys[5] => $this->getVersion(),
1322: $keys[6] => $this->getVersionCreatedAt(),
1323: $keys[7] => $this->getVersionCreatedBy(),
1324: );
1325: if ($includeForeignObjects) {
1326: if (null !== $this->collContentAssocs) {
1327: $result['ContentAssocs'] = $this->collContentAssocs->toArray(null, true, $keyType, $includeLazyLoadColumns, $alreadyDumpedObjects);
1328: }
1329: if (null !== $this->collImages) {
1330: $result['Images'] = $this->collImages->toArray(null, true, $keyType, $includeLazyLoadColumns, $alreadyDumpedObjects);
1331: }
1332: if (null !== $this->collDocuments) {
1333: $result['Documents'] = $this->collDocuments->toArray(null, true, $keyType, $includeLazyLoadColumns, $alreadyDumpedObjects);
1334: }
1335: if (null !== $this->collRewritings) {
1336: $result['Rewritings'] = $this->collRewritings->toArray(null, true, $keyType, $includeLazyLoadColumns, $alreadyDumpedObjects);
1337: }
1338: if (null !== $this->collContentFolders) {
1339: $result['ContentFolders'] = $this->collContentFolders->toArray(null, true, $keyType, $includeLazyLoadColumns, $alreadyDumpedObjects);
1340: }
1341: if (null !== $this->collContentI18ns) {
1342: $result['ContentI18ns'] = $this->collContentI18ns->toArray(null, true, $keyType, $includeLazyLoadColumns, $alreadyDumpedObjects);
1343: }
1344: if (null !== $this->collContentVersions) {
1345: $result['ContentVersions'] = $this->collContentVersions->toArray(null, true, $keyType, $includeLazyLoadColumns, $alreadyDumpedObjects);
1346: }
1347: }
1348:
1349: return $result;
1350: }
1351:
1352: /**
1353: * Sets a field from the object by name passed in as a string.
1354: *
1355: * @param string $name peer name
1356: * @param mixed $value field value
1357: * @param string $type The type of fieldname the $name is of:
1358: * one of the class type constants BasePeer::TYPE_PHPNAME, BasePeer::TYPE_STUDLYPHPNAME
1359: * BasePeer::TYPE_COLNAME, BasePeer::TYPE_FIELDNAME, BasePeer::TYPE_NUM.
1360: * Defaults to BasePeer::TYPE_PHPNAME
1361: * @return void
1362: */
1363: public function setByName($name, $value, $type = BasePeer::TYPE_PHPNAME)
1364: {
1365: $pos = ContentPeer::translateFieldName($name, $type, BasePeer::TYPE_NUM);
1366:
1367: $this->setByPosition($pos, $value);
1368: }
1369:
1370: /**
1371: * Sets a field from the object by Position as specified in the xml schema.
1372: * Zero-based.
1373: *
1374: * @param int $pos position in xml schema
1375: * @param mixed $value field value
1376: * @return void
1377: */
1378: public function setByPosition($pos, $value)
1379: {
1380: switch ($pos) {
1381: case 0:
1382: $this->setId($value);
1383: break;
1384: case 1:
1385: $this->setVisible($value);
1386: break;
1387: case 2:
1388: $this->setPosition($value);
1389: break;
1390: case 3:
1391: $this->setCreatedAt($value);
1392: break;
1393: case 4:
1394: $this->setUpdatedAt($value);
1395: break;
1396: case 5:
1397: $this->setVersion($value);
1398: break;
1399: case 6:
1400: $this->setVersionCreatedAt($value);
1401: break;
1402: case 7:
1403: $this->setVersionCreatedBy($value);
1404: break;
1405: } // switch()
1406: }
1407:
1408: /**
1409: * Populates the object using an array.
1410: *
1411: * This is particularly useful when populating an object from one of the
1412: * request arrays (e.g. $_POST). This method goes through the column
1413: * names, checking to see whether a matching key exists in populated
1414: * array. If so the setByName() method is called for that column.
1415: *
1416: * You can specify the key type of the array by additionally passing one
1417: * of the class type constants BasePeer::TYPE_PHPNAME, BasePeer::TYPE_STUDLYPHPNAME,
1418: * BasePeer::TYPE_COLNAME, BasePeer::TYPE_FIELDNAME, BasePeer::TYPE_NUM.
1419: * The default key type is the column's BasePeer::TYPE_PHPNAME
1420: *
1421: * @param array $arr An array to populate the object from.
1422: * @param string $keyType The type of keys the array uses.
1423: * @return void
1424: */
1425: public function fromArray($arr, $keyType = BasePeer::TYPE_PHPNAME)
1426: {
1427: $keys = ContentPeer::getFieldNames($keyType);
1428:
1429: if (array_key_exists($keys[0], $arr)) $this->setId($arr[$keys[0]]);
1430: if (array_key_exists($keys[1], $arr)) $this->setVisible($arr[$keys[1]]);
1431: if (array_key_exists($keys[2], $arr)) $this->setPosition($arr[$keys[2]]);
1432: if (array_key_exists($keys[3], $arr)) $this->setCreatedAt($arr[$keys[3]]);
1433: if (array_key_exists($keys[4], $arr)) $this->setUpdatedAt($arr[$keys[4]]);
1434: if (array_key_exists($keys[5], $arr)) $this->setVersion($arr[$keys[5]]);
1435: if (array_key_exists($keys[6], $arr)) $this->setVersionCreatedAt($arr[$keys[6]]);
1436: if (array_key_exists($keys[7], $arr)) $this->setVersionCreatedBy($arr[$keys[7]]);
1437: }
1438:
1439: /**
1440: * Build a Criteria object containing the values of all modified columns in this object.
1441: *
1442: * @return Criteria The Criteria object containing all modified values.
1443: */
1444: public function buildCriteria()
1445: {
1446: $criteria = new Criteria(ContentPeer::DATABASE_NAME);
1447:
1448: if ($this->isColumnModified(ContentPeer::ID)) $criteria->add(ContentPeer::ID, $this->id);
1449: if ($this->isColumnModified(ContentPeer::VISIBLE)) $criteria->add(ContentPeer::VISIBLE, $this->visible);
1450: if ($this->isColumnModified(ContentPeer::POSITION)) $criteria->add(ContentPeer::POSITION, $this->position);
1451: if ($this->isColumnModified(ContentPeer::CREATED_AT)) $criteria->add(ContentPeer::CREATED_AT, $this->created_at);
1452: if ($this->isColumnModified(ContentPeer::UPDATED_AT)) $criteria->add(ContentPeer::UPDATED_AT, $this->updated_at);
1453: if ($this->isColumnModified(ContentPeer::VERSION)) $criteria->add(ContentPeer::VERSION, $this->version);
1454: if ($this->isColumnModified(ContentPeer::VERSION_CREATED_AT)) $criteria->add(ContentPeer::VERSION_CREATED_AT, $this->version_created_at);
1455: if ($this->isColumnModified(ContentPeer::VERSION_CREATED_BY)) $criteria->add(ContentPeer::VERSION_CREATED_BY, $this->version_created_by);
1456:
1457: return $criteria;
1458: }
1459:
1460: /**
1461: * Builds a Criteria object containing the primary key for this object.
1462: *
1463: * Unlike buildCriteria() this method includes the primary key values regardless
1464: * of whether or not they have been modified.
1465: *
1466: * @return Criteria The Criteria object containing value(s) for primary key(s).
1467: */
1468: public function buildPkeyCriteria()
1469: {
1470: $criteria = new Criteria(ContentPeer::DATABASE_NAME);
1471: $criteria->add(ContentPeer::ID, $this->id);
1472:
1473: return $criteria;
1474: }
1475:
1476: /**
1477: * Returns the primary key for this object (row).
1478: * @return int
1479: */
1480: public function getPrimaryKey()
1481: {
1482: return $this->getId();
1483: }
1484:
1485: /**
1486: * Generic method to set the primary key (id column).
1487: *
1488: * @param int $key Primary key.
1489: * @return void
1490: */
1491: public function setPrimaryKey($key)
1492: {
1493: $this->setId($key);
1494: }
1495:
1496: /**
1497: * Returns true if the primary key for this object is null.
1498: * @return boolean
1499: */
1500: public function isPrimaryKeyNull()
1501: {
1502:
1503: return null === $this->getId();
1504: }
1505:
1506: /**
1507: * Sets contents of passed object to values from current object.
1508: *
1509: * If desired, this method can also make copies of all associated (fkey referrers)
1510: * objects.
1511: *
1512: * @param object $copyObj An object of Content (or compatible) type.
1513: * @param boolean $deepCopy Whether to also copy all rows that refer (by fkey) to the current row.
1514: * @param boolean $makeNew Whether to reset autoincrement PKs and make the object new.
1515: * @throws PropelException
1516: */
1517: public function copyInto($copyObj, $deepCopy = false, $makeNew = true)
1518: {
1519: $copyObj->setVisible($this->getVisible());
1520: $copyObj->setPosition($this->getPosition());
1521: $copyObj->setCreatedAt($this->getCreatedAt());
1522: $copyObj->setUpdatedAt($this->getUpdatedAt());
1523: $copyObj->setVersion($this->getVersion());
1524: $copyObj->setVersionCreatedAt($this->getVersionCreatedAt());
1525: $copyObj->setVersionCreatedBy($this->getVersionCreatedBy());
1526:
1527: if ($deepCopy && !$this->startCopy) {
1528: // important: temporarily setNew(false) because this affects the behavior of
1529: // the getter/setter methods for fkey referrer objects.
1530: $copyObj->setNew(false);
1531: // store object hash to prevent cycle
1532: $this->startCopy = true;
1533:
1534: foreach ($this->getContentAssocs() as $relObj) {
1535: if ($relObj !== $this) { // ensure that we don't try to copy a reference to ourselves
1536: $copyObj->addContentAssoc($relObj->copy($deepCopy));
1537: }
1538: }
1539:
1540: foreach ($this->getImages() as $relObj) {
1541: if ($relObj !== $this) { // ensure that we don't try to copy a reference to ourselves
1542: $copyObj->addImage($relObj->copy($deepCopy));
1543: }
1544: }
1545:
1546: foreach ($this->getDocuments() as $relObj) {
1547: if ($relObj !== $this) { // ensure that we don't try to copy a reference to ourselves
1548: $copyObj->addDocument($relObj->copy($deepCopy));
1549: }
1550: }
1551:
1552: foreach ($this->getRewritings() as $relObj) {
1553: if ($relObj !== $this) { // ensure that we don't try to copy a reference to ourselves
1554: $copyObj->addRewriting($relObj->copy($deepCopy));
1555: }
1556: }
1557:
1558: foreach ($this->getContentFolders() as $relObj) {
1559: if ($relObj !== $this) { // ensure that we don't try to copy a reference to ourselves
1560: $copyObj->addContentFolder($relObj->copy($deepCopy));
1561: }
1562: }
1563:
1564: foreach ($this->getContentI18ns() as $relObj) {
1565: if ($relObj !== $this) { // ensure that we don't try to copy a reference to ourselves
1566: $copyObj->addContentI18n($relObj->copy($deepCopy));
1567: }
1568: }
1569:
1570: foreach ($this->getContentVersions() as $relObj) {
1571: if ($relObj !== $this) { // ensure that we don't try to copy a reference to ourselves
1572: $copyObj->addContentVersion($relObj->copy($deepCopy));
1573: }
1574: }
1575:
1576: //unflag object copy
1577: $this->startCopy = false;
1578: } // if ($deepCopy)
1579:
1580: if ($makeNew) {
1581: $copyObj->setNew(true);
1582: $copyObj->setId(NULL); // this is a auto-increment column, so set to default value
1583: }
1584: }
1585:
1586: /**
1587: * Makes a copy of this object that will be inserted as a new row in table when saved.
1588: * It creates a new object filling in the simple attributes, but skipping any primary
1589: * keys that are defined for the table.
1590: *
1591: * If desired, this method can also make copies of all associated (fkey referrers)
1592: * objects.
1593: *
1594: * @param boolean $deepCopy Whether to also copy all rows that refer (by fkey) to the current row.
1595: * @return Content Clone of current object.
1596: * @throws PropelException
1597: */
1598: public function copy($deepCopy = false)
1599: {
1600: // we use get_class(), because this might be a subclass
1601: $clazz = get_class($this);
1602: $copyObj = new $clazz();
1603: $this->copyInto($copyObj, $deepCopy);
1604:
1605: return $copyObj;
1606: }
1607:
1608: /**
1609: * Returns a peer instance associated with this om.
1610: *
1611: * Since Peer classes are not to have any instance attributes, this method returns the
1612: * same instance for all member of this class. The method could therefore
1613: * be static, but this would prevent one from overriding the behavior.
1614: *
1615: * @return ContentPeer
1616: */
1617: public function getPeer()
1618: {
1619: if (self::$peer === null) {
1620: self::$peer = new ContentPeer();
1621: }
1622:
1623: return self::$peer;
1624: }
1625:
1626:
1627: /**
1628: * Initializes a collection based on the name of a relation.
1629: * Avoids crafting an 'init[$relationName]s' method name
1630: * that wouldn't work when StandardEnglishPluralizer is used.
1631: *
1632: * @param string $relationName The name of the relation to initialize
1633: * @return void
1634: */
1635: public function initRelation($relationName)
1636: {
1637: if ('ContentAssoc' == $relationName) {
1638: $this->initContentAssocs();
1639: }
1640: if ('Image' == $relationName) {
1641: $this->initImages();
1642: }
1643: if ('Document' == $relationName) {
1644: $this->initDocuments();
1645: }
1646: if ('Rewriting' == $relationName) {
1647: $this->initRewritings();
1648: }
1649: if ('ContentFolder' == $relationName) {
1650: $this->initContentFolders();
1651: }
1652: if ('ContentI18n' == $relationName) {
1653: $this->initContentI18ns();
1654: }
1655: if ('ContentVersion' == $relationName) {
1656: $this->initContentVersions();
1657: }
1658: }
1659:
1660: /**
1661: * Clears out the collContentAssocs collection
1662: *
1663: * This does not modify the database; however, it will remove any associated objects, causing
1664: * them to be refetched by subsequent calls to accessor method.
1665: *
1666: * @return void
1667: * @see addContentAssocs()
1668: */
1669: public function clearContentAssocs()
1670: {
1671: $this->collContentAssocs = null; // important to set this to null since that means it is uninitialized
1672: $this->collContentAssocsPartial = null;
1673: }
1674:
1675: /**
1676: * reset is the collContentAssocs collection loaded partially
1677: *
1678: * @return void
1679: */
1680: public function resetPartialContentAssocs($v = true)
1681: {
1682: $this->collContentAssocsPartial = $v;
1683: }
1684:
1685: /**
1686: * Initializes the collContentAssocs collection.
1687: *
1688: * By default this just sets the collContentAssocs collection to an empty array (like clearcollContentAssocs());
1689: * however, you may wish to override this method in your stub class to provide setting appropriate
1690: * to your application -- for example, setting the initial array to the values stored in database.
1691: *
1692: * @param boolean $overrideExisting If set to true, the method call initializes
1693: * the collection even if it is not empty
1694: *
1695: * @return void
1696: */
1697: public function initContentAssocs($overrideExisting = true)
1698: {
1699: if (null !== $this->collContentAssocs && !$overrideExisting) {
1700: return;
1701: }
1702: $this->collContentAssocs = new PropelObjectCollection();
1703: $this->collContentAssocs->setModel('ContentAssoc');
1704: }
1705:
1706: /**
1707: * Gets an array of ContentAssoc objects which contain a foreign key that references this object.
1708: *
1709: * If the $criteria is not null, it is used to always fetch the results from the database.
1710: * Otherwise the results are fetched from the database the first time, then cached.
1711: * Next time the same method is called without $criteria, the cached collection is returned.
1712: * If this Content is new, it will return
1713: * an empty collection or the current collection; the criteria is ignored on a new object.
1714: *
1715: * @param Criteria $criteria optional Criteria object to narrow the query
1716: * @param PropelPDO $con optional connection object
1717: * @return PropelObjectCollection|ContentAssoc[] List of ContentAssoc objects
1718: * @throws PropelException
1719: */
1720: public function getContentAssocs($criteria = null, PropelPDO $con = null)
1721: {
1722: $partial = $this->collContentAssocsPartial && !$this->isNew();
1723: if (null === $this->collContentAssocs || null !== $criteria || $partial) {
1724: if ($this->isNew() && null === $this->collContentAssocs) {
1725: // return empty collection
1726: $this->initContentAssocs();
1727: } else {
1728: $collContentAssocs = ContentAssocQuery::create(null, $criteria)
1729: ->filterByContent($this)
1730: ->find($con);
1731: if (null !== $criteria) {
1732: if (false !== $this->collContentAssocsPartial && count($collContentAssocs)) {
1733: $this->initContentAssocs(false);
1734:
1735: foreach($collContentAssocs as $obj) {
1736: if (false == $this->collContentAssocs->contains($obj)) {
1737: $this->collContentAssocs->append($obj);
1738: }
1739: }
1740:
1741: $this->collContentAssocsPartial = true;
1742: }
1743:
1744: return $collContentAssocs;
1745: }
1746:
1747: if($partial && $this->collContentAssocs) {
1748: foreach($this->collContentAssocs as $obj) {
1749: if($obj->isNew()) {
1750: $collContentAssocs[] = $obj;
1751: }
1752: }
1753: }
1754:
1755: $this->collContentAssocs = $collContentAssocs;
1756: $this->collContentAssocsPartial = false;
1757: }
1758: }
1759:
1760: return $this->collContentAssocs;
1761: }
1762:
1763: /**
1764: * Sets a collection of ContentAssoc objects related by a one-to-many relationship
1765: * to the current object.
1766: * It will also schedule objects for deletion based on a diff between old objects (aka persisted)
1767: * and new objects from the given Propel collection.
1768: *
1769: * @param PropelCollection $contentAssocs A Propel collection.
1770: * @param PropelPDO $con Optional connection object
1771: */
1772: public function setContentAssocs(PropelCollection $contentAssocs, PropelPDO $con = null)
1773: {
1774: $this->contentAssocsScheduledForDeletion = $this->getContentAssocs(new Criteria(), $con)->diff($contentAssocs);
1775:
1776: foreach ($this->contentAssocsScheduledForDeletion as $contentAssocRemoved) {
1777: $contentAssocRemoved->setContent(null);
1778: }
1779:
1780: $this->collContentAssocs = null;
1781: foreach ($contentAssocs as $contentAssoc) {
1782: $this->addContentAssoc($contentAssoc);
1783: }
1784:
1785: $this->collContentAssocs = $contentAssocs;
1786: $this->collContentAssocsPartial = false;
1787: }
1788:
1789: /**
1790: * Returns the number of related ContentAssoc objects.
1791: *
1792: * @param Criteria $criteria
1793: * @param boolean $distinct
1794: * @param PropelPDO $con
1795: * @return int Count of related ContentAssoc objects.
1796: * @throws PropelException
1797: */
1798: public function countContentAssocs(Criteria $criteria = null, $distinct = false, PropelPDO $con = null)
1799: {
1800: $partial = $this->collContentAssocsPartial && !$this->isNew();
1801: if (null === $this->collContentAssocs || null !== $criteria || $partial) {
1802: if ($this->isNew() && null === $this->collContentAssocs) {
1803: return 0;
1804: } else {
1805: if($partial && !$criteria) {
1806: return count($this->getContentAssocs());
1807: }
1808: $query = ContentAssocQuery::create(null, $criteria);
1809: if ($distinct) {
1810: $query->distinct();
1811: }
1812:
1813: return $query
1814: ->filterByContent($this)
1815: ->count($con);
1816: }
1817: } else {
1818: return count($this->collContentAssocs);
1819: }
1820: }
1821:
1822: /**
1823: * Method called to associate a ContentAssoc object to this object
1824: * through the ContentAssoc foreign key attribute.
1825: *
1826: * @param ContentAssoc $l ContentAssoc
1827: * @return Content The current object (for fluent API support)
1828: */
1829: public function addContentAssoc(ContentAssoc $l)
1830: {
1831: if ($this->collContentAssocs === null) {
1832: $this->initContentAssocs();
1833: $this->collContentAssocsPartial = true;
1834: }
1835: if (!$this->collContentAssocs->contains($l)) { // only add it if the **same** object is not already associated
1836: $this->doAddContentAssoc($l);
1837: }
1838:
1839: return $this;
1840: }
1841:
1842: /**
1843: * @param ContentAssoc $contentAssoc The contentAssoc object to add.
1844: */
1845: protected function doAddContentAssoc($contentAssoc)
1846: {
1847: $this->collContentAssocs[]= $contentAssoc;
1848: $contentAssoc->setContent($this);
1849: }
1850:
1851: /**
1852: * @param ContentAssoc $contentAssoc The contentAssoc object to remove.
1853: */
1854: public function removeContentAssoc($contentAssoc)
1855: {
1856: if ($this->getContentAssocs()->contains($contentAssoc)) {
1857: $this->collContentAssocs->remove($this->collContentAssocs->search($contentAssoc));
1858: if (null === $this->contentAssocsScheduledForDeletion) {
1859: $this->contentAssocsScheduledForDeletion = clone $this->collContentAssocs;
1860: $this->contentAssocsScheduledForDeletion->clear();
1861: }
1862: $this->contentAssocsScheduledForDeletion[]= $contentAssoc;
1863: $contentAssoc->setContent(null);
1864: }
1865: }
1866:
1867:
1868: /**
1869: * If this collection has already been initialized with
1870: * an identical criteria, it returns the collection.
1871: * Otherwise if this Content is new, it will return
1872: * an empty collection; or if this Content has previously
1873: * been saved, it will retrieve related ContentAssocs from storage.
1874: *
1875: * This method is protected by default in order to keep the public
1876: * api reasonable. You can provide public methods for those you
1877: * actually need in Content.
1878: *
1879: * @param Criteria $criteria optional Criteria object to narrow the query
1880: * @param PropelPDO $con optional connection object
1881: * @param string $join_behavior optional join type to use (defaults to Criteria::LEFT_JOIN)
1882: * @return PropelObjectCollection|ContentAssoc[] List of ContentAssoc objects
1883: */
1884: public function getContentAssocsJoinCategory($criteria = null, $con = null, $join_behavior = Criteria::LEFT_JOIN)
1885: {
1886: $query = ContentAssocQuery::create(null, $criteria);
1887: $query->joinWith('Category', $join_behavior);
1888:
1889: return $this->getContentAssocs($query, $con);
1890: }
1891:
1892:
1893: /**
1894: * If this collection has already been initialized with
1895: * an identical criteria, it returns the collection.
1896: * Otherwise if this Content is new, it will return
1897: * an empty collection; or if this Content has previously
1898: * been saved, it will retrieve related ContentAssocs from storage.
1899: *
1900: * This method is protected by default in order to keep the public
1901: * api reasonable. You can provide public methods for those you
1902: * actually need in Content.
1903: *
1904: * @param Criteria $criteria optional Criteria object to narrow the query
1905: * @param PropelPDO $con optional connection object
1906: * @param string $join_behavior optional join type to use (defaults to Criteria::LEFT_JOIN)
1907: * @return PropelObjectCollection|ContentAssoc[] List of ContentAssoc objects
1908: */
1909: public function getContentAssocsJoinProduct($criteria = null, $con = null, $join_behavior = Criteria::LEFT_JOIN)
1910: {
1911: $query = ContentAssocQuery::create(null, $criteria);
1912: $query->joinWith('Product', $join_behavior);
1913:
1914: return $this->getContentAssocs($query, $con);
1915: }
1916:
1917: /**
1918: * Clears out the collImages collection
1919: *
1920: * This does not modify the database; however, it will remove any associated objects, causing
1921: * them to be refetched by subsequent calls to accessor method.
1922: *
1923: * @return void
1924: * @see addImages()
1925: */
1926: public function clearImages()
1927: {
1928: $this->collImages = null; // important to set this to null since that means it is uninitialized
1929: $this->collImagesPartial = null;
1930: }
1931:
1932: /**
1933: * reset is the collImages collection loaded partially
1934: *
1935: * @return void
1936: */
1937: public function resetPartialImages($v = true)
1938: {
1939: $this->collImagesPartial = $v;
1940: }
1941:
1942: /**
1943: * Initializes the collImages collection.
1944: *
1945: * By default this just sets the collImages collection to an empty array (like clearcollImages());
1946: * however, you may wish to override this method in your stub class to provide setting appropriate
1947: * to your application -- for example, setting the initial array to the values stored in database.
1948: *
1949: * @param boolean $overrideExisting If set to true, the method call initializes
1950: * the collection even if it is not empty
1951: *
1952: * @return void
1953: */
1954: public function initImages($overrideExisting = true)
1955: {
1956: if (null !== $this->collImages && !$overrideExisting) {
1957: return;
1958: }
1959: $this->collImages = new PropelObjectCollection();
1960: $this->collImages->setModel('Image');
1961: }
1962:
1963: /**
1964: * Gets an array of Image objects which contain a foreign key that references this object.
1965: *
1966: * If the $criteria is not null, it is used to always fetch the results from the database.
1967: * Otherwise the results are fetched from the database the first time, then cached.
1968: * Next time the same method is called without $criteria, the cached collection is returned.
1969: * If this Content is new, it will return
1970: * an empty collection or the current collection; the criteria is ignored on a new object.
1971: *
1972: * @param Criteria $criteria optional Criteria object to narrow the query
1973: * @param PropelPDO $con optional connection object
1974: * @return PropelObjectCollection|Image[] List of Image objects
1975: * @throws PropelException
1976: */
1977: public function getImages($criteria = null, PropelPDO $con = null)
1978: {
1979: $partial = $this->collImagesPartial && !$this->isNew();
1980: if (null === $this->collImages || null !== $criteria || $partial) {
1981: if ($this->isNew() && null === $this->collImages) {
1982: // return empty collection
1983: $this->initImages();
1984: } else {
1985: $collImages = ImageQuery::create(null, $criteria)
1986: ->filterByContent($this)
1987: ->find($con);
1988: if (null !== $criteria) {
1989: if (false !== $this->collImagesPartial && count($collImages)) {
1990: $this->initImages(false);
1991:
1992: foreach($collImages as $obj) {
1993: if (false == $this->collImages->contains($obj)) {
1994: $this->collImages->append($obj);
1995: }
1996: }
1997:
1998: $this->collImagesPartial = true;
1999: }
2000:
2001: return $collImages;
2002: }
2003:
2004: if($partial && $this->collImages) {
2005: foreach($this->collImages as $obj) {
2006: if($obj->isNew()) {
2007: $collImages[] = $obj;
2008: }
2009: }
2010: }
2011:
2012: $this->collImages = $collImages;
2013: $this->collImagesPartial = false;
2014: }
2015: }
2016:
2017: return $this->collImages;
2018: }
2019:
2020: /**
2021: * Sets a collection of Image objects related by a one-to-many relationship
2022: * to the current object.
2023: * It will also schedule objects for deletion based on a diff between old objects (aka persisted)
2024: * and new objects from the given Propel collection.
2025: *
2026: * @param PropelCollection $images A Propel collection.
2027: * @param PropelPDO $con Optional connection object
2028: */
2029: public function setImages(PropelCollection $images, PropelPDO $con = null)
2030: {
2031: $this->imagesScheduledForDeletion = $this->getImages(new Criteria(), $con)->diff($images);
2032:
2033: foreach ($this->imagesScheduledForDeletion as $imageRemoved) {
2034: $imageRemoved->setContent(null);
2035: }
2036:
2037: $this->collImages = null;
2038: foreach ($images as $image) {
2039: $this->addImage($image);
2040: }
2041:
2042: $this->collImages = $images;
2043: $this->collImagesPartial = false;
2044: }
2045:
2046: /**
2047: * Returns the number of related Image objects.
2048: *
2049: * @param Criteria $criteria
2050: * @param boolean $distinct
2051: * @param PropelPDO $con
2052: * @return int Count of related Image objects.
2053: * @throws PropelException
2054: */
2055: public function countImages(Criteria $criteria = null, $distinct = false, PropelPDO $con = null)
2056: {
2057: $partial = $this->collImagesPartial && !$this->isNew();
2058: if (null === $this->collImages || null !== $criteria || $partial) {
2059: if ($this->isNew() && null === $this->collImages) {
2060: return 0;
2061: } else {
2062: if($partial && !$criteria) {
2063: return count($this->getImages());
2064: }
2065: $query = ImageQuery::create(null, $criteria);
2066: if ($distinct) {
2067: $query->distinct();
2068: }
2069:
2070: return $query
2071: ->filterByContent($this)
2072: ->count($con);
2073: }
2074: } else {
2075: return count($this->collImages);
2076: }
2077: }
2078:
2079: /**
2080: * Method called to associate a Image object to this object
2081: * through the Image foreign key attribute.
2082: *
2083: * @param Image $l Image
2084: * @return Content The current object (for fluent API support)
2085: */
2086: public function addImage(Image $l)
2087: {
2088: if ($this->collImages === null) {
2089: $this->initImages();
2090: $this->collImagesPartial = true;
2091: }
2092: if (!$this->collImages->contains($l)) { // only add it if the **same** object is not already associated
2093: $this->doAddImage($l);
2094: }
2095:
2096: return $this;
2097: }
2098:
2099: /**
2100: * @param Image $image The image object to add.
2101: */
2102: protected function doAddImage($image)
2103: {
2104: $this->collImages[]= $image;
2105: $image->setContent($this);
2106: }
2107:
2108: /**
2109: * @param Image $image The image object to remove.
2110: */
2111: public function removeImage($image)
2112: {
2113: if ($this->getImages()->contains($image)) {
2114: $this->collImages->remove($this->collImages->search($image));
2115: if (null === $this->imagesScheduledForDeletion) {
2116: $this->imagesScheduledForDeletion = clone $this->collImages;
2117: $this->imagesScheduledForDeletion->clear();
2118: }
2119: $this->imagesScheduledForDeletion[]= $image;
2120: $image->setContent(null);
2121: }
2122: }
2123:
2124:
2125: /**
2126: * If this collection has already been initialized with
2127: * an identical criteria, it returns the collection.
2128: * Otherwise if this Content is new, it will return
2129: * an empty collection; or if this Content has previously
2130: * been saved, it will retrieve related Images from storage.
2131: *
2132: * This method is protected by default in order to keep the public
2133: * api reasonable. You can provide public methods for those you
2134: * actually need in Content.
2135: *
2136: * @param Criteria $criteria optional Criteria object to narrow the query
2137: * @param PropelPDO $con optional connection object
2138: * @param string $join_behavior optional join type to use (defaults to Criteria::LEFT_JOIN)
2139: * @return PropelObjectCollection|Image[] List of Image objects
2140: */
2141: public function getImagesJoinProduct($criteria = null, $con = null, $join_behavior = Criteria::LEFT_JOIN)
2142: {
2143: $query = ImageQuery::create(null, $criteria);
2144: $query->joinWith('Product', $join_behavior);
2145:
2146: return $this->getImages($query, $con);
2147: }
2148:
2149:
2150: /**
2151: * If this collection has already been initialized with
2152: * an identical criteria, it returns the collection.
2153: * Otherwise if this Content is new, it will return
2154: * an empty collection; or if this Content has previously
2155: * been saved, it will retrieve related Images from storage.
2156: *
2157: * This method is protected by default in order to keep the public
2158: * api reasonable. You can provide public methods for those you
2159: * actually need in Content.
2160: *
2161: * @param Criteria $criteria optional Criteria object to narrow the query
2162: * @param PropelPDO $con optional connection object
2163: * @param string $join_behavior optional join type to use (defaults to Criteria::LEFT_JOIN)
2164: * @return PropelObjectCollection|Image[] List of Image objects
2165: */
2166: public function getImagesJoinCategory($criteria = null, $con = null, $join_behavior = Criteria::LEFT_JOIN)
2167: {
2168: $query = ImageQuery::create(null, $criteria);
2169: $query->joinWith('Category', $join_behavior);
2170:
2171: return $this->getImages($query, $con);
2172: }
2173:
2174:
2175: /**
2176: * If this collection has already been initialized with
2177: * an identical criteria, it returns the collection.
2178: * Otherwise if this Content is new, it will return
2179: * an empty collection; or if this Content has previously
2180: * been saved, it will retrieve related Images from storage.
2181: *
2182: * This method is protected by default in order to keep the public
2183: * api reasonable. You can provide public methods for those you
2184: * actually need in Content.
2185: *
2186: * @param Criteria $criteria optional Criteria object to narrow the query
2187: * @param PropelPDO $con optional connection object
2188: * @param string $join_behavior optional join type to use (defaults to Criteria::LEFT_JOIN)
2189: * @return PropelObjectCollection|Image[] List of Image objects
2190: */
2191: public function getImagesJoinFolder($criteria = null, $con = null, $join_behavior = Criteria::LEFT_JOIN)
2192: {
2193: $query = ImageQuery::create(null, $criteria);
2194: $query->joinWith('Folder', $join_behavior);
2195:
2196: return $this->getImages($query, $con);
2197: }
2198:
2199: /**
2200: * Clears out the collDocuments collection
2201: *
2202: * This does not modify the database; however, it will remove any associated objects, causing
2203: * them to be refetched by subsequent calls to accessor method.
2204: *
2205: * @return void
2206: * @see addDocuments()
2207: */
2208: public function clearDocuments()
2209: {
2210: $this->collDocuments = null; // important to set this to null since that means it is uninitialized
2211: $this->collDocumentsPartial = null;
2212: }
2213:
2214: /**
2215: * reset is the collDocuments collection loaded partially
2216: *
2217: * @return void
2218: */
2219: public function resetPartialDocuments($v = true)
2220: {
2221: $this->collDocumentsPartial = $v;
2222: }
2223:
2224: /**
2225: * Initializes the collDocuments collection.
2226: *
2227: * By default this just sets the collDocuments collection to an empty array (like clearcollDocuments());
2228: * however, you may wish to override this method in your stub class to provide setting appropriate
2229: * to your application -- for example, setting the initial array to the values stored in database.
2230: *
2231: * @param boolean $overrideExisting If set to true, the method call initializes
2232: * the collection even if it is not empty
2233: *
2234: * @return void
2235: */
2236: public function initDocuments($overrideExisting = true)
2237: {
2238: if (null !== $this->collDocuments && !$overrideExisting) {
2239: return;
2240: }
2241: $this->collDocuments = new PropelObjectCollection();
2242: $this->collDocuments->setModel('Document');
2243: }
2244:
2245: /**
2246: * Gets an array of Document objects which contain a foreign key that references this object.
2247: *
2248: * If the $criteria is not null, it is used to always fetch the results from the database.
2249: * Otherwise the results are fetched from the database the first time, then cached.
2250: * Next time the same method is called without $criteria, the cached collection is returned.
2251: * If this Content is new, it will return
2252: * an empty collection or the current collection; the criteria is ignored on a new object.
2253: *
2254: * @param Criteria $criteria optional Criteria object to narrow the query
2255: * @param PropelPDO $con optional connection object
2256: * @return PropelObjectCollection|Document[] List of Document objects
2257: * @throws PropelException
2258: */
2259: public function getDocuments($criteria = null, PropelPDO $con = null)
2260: {
2261: $partial = $this->collDocumentsPartial && !$this->isNew();
2262: if (null === $this->collDocuments || null !== $criteria || $partial) {
2263: if ($this->isNew() && null === $this->collDocuments) {
2264: // return empty collection
2265: $this->initDocuments();
2266: } else {
2267: $collDocuments = DocumentQuery::create(null, $criteria)
2268: ->filterByContent($this)
2269: ->find($con);
2270: if (null !== $criteria) {
2271: if (false !== $this->collDocumentsPartial && count($collDocuments)) {
2272: $this->initDocuments(false);
2273:
2274: foreach($collDocuments as $obj) {
2275: if (false == $this->collDocuments->contains($obj)) {
2276: $this->collDocuments->append($obj);
2277: }
2278: }
2279:
2280: $this->collDocumentsPartial = true;
2281: }
2282:
2283: return $collDocuments;
2284: }
2285:
2286: if($partial && $this->collDocuments) {
2287: foreach($this->collDocuments as $obj) {
2288: if($obj->isNew()) {
2289: $collDocuments[] = $obj;
2290: }
2291: }
2292: }
2293:
2294: $this->collDocuments = $collDocuments;
2295: $this->collDocumentsPartial = false;
2296: }
2297: }
2298:
2299: return $this->collDocuments;
2300: }
2301:
2302: /**
2303: * Sets a collection of Document objects related by a one-to-many relationship
2304: * to the current object.
2305: * It will also schedule objects for deletion based on a diff between old objects (aka persisted)
2306: * and new objects from the given Propel collection.
2307: *
2308: * @param PropelCollection $documents A Propel collection.
2309: * @param PropelPDO $con Optional connection object
2310: */
2311: public function setDocuments(PropelCollection $documents, PropelPDO $con = null)
2312: {
2313: $this->documentsScheduledForDeletion = $this->getDocuments(new Criteria(), $con)->diff($documents);
2314:
2315: foreach ($this->documentsScheduledForDeletion as $documentRemoved) {
2316: $documentRemoved->setContent(null);
2317: }
2318:
2319: $this->collDocuments = null;
2320: foreach ($documents as $document) {
2321: $this->addDocument($document);
2322: }
2323:
2324: $this->collDocuments = $documents;
2325: $this->collDocumentsPartial = false;
2326: }
2327:
2328: /**
2329: * Returns the number of related Document objects.
2330: *
2331: * @param Criteria $criteria
2332: * @param boolean $distinct
2333: * @param PropelPDO $con
2334: * @return int Count of related Document objects.
2335: * @throws PropelException
2336: */
2337: public function countDocuments(Criteria $criteria = null, $distinct = false, PropelPDO $con = null)
2338: {
2339: $partial = $this->collDocumentsPartial && !$this->isNew();
2340: if (null === $this->collDocuments || null !== $criteria || $partial) {
2341: if ($this->isNew() && null === $this->collDocuments) {
2342: return 0;
2343: } else {
2344: if($partial && !$criteria) {
2345: return count($this->getDocuments());
2346: }
2347: $query = DocumentQuery::create(null, $criteria);
2348: if ($distinct) {
2349: $query->distinct();
2350: }
2351:
2352: return $query
2353: ->filterByContent($this)
2354: ->count($con);
2355: }
2356: } else {
2357: return count($this->collDocuments);
2358: }
2359: }
2360:
2361: /**
2362: * Method called to associate a Document object to this object
2363: * through the Document foreign key attribute.
2364: *
2365: * @param Document $l Document
2366: * @return Content The current object (for fluent API support)
2367: */
2368: public function addDocument(Document $l)
2369: {
2370: if ($this->collDocuments === null) {
2371: $this->initDocuments();
2372: $this->collDocumentsPartial = true;
2373: }
2374: if (!$this->collDocuments->contains($l)) { // only add it if the **same** object is not already associated
2375: $this->doAddDocument($l);
2376: }
2377:
2378: return $this;
2379: }
2380:
2381: /**
2382: * @param Document $document The document object to add.
2383: */
2384: protected function doAddDocument($document)
2385: {
2386: $this->collDocuments[]= $document;
2387: $document->setContent($this);
2388: }
2389:
2390: /**
2391: * @param Document $document The document object to remove.
2392: */
2393: public function removeDocument($document)
2394: {
2395: if ($this->getDocuments()->contains($document)) {
2396: $this->collDocuments->remove($this->collDocuments->search($document));
2397: if (null === $this->documentsScheduledForDeletion) {
2398: $this->documentsScheduledForDeletion = clone $this->collDocuments;
2399: $this->documentsScheduledForDeletion->clear();
2400: }
2401: $this->documentsScheduledForDeletion[]= $document;
2402: $document->setContent(null);
2403: }
2404: }
2405:
2406:
2407: /**
2408: * If this collection has already been initialized with
2409: * an identical criteria, it returns the collection.
2410: * Otherwise if this Content is new, it will return
2411: * an empty collection; or if this Content has previously
2412: * been saved, it will retrieve related Documents from storage.
2413: *
2414: * This method is protected by default in order to keep the public
2415: * api reasonable. You can provide public methods for those you
2416: * actually need in Content.
2417: *
2418: * @param Criteria $criteria optional Criteria object to narrow the query
2419: * @param PropelPDO $con optional connection object
2420: * @param string $join_behavior optional join type to use (defaults to Criteria::LEFT_JOIN)
2421: * @return PropelObjectCollection|Document[] List of Document objects
2422: */
2423: public function getDocumentsJoinProduct($criteria = null, $con = null, $join_behavior = Criteria::LEFT_JOIN)
2424: {
2425: $query = DocumentQuery::create(null, $criteria);
2426: $query->joinWith('Product', $join_behavior);
2427:
2428: return $this->getDocuments($query, $con);
2429: }
2430:
2431:
2432: /**
2433: * If this collection has already been initialized with
2434: * an identical criteria, it returns the collection.
2435: * Otherwise if this Content is new, it will return
2436: * an empty collection; or if this Content has previously
2437: * been saved, it will retrieve related Documents from storage.
2438: *
2439: * This method is protected by default in order to keep the public
2440: * api reasonable. You can provide public methods for those you
2441: * actually need in Content.
2442: *
2443: * @param Criteria $criteria optional Criteria object to narrow the query
2444: * @param PropelPDO $con optional connection object
2445: * @param string $join_behavior optional join type to use (defaults to Criteria::LEFT_JOIN)
2446: * @return PropelObjectCollection|Document[] List of Document objects
2447: */
2448: public function getDocumentsJoinCategory($criteria = null, $con = null, $join_behavior = Criteria::LEFT_JOIN)
2449: {
2450: $query = DocumentQuery::create(null, $criteria);
2451: $query->joinWith('Category', $join_behavior);
2452:
2453: return $this->getDocuments($query, $con);
2454: }
2455:
2456:
2457: /**
2458: * If this collection has already been initialized with
2459: * an identical criteria, it returns the collection.
2460: * Otherwise if this Content is new, it will return
2461: * an empty collection; or if this Content has previously
2462: * been saved, it will retrieve related Documents from storage.
2463: *
2464: * This method is protected by default in order to keep the public
2465: * api reasonable. You can provide public methods for those you
2466: * actually need in Content.
2467: *
2468: * @param Criteria $criteria optional Criteria object to narrow the query
2469: * @param PropelPDO $con optional connection object
2470: * @param string $join_behavior optional join type to use (defaults to Criteria::LEFT_JOIN)
2471: * @return PropelObjectCollection|Document[] List of Document objects
2472: */
2473: public function getDocumentsJoinFolder($criteria = null, $con = null, $join_behavior = Criteria::LEFT_JOIN)
2474: {
2475: $query = DocumentQuery::create(null, $criteria);
2476: $query->joinWith('Folder', $join_behavior);
2477:
2478: return $this->getDocuments($query, $con);
2479: }
2480:
2481: /**
2482: * Clears out the collRewritings collection
2483: *
2484: * This does not modify the database; however, it will remove any associated objects, causing
2485: * them to be refetched by subsequent calls to accessor method.
2486: *
2487: * @return void
2488: * @see addRewritings()
2489: */
2490: public function clearRewritings()
2491: {
2492: $this->collRewritings = null; // important to set this to null since that means it is uninitialized
2493: $this->collRewritingsPartial = null;
2494: }
2495:
2496: /**
2497: * reset is the collRewritings collection loaded partially
2498: *
2499: * @return void
2500: */
2501: public function resetPartialRewritings($v = true)
2502: {
2503: $this->collRewritingsPartial = $v;
2504: }
2505:
2506: /**
2507: * Initializes the collRewritings collection.
2508: *
2509: * By default this just sets the collRewritings collection to an empty array (like clearcollRewritings());
2510: * however, you may wish to override this method in your stub class to provide setting appropriate
2511: * to your application -- for example, setting the initial array to the values stored in database.
2512: *
2513: * @param boolean $overrideExisting If set to true, the method call initializes
2514: * the collection even if it is not empty
2515: *
2516: * @return void
2517: */
2518: public function initRewritings($overrideExisting = true)
2519: {
2520: if (null !== $this->collRewritings && !$overrideExisting) {
2521: return;
2522: }
2523: $this->collRewritings = new PropelObjectCollection();
2524: $this->collRewritings->setModel('Rewriting');
2525: }
2526:
2527: /**
2528: * Gets an array of Rewriting objects which contain a foreign key that references this object.
2529: *
2530: * If the $criteria is not null, it is used to always fetch the results from the database.
2531: * Otherwise the results are fetched from the database the first time, then cached.
2532: * Next time the same method is called without $criteria, the cached collection is returned.
2533: * If this Content is new, it will return
2534: * an empty collection or the current collection; the criteria is ignored on a new object.
2535: *
2536: * @param Criteria $criteria optional Criteria object to narrow the query
2537: * @param PropelPDO $con optional connection object
2538: * @return PropelObjectCollection|Rewriting[] List of Rewriting objects
2539: * @throws PropelException
2540: */
2541: public function getRewritings($criteria = null, PropelPDO $con = null)
2542: {
2543: $partial = $this->collRewritingsPartial && !$this->isNew();
2544: if (null === $this->collRewritings || null !== $criteria || $partial) {
2545: if ($this->isNew() && null === $this->collRewritings) {
2546: // return empty collection
2547: $this->initRewritings();
2548: } else {
2549: $collRewritings = RewritingQuery::create(null, $criteria)
2550: ->filterByContent($this)
2551: ->find($con);
2552: if (null !== $criteria) {
2553: if (false !== $this->collRewritingsPartial && count($collRewritings)) {
2554: $this->initRewritings(false);
2555:
2556: foreach($collRewritings as $obj) {
2557: if (false == $this->collRewritings->contains($obj)) {
2558: $this->collRewritings->append($obj);
2559: }
2560: }
2561:
2562: $this->collRewritingsPartial = true;
2563: }
2564:
2565: return $collRewritings;
2566: }
2567:
2568: if($partial && $this->collRewritings) {
2569: foreach($this->collRewritings as $obj) {
2570: if($obj->isNew()) {
2571: $collRewritings[] = $obj;
2572: }
2573: }
2574: }
2575:
2576: $this->collRewritings = $collRewritings;
2577: $this->collRewritingsPartial = false;
2578: }
2579: }
2580:
2581: return $this->collRewritings;
2582: }
2583:
2584: /**
2585: * Sets a collection of Rewriting objects related by a one-to-many relationship
2586: * to the current object.
2587: * It will also schedule objects for deletion based on a diff between old objects (aka persisted)
2588: * and new objects from the given Propel collection.
2589: *
2590: * @param PropelCollection $rewritings A Propel collection.
2591: * @param PropelPDO $con Optional connection object
2592: */
2593: public function setRewritings(PropelCollection $rewritings, PropelPDO $con = null)
2594: {
2595: $this->rewritingsScheduledForDeletion = $this->getRewritings(new Criteria(), $con)->diff($rewritings);
2596:
2597: foreach ($this->rewritingsScheduledForDeletion as $rewritingRemoved) {
2598: $rewritingRemoved->setContent(null);
2599: }
2600:
2601: $this->collRewritings = null;
2602: foreach ($rewritings as $rewriting) {
2603: $this->addRewriting($rewriting);
2604: }
2605:
2606: $this->collRewritings = $rewritings;
2607: $this->collRewritingsPartial = false;
2608: }
2609:
2610: /**
2611: * Returns the number of related Rewriting objects.
2612: *
2613: * @param Criteria $criteria
2614: * @param boolean $distinct
2615: * @param PropelPDO $con
2616: * @return int Count of related Rewriting objects.
2617: * @throws PropelException
2618: */
2619: public function countRewritings(Criteria $criteria = null, $distinct = false, PropelPDO $con = null)
2620: {
2621: $partial = $this->collRewritingsPartial && !$this->isNew();
2622: if (null === $this->collRewritings || null !== $criteria || $partial) {
2623: if ($this->isNew() && null === $this->collRewritings) {
2624: return 0;
2625: } else {
2626: if($partial && !$criteria) {
2627: return count($this->getRewritings());
2628: }
2629: $query = RewritingQuery::create(null, $criteria);
2630: if ($distinct) {
2631: $query->distinct();
2632: }
2633:
2634: return $query
2635: ->filterByContent($this)
2636: ->count($con);
2637: }
2638: } else {
2639: return count($this->collRewritings);
2640: }
2641: }
2642:
2643: /**
2644: * Method called to associate a Rewriting object to this object
2645: * through the Rewriting foreign key attribute.
2646: *
2647: * @param Rewriting $l Rewriting
2648: * @return Content The current object (for fluent API support)
2649: */
2650: public function addRewriting(Rewriting $l)
2651: {
2652: if ($this->collRewritings === null) {
2653: $this->initRewritings();
2654: $this->collRewritingsPartial = true;
2655: }
2656: if (!$this->collRewritings->contains($l)) { // only add it if the **same** object is not already associated
2657: $this->doAddRewriting($l);
2658: }
2659:
2660: return $this;
2661: }
2662:
2663: /**
2664: * @param Rewriting $rewriting The rewriting object to add.
2665: */
2666: protected function doAddRewriting($rewriting)
2667: {
2668: $this->collRewritings[]= $rewriting;
2669: $rewriting->setContent($this);
2670: }
2671:
2672: /**
2673: * @param Rewriting $rewriting The rewriting object to remove.
2674: */
2675: public function removeRewriting($rewriting)
2676: {
2677: if ($this->getRewritings()->contains($rewriting)) {
2678: $this->collRewritings->remove($this->collRewritings->search($rewriting));
2679: if (null === $this->rewritingsScheduledForDeletion) {
2680: $this->rewritingsScheduledForDeletion = clone $this->collRewritings;
2681: $this->rewritingsScheduledForDeletion->clear();
2682: }
2683: $this->rewritingsScheduledForDeletion[]= $rewriting;
2684: $rewriting->setContent(null);
2685: }
2686: }
2687:
2688:
2689: /**
2690: * If this collection has already been initialized with
2691: * an identical criteria, it returns the collection.
2692: * Otherwise if this Content is new, it will return
2693: * an empty collection; or if this Content has previously
2694: * been saved, it will retrieve related Rewritings from storage.
2695: *
2696: * This method is protected by default in order to keep the public
2697: * api reasonable. You can provide public methods for those you
2698: * actually need in Content.
2699: *
2700: * @param Criteria $criteria optional Criteria object to narrow the query
2701: * @param PropelPDO $con optional connection object
2702: * @param string $join_behavior optional join type to use (defaults to Criteria::LEFT_JOIN)
2703: * @return PropelObjectCollection|Rewriting[] List of Rewriting objects
2704: */
2705: public function getRewritingsJoinProduct($criteria = null, $con = null, $join_behavior = Criteria::LEFT_JOIN)
2706: {
2707: $query = RewritingQuery::create(null, $criteria);
2708: $query->joinWith('Product', $join_behavior);
2709:
2710: return $this->getRewritings($query, $con);
2711: }
2712:
2713:
2714: /**
2715: * If this collection has already been initialized with
2716: * an identical criteria, it returns the collection.
2717: * Otherwise if this Content is new, it will return
2718: * an empty collection; or if this Content has previously
2719: * been saved, it will retrieve related Rewritings from storage.
2720: *
2721: * This method is protected by default in order to keep the public
2722: * api reasonable. You can provide public methods for those you
2723: * actually need in Content.
2724: *
2725: * @param Criteria $criteria optional Criteria object to narrow the query
2726: * @param PropelPDO $con optional connection object
2727: * @param string $join_behavior optional join type to use (defaults to Criteria::LEFT_JOIN)
2728: * @return PropelObjectCollection|Rewriting[] List of Rewriting objects
2729: */
2730: public function getRewritingsJoinCategory($criteria = null, $con = null, $join_behavior = Criteria::LEFT_JOIN)
2731: {
2732: $query = RewritingQuery::create(null, $criteria);
2733: $query->joinWith('Category', $join_behavior);
2734:
2735: return $this->getRewritings($query, $con);
2736: }
2737:
2738:
2739: /**
2740: * If this collection has already been initialized with
2741: * an identical criteria, it returns the collection.
2742: * Otherwise if this Content is new, it will return
2743: * an empty collection; or if this Content has previously
2744: * been saved, it will retrieve related Rewritings from storage.
2745: *
2746: * This method is protected by default in order to keep the public
2747: * api reasonable. You can provide public methods for those you
2748: * actually need in Content.
2749: *
2750: * @param Criteria $criteria optional Criteria object to narrow the query
2751: * @param PropelPDO $con optional connection object
2752: * @param string $join_behavior optional join type to use (defaults to Criteria::LEFT_JOIN)
2753: * @return PropelObjectCollection|Rewriting[] List of Rewriting objects
2754: */
2755: public function getRewritingsJoinFolder($criteria = null, $con = null, $join_behavior = Criteria::LEFT_JOIN)
2756: {
2757: $query = RewritingQuery::create(null, $criteria);
2758: $query->joinWith('Folder', $join_behavior);
2759:
2760: return $this->getRewritings($query, $con);
2761: }
2762:
2763: /**
2764: * Clears out the collContentFolders collection
2765: *
2766: * This does not modify the database; however, it will remove any associated objects, causing
2767: * them to be refetched by subsequent calls to accessor method.
2768: *
2769: * @return void
2770: * @see addContentFolders()
2771: */
2772: public function clearContentFolders()
2773: {
2774: $this->collContentFolders = null; // important to set this to null since that means it is uninitialized
2775: $this->collContentFoldersPartial = null;
2776: }
2777:
2778: /**
2779: * reset is the collContentFolders collection loaded partially
2780: *
2781: * @return void
2782: */
2783: public function resetPartialContentFolders($v = true)
2784: {
2785: $this->collContentFoldersPartial = $v;
2786: }
2787:
2788: /**
2789: * Initializes the collContentFolders collection.
2790: *
2791: * By default this just sets the collContentFolders collection to an empty array (like clearcollContentFolders());
2792: * however, you may wish to override this method in your stub class to provide setting appropriate
2793: * to your application -- for example, setting the initial array to the values stored in database.
2794: *
2795: * @param boolean $overrideExisting If set to true, the method call initializes
2796: * the collection even if it is not empty
2797: *
2798: * @return void
2799: */
2800: public function initContentFolders($overrideExisting = true)
2801: {
2802: if (null !== $this->collContentFolders && !$overrideExisting) {
2803: return;
2804: }
2805: $this->collContentFolders = new PropelObjectCollection();
2806: $this->collContentFolders->setModel('ContentFolder');
2807: }
2808:
2809: /**
2810: * Gets an array of ContentFolder objects which contain a foreign key that references this object.
2811: *
2812: * If the $criteria is not null, it is used to always fetch the results from the database.
2813: * Otherwise the results are fetched from the database the first time, then cached.
2814: * Next time the same method is called without $criteria, the cached collection is returned.
2815: * If this Content is new, it will return
2816: * an empty collection or the current collection; the criteria is ignored on a new object.
2817: *
2818: * @param Criteria $criteria optional Criteria object to narrow the query
2819: * @param PropelPDO $con optional connection object
2820: * @return PropelObjectCollection|ContentFolder[] List of ContentFolder objects
2821: * @throws PropelException
2822: */
2823: public function getContentFolders($criteria = null, PropelPDO $con = null)
2824: {
2825: $partial = $this->collContentFoldersPartial && !$this->isNew();
2826: if (null === $this->collContentFolders || null !== $criteria || $partial) {
2827: if ($this->isNew() && null === $this->collContentFolders) {
2828: // return empty collection
2829: $this->initContentFolders();
2830: } else {
2831: $collContentFolders = ContentFolderQuery::create(null, $criteria)
2832: ->filterByContent($this)
2833: ->find($con);
2834: if (null !== $criteria) {
2835: if (false !== $this->collContentFoldersPartial && count($collContentFolders)) {
2836: $this->initContentFolders(false);
2837:
2838: foreach($collContentFolders as $obj) {
2839: if (false == $this->collContentFolders->contains($obj)) {
2840: $this->collContentFolders->append($obj);
2841: }
2842: }
2843:
2844: $this->collContentFoldersPartial = true;
2845: }
2846:
2847: return $collContentFolders;
2848: }
2849:
2850: if($partial && $this->collContentFolders) {
2851: foreach($this->collContentFolders as $obj) {
2852: if($obj->isNew()) {
2853: $collContentFolders[] = $obj;
2854: }
2855: }
2856: }
2857:
2858: $this->collContentFolders = $collContentFolders;
2859: $this->collContentFoldersPartial = false;
2860: }
2861: }
2862:
2863: return $this->collContentFolders;
2864: }
2865:
2866: /**
2867: * Sets a collection of ContentFolder objects related by a one-to-many relationship
2868: * to the current object.
2869: * It will also schedule objects for deletion based on a diff between old objects (aka persisted)
2870: * and new objects from the given Propel collection.
2871: *
2872: * @param PropelCollection $contentFolders A Propel collection.
2873: * @param PropelPDO $con Optional connection object
2874: */
2875: public function setContentFolders(PropelCollection $contentFolders, PropelPDO $con = null)
2876: {
2877: $this->contentFoldersScheduledForDeletion = $this->getContentFolders(new Criteria(), $con)->diff($contentFolders);
2878:
2879: foreach ($this->contentFoldersScheduledForDeletion as $contentFolderRemoved) {
2880: $contentFolderRemoved->setContent(null);
2881: }
2882:
2883: $this->collContentFolders = null;
2884: foreach ($contentFolders as $contentFolder) {
2885: $this->addContentFolder($contentFolder);
2886: }
2887:
2888: $this->collContentFolders = $contentFolders;
2889: $this->collContentFoldersPartial = false;
2890: }
2891:
2892: /**
2893: * Returns the number of related ContentFolder objects.
2894: *
2895: * @param Criteria $criteria
2896: * @param boolean $distinct
2897: * @param PropelPDO $con
2898: * @return int Count of related ContentFolder objects.
2899: * @throws PropelException
2900: */
2901: public function countContentFolders(Criteria $criteria = null, $distinct = false, PropelPDO $con = null)
2902: {
2903: $partial = $this->collContentFoldersPartial && !$this->isNew();
2904: if (null === $this->collContentFolders || null !== $criteria || $partial) {
2905: if ($this->isNew() && null === $this->collContentFolders) {
2906: return 0;
2907: } else {
2908: if($partial && !$criteria) {
2909: return count($this->getContentFolders());
2910: }
2911: $query = ContentFolderQuery::create(null, $criteria);
2912: if ($distinct) {
2913: $query->distinct();
2914: }
2915:
2916: return $query
2917: ->filterByContent($this)
2918: ->count($con);
2919: }
2920: } else {
2921: return count($this->collContentFolders);
2922: }
2923: }
2924:
2925: /**
2926: * Method called to associate a ContentFolder object to this object
2927: * through the ContentFolder foreign key attribute.
2928: *
2929: * @param ContentFolder $l ContentFolder
2930: * @return Content The current object (for fluent API support)
2931: */
2932: public function addContentFolder(ContentFolder $l)
2933: {
2934: if ($this->collContentFolders === null) {
2935: $this->initContentFolders();
2936: $this->collContentFoldersPartial = true;
2937: }
2938: if (!$this->collContentFolders->contains($l)) { // only add it if the **same** object is not already associated
2939: $this->doAddContentFolder($l);
2940: }
2941:
2942: return $this;
2943: }
2944:
2945: /**
2946: * @param ContentFolder $contentFolder The contentFolder object to add.
2947: */
2948: protected function doAddContentFolder($contentFolder)
2949: {
2950: $this->collContentFolders[]= $contentFolder;
2951: $contentFolder->setContent($this);
2952: }
2953:
2954: /**
2955: * @param ContentFolder $contentFolder The contentFolder object to remove.
2956: */
2957: public function removeContentFolder($contentFolder)
2958: {
2959: if ($this->getContentFolders()->contains($contentFolder)) {
2960: $this->collContentFolders->remove($this->collContentFolders->search($contentFolder));
2961: if (null === $this->contentFoldersScheduledForDeletion) {
2962: $this->contentFoldersScheduledForDeletion = clone $this->collContentFolders;
2963: $this->contentFoldersScheduledForDeletion->clear();
2964: }
2965: $this->contentFoldersScheduledForDeletion[]= $contentFolder;
2966: $contentFolder->setContent(null);
2967: }
2968: }
2969:
2970:
2971: /**
2972: * If this collection has already been initialized with
2973: * an identical criteria, it returns the collection.
2974: * Otherwise if this Content is new, it will return
2975: * an empty collection; or if this Content has previously
2976: * been saved, it will retrieve related ContentFolders from storage.
2977: *
2978: * This method is protected by default in order to keep the public
2979: * api reasonable. You can provide public methods for those you
2980: * actually need in Content.
2981: *
2982: * @param Criteria $criteria optional Criteria object to narrow the query
2983: * @param PropelPDO $con optional connection object
2984: * @param string $join_behavior optional join type to use (defaults to Criteria::LEFT_JOIN)
2985: * @return PropelObjectCollection|ContentFolder[] List of ContentFolder objects
2986: */
2987: public function getContentFoldersJoinFolder($criteria = null, $con = null, $join_behavior = Criteria::LEFT_JOIN)
2988: {
2989: $query = ContentFolderQuery::create(null, $criteria);
2990: $query->joinWith('Folder', $join_behavior);
2991:
2992: return $this->getContentFolders($query, $con);
2993: }
2994:
2995: /**
2996: * Clears out the collContentI18ns collection
2997: *
2998: * This does not modify the database; however, it will remove any associated objects, causing
2999: * them to be refetched by subsequent calls to accessor method.
3000: *
3001: * @return void
3002: * @see addContentI18ns()
3003: */
3004: public function clearContentI18ns()
3005: {
3006: $this->collContentI18ns = null; // important to set this to null since that means it is uninitialized
3007: $this->collContentI18nsPartial = null;
3008: }
3009:
3010: /**
3011: * reset is the collContentI18ns collection loaded partially
3012: *
3013: * @return void
3014: */
3015: public function resetPartialContentI18ns($v = true)
3016: {
3017: $this->collContentI18nsPartial = $v;
3018: }
3019:
3020: /**
3021: * Initializes the collContentI18ns collection.
3022: *
3023: * By default this just sets the collContentI18ns collection to an empty array (like clearcollContentI18ns());
3024: * however, you may wish to override this method in your stub class to provide setting appropriate
3025: * to your application -- for example, setting the initial array to the values stored in database.
3026: *
3027: * @param boolean $overrideExisting If set to true, the method call initializes
3028: * the collection even if it is not empty
3029: *
3030: * @return void
3031: */
3032: public function initContentI18ns($overrideExisting = true)
3033: {
3034: if (null !== $this->collContentI18ns && !$overrideExisting) {
3035: return;
3036: }
3037: $this->collContentI18ns = new PropelObjectCollection();
3038: $this->collContentI18ns->setModel('ContentI18n');
3039: }
3040:
3041: /**
3042: * Gets an array of ContentI18n objects which contain a foreign key that references this object.
3043: *
3044: * If the $criteria is not null, it is used to always fetch the results from the database.
3045: * Otherwise the results are fetched from the database the first time, then cached.
3046: * Next time the same method is called without $criteria, the cached collection is returned.
3047: * If this Content is new, it will return
3048: * an empty collection or the current collection; the criteria is ignored on a new object.
3049: *
3050: * @param Criteria $criteria optional Criteria object to narrow the query
3051: * @param PropelPDO $con optional connection object
3052: * @return PropelObjectCollection|ContentI18n[] List of ContentI18n objects
3053: * @throws PropelException
3054: */
3055: public function getContentI18ns($criteria = null, PropelPDO $con = null)
3056: {
3057: $partial = $this->collContentI18nsPartial && !$this->isNew();
3058: if (null === $this->collContentI18ns || null !== $criteria || $partial) {
3059: if ($this->isNew() && null === $this->collContentI18ns) {
3060: // return empty collection
3061: $this->initContentI18ns();
3062: } else {
3063: $collContentI18ns = ContentI18nQuery::create(null, $criteria)
3064: ->filterByContent($this)
3065: ->find($con);
3066: if (null !== $criteria) {
3067: if (false !== $this->collContentI18nsPartial && count($collContentI18ns)) {
3068: $this->initContentI18ns(false);
3069:
3070: foreach($collContentI18ns as $obj) {
3071: if (false == $this->collContentI18ns->contains($obj)) {
3072: $this->collContentI18ns->append($obj);
3073: }
3074: }
3075:
3076: $this->collContentI18nsPartial = true;
3077: }
3078:
3079: return $collContentI18ns;
3080: }
3081:
3082: if($partial && $this->collContentI18ns) {
3083: foreach($this->collContentI18ns as $obj) {
3084: if($obj->isNew()) {
3085: $collContentI18ns[] = $obj;
3086: }
3087: }
3088: }
3089:
3090: $this->collContentI18ns = $collContentI18ns;
3091: $this->collContentI18nsPartial = false;
3092: }
3093: }
3094:
3095: return $this->collContentI18ns;
3096: }
3097:
3098: /**
3099: * Sets a collection of ContentI18n objects related by a one-to-many relationship
3100: * to the current object.
3101: * It will also schedule objects for deletion based on a diff between old objects (aka persisted)
3102: * and new objects from the given Propel collection.
3103: *
3104: * @param PropelCollection $contentI18ns A Propel collection.
3105: * @param PropelPDO $con Optional connection object
3106: */
3107: public function setContentI18ns(PropelCollection $contentI18ns, PropelPDO $con = null)
3108: {
3109: $this->contentI18nsScheduledForDeletion = $this->getContentI18ns(new Criteria(), $con)->diff($contentI18ns);
3110:
3111: foreach ($this->contentI18nsScheduledForDeletion as $contentI18nRemoved) {
3112: $contentI18nRemoved->setContent(null);
3113: }
3114:
3115: $this->collContentI18ns = null;
3116: foreach ($contentI18ns as $contentI18n) {
3117: $this->addContentI18n($contentI18n);
3118: }
3119:
3120: $this->collContentI18ns = $contentI18ns;
3121: $this->collContentI18nsPartial = false;
3122: }
3123:
3124: /**
3125: * Returns the number of related ContentI18n objects.
3126: *
3127: * @param Criteria $criteria
3128: * @param boolean $distinct
3129: * @param PropelPDO $con
3130: * @return int Count of related ContentI18n objects.
3131: * @throws PropelException
3132: */
3133: public function countContentI18ns(Criteria $criteria = null, $distinct = false, PropelPDO $con = null)
3134: {
3135: $partial = $this->collContentI18nsPartial && !$this->isNew();
3136: if (null === $this->collContentI18ns || null !== $criteria || $partial) {
3137: if ($this->isNew() && null === $this->collContentI18ns) {
3138: return 0;
3139: } else {
3140: if($partial && !$criteria) {
3141: return count($this->getContentI18ns());
3142: }
3143: $query = ContentI18nQuery::create(null, $criteria);
3144: if ($distinct) {
3145: $query->distinct();
3146: }
3147:
3148: return $query
3149: ->filterByContent($this)
3150: ->count($con);
3151: }
3152: } else {
3153: return count($this->collContentI18ns);
3154: }
3155: }
3156:
3157: /**
3158: * Method called to associate a ContentI18n object to this object
3159: * through the ContentI18n foreign key attribute.
3160: *
3161: * @param ContentI18n $l ContentI18n
3162: * @return Content The current object (for fluent API support)
3163: */
3164: public function addContentI18n(ContentI18n $l)
3165: {
3166: if ($l && $locale = $l->getLocale()) {
3167: $this->setLocale($locale);
3168: $this->currentTranslations[$locale] = $l;
3169: }
3170: if ($this->collContentI18ns === null) {
3171: $this->initContentI18ns();
3172: $this->collContentI18nsPartial = true;
3173: }
3174: if (!$this->collContentI18ns->contains($l)) { // only add it if the **same** object is not already associated
3175: $this->doAddContentI18n($l);
3176: }
3177:
3178: return $this;
3179: }
3180:
3181: /**
3182: * @param ContentI18n $contentI18n The contentI18n object to add.
3183: */
3184: protected function doAddContentI18n($contentI18n)
3185: {
3186: $this->collContentI18ns[]= $contentI18n;
3187: $contentI18n->setContent($this);
3188: }
3189:
3190: /**
3191: * @param ContentI18n $contentI18n The contentI18n object to remove.
3192: */
3193: public function removeContentI18n($contentI18n)
3194: {
3195: if ($this->getContentI18ns()->contains($contentI18n)) {
3196: $this->collContentI18ns->remove($this->collContentI18ns->search($contentI18n));
3197: if (null === $this->contentI18nsScheduledForDeletion) {
3198: $this->contentI18nsScheduledForDeletion = clone $this->collContentI18ns;
3199: $this->contentI18nsScheduledForDeletion->clear();
3200: }
3201: $this->contentI18nsScheduledForDeletion[]= $contentI18n;
3202: $contentI18n->setContent(null);
3203: }
3204: }
3205:
3206: /**
3207: * Clears out the collContentVersions collection
3208: *
3209: * This does not modify the database; however, it will remove any associated objects, causing
3210: * them to be refetched by subsequent calls to accessor method.
3211: *
3212: * @return void
3213: * @see addContentVersions()
3214: */
3215: public function clearContentVersions()
3216: {
3217: $this->collContentVersions = null; // important to set this to null since that means it is uninitialized
3218: $this->collContentVersionsPartial = null;
3219: }
3220:
3221: /**
3222: * reset is the collContentVersions collection loaded partially
3223: *
3224: * @return void
3225: */
3226: public function resetPartialContentVersions($v = true)
3227: {
3228: $this->collContentVersionsPartial = $v;
3229: }
3230:
3231: /**
3232: * Initializes the collContentVersions collection.
3233: *
3234: * By default this just sets the collContentVersions collection to an empty array (like clearcollContentVersions());
3235: * however, you may wish to override this method in your stub class to provide setting appropriate
3236: * to your application -- for example, setting the initial array to the values stored in database.
3237: *
3238: * @param boolean $overrideExisting If set to true, the method call initializes
3239: * the collection even if it is not empty
3240: *
3241: * @return void
3242: */
3243: public function initContentVersions($overrideExisting = true)
3244: {
3245: if (null !== $this->collContentVersions && !$overrideExisting) {
3246: return;
3247: }
3248: $this->collContentVersions = new PropelObjectCollection();
3249: $this->collContentVersions->setModel('ContentVersion');
3250: }
3251:
3252: /**
3253: * Gets an array of ContentVersion objects which contain a foreign key that references this object.
3254: *
3255: * If the $criteria is not null, it is used to always fetch the results from the database.
3256: * Otherwise the results are fetched from the database the first time, then cached.
3257: * Next time the same method is called without $criteria, the cached collection is returned.
3258: * If this Content is new, it will return
3259: * an empty collection or the current collection; the criteria is ignored on a new object.
3260: *
3261: * @param Criteria $criteria optional Criteria object to narrow the query
3262: * @param PropelPDO $con optional connection object
3263: * @return PropelObjectCollection|ContentVersion[] List of ContentVersion objects
3264: * @throws PropelException
3265: */
3266: public function getContentVersions($criteria = null, PropelPDO $con = null)
3267: {
3268: $partial = $this->collContentVersionsPartial && !$this->isNew();
3269: if (null === $this->collContentVersions || null !== $criteria || $partial) {
3270: if ($this->isNew() && null === $this->collContentVersions) {
3271: // return empty collection
3272: $this->initContentVersions();
3273: } else {
3274: $collContentVersions = ContentVersionQuery::create(null, $criteria)
3275: ->filterByContent($this)
3276: ->find($con);
3277: if (null !== $criteria) {
3278: if (false !== $this->collContentVersionsPartial && count($collContentVersions)) {
3279: $this->initContentVersions(false);
3280:
3281: foreach($collContentVersions as $obj) {
3282: if (false == $this->collContentVersions->contains($obj)) {
3283: $this->collContentVersions->append($obj);
3284: }
3285: }
3286:
3287: $this->collContentVersionsPartial = true;
3288: }
3289:
3290: return $collContentVersions;
3291: }
3292:
3293: if($partial && $this->collContentVersions) {
3294: foreach($this->collContentVersions as $obj) {
3295: if($obj->isNew()) {
3296: $collContentVersions[] = $obj;
3297: }
3298: }
3299: }
3300:
3301: $this->collContentVersions = $collContentVersions;
3302: $this->collContentVersionsPartial = false;
3303: }
3304: }
3305:
3306: return $this->collContentVersions;
3307: }
3308:
3309: /**
3310: * Sets a collection of ContentVersion objects related by a one-to-many relationship
3311: * to the current object.
3312: * It will also schedule objects for deletion based on a diff between old objects (aka persisted)
3313: * and new objects from the given Propel collection.
3314: *
3315: * @param PropelCollection $contentVersions A Propel collection.
3316: * @param PropelPDO $con Optional connection object
3317: */
3318: public function setContentVersions(PropelCollection $contentVersions, PropelPDO $con = null)
3319: {
3320: $this->contentVersionsScheduledForDeletion = $this->getContentVersions(new Criteria(), $con)->diff($contentVersions);
3321:
3322: foreach ($this->contentVersionsScheduledForDeletion as $contentVersionRemoved) {
3323: $contentVersionRemoved->setContent(null);
3324: }
3325:
3326: $this->collContentVersions = null;
3327: foreach ($contentVersions as $contentVersion) {
3328: $this->addContentVersion($contentVersion);
3329: }
3330:
3331: $this->collContentVersions = $contentVersions;
3332: $this->collContentVersionsPartial = false;
3333: }
3334:
3335: /**
3336: * Returns the number of related ContentVersion objects.
3337: *
3338: * @param Criteria $criteria
3339: * @param boolean $distinct
3340: * @param PropelPDO $con
3341: * @return int Count of related ContentVersion objects.
3342: * @throws PropelException
3343: */
3344: public function countContentVersions(Criteria $criteria = null, $distinct = false, PropelPDO $con = null)
3345: {
3346: $partial = $this->collContentVersionsPartial && !$this->isNew();
3347: if (null === $this->collContentVersions || null !== $criteria || $partial) {
3348: if ($this->isNew() && null === $this->collContentVersions) {
3349: return 0;
3350: } else {
3351: if($partial && !$criteria) {
3352: return count($this->getContentVersions());
3353: }
3354: $query = ContentVersionQuery::create(null, $criteria);
3355: if ($distinct) {
3356: $query->distinct();
3357: }
3358:
3359: return $query
3360: ->filterByContent($this)
3361: ->count($con);
3362: }
3363: } else {
3364: return count($this->collContentVersions);
3365: }
3366: }
3367:
3368: /**
3369: * Method called to associate a ContentVersion object to this object
3370: * through the ContentVersion foreign key attribute.
3371: *
3372: * @param ContentVersion $l ContentVersion
3373: * @return Content The current object (for fluent API support)
3374: */
3375: public function addContentVersion(ContentVersion $l)
3376: {
3377: if ($this->collContentVersions === null) {
3378: $this->initContentVersions();
3379: $this->collContentVersionsPartial = true;
3380: }
3381: if (!$this->collContentVersions->contains($l)) { // only add it if the **same** object is not already associated
3382: $this->doAddContentVersion($l);
3383: }
3384:
3385: return $this;
3386: }
3387:
3388: /**
3389: * @param ContentVersion $contentVersion The contentVersion object to add.
3390: */
3391: protected function doAddContentVersion($contentVersion)
3392: {
3393: $this->collContentVersions[]= $contentVersion;
3394: $contentVersion->setContent($this);
3395: }
3396:
3397: /**
3398: * @param ContentVersion $contentVersion The contentVersion object to remove.
3399: */
3400: public function removeContentVersion($contentVersion)
3401: {
3402: if ($this->getContentVersions()->contains($contentVersion)) {
3403: $this->collContentVersions->remove($this->collContentVersions->search($contentVersion));
3404: if (null === $this->contentVersionsScheduledForDeletion) {
3405: $this->contentVersionsScheduledForDeletion = clone $this->collContentVersions;
3406: $this->contentVersionsScheduledForDeletion->clear();
3407: }
3408: $this->contentVersionsScheduledForDeletion[]= $contentVersion;
3409: $contentVersion->setContent(null);
3410: }
3411: }
3412:
3413: /**
3414: * Clears the current object and sets all attributes to their default values
3415: */
3416: public function clear()
3417: {
3418: $this->id = null;
3419: $this->visible = null;
3420: $this->position = null;
3421: $this->created_at = null;
3422: $this->updated_at = null;
3423: $this->version = null;
3424: $this->version_created_at = null;
3425: $this->version_created_by = null;
3426: $this->alreadyInSave = false;
3427: $this->alreadyInValidation = false;
3428: $this->clearAllReferences();
3429: $this->applyDefaultValues();
3430: $this->resetModified();
3431: $this->setNew(true);
3432: $this->setDeleted(false);
3433: }
3434:
3435: /**
3436: * Resets all references to other model objects or collections of model objects.
3437: *
3438: * This method is a user-space workaround for PHP's inability to garbage collect
3439: * objects with circular references (even in PHP 5.3). This is currently necessary
3440: * when using Propel in certain daemon or large-volumne/high-memory operations.
3441: *
3442: * @param boolean $deep Whether to also clear the references on all referrer objects.
3443: */
3444: public function clearAllReferences($deep = false)
3445: {
3446: if ($deep) {
3447: if ($this->collContentAssocs) {
3448: foreach ($this->collContentAssocs as $o) {
3449: $o->clearAllReferences($deep);
3450: }
3451: }
3452: if ($this->collImages) {
3453: foreach ($this->collImages as $o) {
3454: $o->clearAllReferences($deep);
3455: }
3456: }
3457: if ($this->collDocuments) {
3458: foreach ($this->collDocuments as $o) {
3459: $o->clearAllReferences($deep);
3460: }
3461: }
3462: if ($this->collRewritings) {
3463: foreach ($this->collRewritings as $o) {
3464: $o->clearAllReferences($deep);
3465: }
3466: }
3467: if ($this->collContentFolders) {
3468: foreach ($this->collContentFolders as $o) {
3469: $o->clearAllReferences($deep);
3470: }
3471: }
3472: if ($this->collContentI18ns) {
3473: foreach ($this->collContentI18ns as $o) {
3474: $o->clearAllReferences($deep);
3475: }
3476: }
3477: if ($this->collContentVersions) {
3478: foreach ($this->collContentVersions as $o) {
3479: $o->clearAllReferences($deep);
3480: }
3481: }
3482: } // if ($deep)
3483:
3484: // i18n behavior
3485: $this->currentLocale = 'en_EN';
3486: $this->currentTranslations = null;
3487:
3488: if ($this->collContentAssocs instanceof PropelCollection) {
3489: $this->collContentAssocs->clearIterator();
3490: }
3491: $this->collContentAssocs = null;
3492: if ($this->collImages instanceof PropelCollection) {
3493: $this->collImages->clearIterator();
3494: }
3495: $this->collImages = null;
3496: if ($this->collDocuments instanceof PropelCollection) {
3497: $this->collDocuments->clearIterator();
3498: }
3499: $this->collDocuments = null;
3500: if ($this->collRewritings instanceof PropelCollection) {
3501: $this->collRewritings->clearIterator();
3502: }
3503: $this->collRewritings = null;
3504: if ($this->collContentFolders instanceof PropelCollection) {
3505: $this->collContentFolders->clearIterator();
3506: }
3507: $this->collContentFolders = null;
3508: if ($this->collContentI18ns instanceof PropelCollection) {
3509: $this->collContentI18ns->clearIterator();
3510: }
3511: $this->collContentI18ns = null;
3512: if ($this->collContentVersions instanceof PropelCollection) {
3513: $this->collContentVersions->clearIterator();
3514: }
3515: $this->collContentVersions = null;
3516: }
3517:
3518: /**
3519: * return the string representation of this object
3520: *
3521: * @return string
3522: */
3523: public function __toString()
3524: {
3525: return (string) $this->exportTo(ContentPeer::DEFAULT_STRING_FORMAT);
3526: }
3527:
3528: /**
3529: * return true is the object is in saving state
3530: *
3531: * @return boolean
3532: */
3533: public function isAlreadyInSave()
3534: {
3535: return $this->alreadyInSave;
3536: }
3537:
3538: // timestampable behavior
3539:
3540: /**
3541: * Mark the current object so that the update date doesn't get updated during next save
3542: *
3543: * @return Content The current object (for fluent API support)
3544: */
3545: public function keepUpdateDateUnchanged()
3546: {
3547: $this->modifiedColumns[] = ContentPeer::UPDATED_AT;
3548:
3549: return $this;
3550: }
3551:
3552: // i18n behavior
3553:
3554: /**
3555: * Sets the locale for translations
3556: *
3557: * @param string $locale Locale to use for the translation, e.g. 'fr_FR'
3558: *
3559: * @return Content The current object (for fluent API support)
3560: */
3561: public function setLocale($locale = 'en_EN')
3562: {
3563: $this->currentLocale = $locale;
3564:
3565: return $this;
3566: }
3567:
3568: /**
3569: * Gets the locale for translations
3570: *
3571: * @return string $locale Locale to use for the translation, e.g. 'fr_FR'
3572: */
3573: public function getLocale()
3574: {
3575: return $this->currentLocale;
3576: }
3577:
3578: /**
3579: * Returns the current translation for a given locale
3580: *
3581: * @param string $locale Locale to use for the translation, e.g. 'fr_FR'
3582: * @param PropelPDO $con an optional connection object
3583: *
3584: * @return ContentI18n */
3585: public function getTranslation($locale = 'en_EN', PropelPDO $con = null)
3586: {
3587: if (!isset($this->currentTranslations[$locale])) {
3588: if (null !== $this->collContentI18ns) {
3589: foreach ($this->collContentI18ns as $translation) {
3590: if ($translation->getLocale() == $locale) {
3591: $this->currentTranslations[$locale] = $translation;
3592:
3593: return $translation;
3594: }
3595: }
3596: }
3597: if ($this->isNew()) {
3598: $translation = new ContentI18n();
3599: $translation->setLocale($locale);
3600: } else {
3601: $translation = ContentI18nQuery::create()
3602: ->filterByPrimaryKey(array($this->getPrimaryKey(), $locale))
3603: ->findOneOrCreate($con);
3604: $this->currentTranslations[$locale] = $translation;
3605: }
3606: $this->addContentI18n($translation);
3607: }
3608:
3609: return $this->currentTranslations[$locale];
3610: }
3611:
3612: /**
3613: * Remove the translation for a given locale
3614: *
3615: * @param string $locale Locale to use for the translation, e.g. 'fr_FR'
3616: * @param PropelPDO $con an optional connection object
3617: *
3618: * @return Content The current object (for fluent API support)
3619: */
3620: public function removeTranslation($locale = 'en_EN', PropelPDO $con = null)
3621: {
3622: if (!$this->isNew()) {
3623: ContentI18nQuery::create()
3624: ->filterByPrimaryKey(array($this->getPrimaryKey(), $locale))
3625: ->delete($con);
3626: }
3627: if (isset($this->currentTranslations[$locale])) {
3628: unset($this->currentTranslations[$locale]);
3629: }
3630: foreach ($this->collContentI18ns as $key => $translation) {
3631: if ($translation->getLocale() == $locale) {
3632: unset($this->collContentI18ns[$key]);
3633: break;
3634: }
3635: }
3636:
3637: return $this;
3638: }
3639:
3640: /**
3641: * Returns the current translation
3642: *
3643: * @param PropelPDO $con an optional connection object
3644: *
3645: * @return ContentI18n */
3646: public function getCurrentTranslation(PropelPDO $con = null)
3647: {
3648: return $this->getTranslation($this->getLocale(), $con);
3649: }
3650:
3651:
3652: /**
3653: * Get the [title] column value.
3654: *
3655: * @return string
3656: */
3657: public function getTitle()
3658: {
3659: return $this->getCurrentTranslation()->getTitle();
3660: }
3661:
3662:
3663: /**
3664: * Set the value of [title] column.
3665: *
3666: * @param string $v new value
3667: * @return ContentI18n The current object (for fluent API support)
3668: */
3669: public function setTitle($v)
3670: { $this->getCurrentTranslation()->setTitle($v);
3671:
3672: return $this;
3673: }
3674:
3675:
3676: /**
3677: * Get the [description] column value.
3678: *
3679: * @return string
3680: */
3681: public function getDescription()
3682: {
3683: return $this->getCurrentTranslation()->getDescription();
3684: }
3685:
3686:
3687: /**
3688: * Set the value of [description] column.
3689: *
3690: * @param string $v new value
3691: * @return ContentI18n The current object (for fluent API support)
3692: */
3693: public function setDescription($v)
3694: { $this->getCurrentTranslation()->setDescription($v);
3695:
3696: return $this;
3697: }
3698:
3699:
3700: /**
3701: * Get the [chapo] column value.
3702: *
3703: * @return string
3704: */
3705: public function getChapo()
3706: {
3707: return $this->getCurrentTranslation()->getChapo();
3708: }
3709:
3710:
3711: /**
3712: * Set the value of [chapo] column.
3713: *
3714: * @param string $v new value
3715: * @return ContentI18n The current object (for fluent API support)
3716: */
3717: public function setChapo($v)
3718: { $this->getCurrentTranslation()->setChapo($v);
3719:
3720: return $this;
3721: }
3722:
3723:
3724: /**
3725: * Get the [postscriptum] column value.
3726: *
3727: * @return string
3728: */
3729: public function getPostscriptum()
3730: {
3731: return $this->getCurrentTranslation()->getPostscriptum();
3732: }
3733:
3734:
3735: /**
3736: * Set the value of [postscriptum] column.
3737: *
3738: * @param string $v new value
3739: * @return ContentI18n The current object (for fluent API support)
3740: */
3741: public function setPostscriptum($v)
3742: { $this->getCurrentTranslation()->setPostscriptum($v);
3743:
3744: return $this;
3745: }
3746:
3747: // versionable behavior
3748:
3749: /**
3750: * Enforce a new Version of this object upon next save.
3751: *
3752: * @return Content
3753: */
3754: public function enforceVersioning()
3755: {
3756: $this->enforceVersion = true;
3757:
3758: return $this;
3759: }
3760:
3761: /**
3762: * Checks whether the current state must be recorded as a version
3763: *
3764: * @param PropelPDO $con An optional PropelPDO connection to use.
3765: *
3766: * @return boolean
3767: */
3768: public function isVersioningNecessary($con = null)
3769: {
3770: if ($this->alreadyInSave) {
3771: return false;
3772: }
3773:
3774: if ($this->enforceVersion) {
3775: return true;
3776: }
3777:
3778: if (ContentPeer::isVersioningEnabled() && ($this->isNew() || $this->isModified() || $this->isDeleted())) {
3779: return true;
3780: }
3781:
3782: return false;
3783: }
3784:
3785: /**
3786: * Creates a version of the current object and saves it.
3787: *
3788: * @param PropelPDO $con the connection to use
3789: *
3790: * @return ContentVersion A version object
3791: */
3792: public function addVersion($con = null)
3793: {
3794: $this->enforceVersion = false;
3795:
3796: $version = new ContentVersion();
3797: $version->setId($this->getId());
3798: $version->setVisible($this->getVisible());
3799: $version->setPosition($this->getPosition());
3800: $version->setCreatedAt($this->getCreatedAt());
3801: $version->setUpdatedAt($this->getUpdatedAt());
3802: $version->setVersion($this->getVersion());
3803: $version->setVersionCreatedAt($this->getVersionCreatedAt());
3804: $version->setVersionCreatedBy($this->getVersionCreatedBy());
3805: $version->setContent($this);
3806: $version->save($con);
3807:
3808: return $version;
3809: }
3810:
3811: /**
3812: * Sets the properties of the curent object to the value they had at a specific version
3813: *
3814: * @param integer $versionNumber The version number to read
3815: * @param PropelPDO $con the connection to use
3816: *
3817: * @return Content The current object (for fluent API support)
3818: * @throws PropelException - if no object with the given version can be found.
3819: */
3820: public function toVersion($versionNumber, $con = null)
3821: {
3822: $version = $this->getOneVersion($versionNumber, $con);
3823: if (!$version) {
3824: throw new PropelException(sprintf('No Content object found with version %d', $version));
3825: }
3826: $this->populateFromVersion($version, $con);
3827:
3828: return $this;
3829: }
3830:
3831: /**
3832: * Sets the properties of the curent object to the value they had at a specific version
3833: *
3834: * @param ContentVersion $version The version object to use
3835: * @param PropelPDO $con the connection to use
3836: * @param array $loadedObjects objects thats been loaded in a chain of populateFromVersion calls on referrer or fk objects.
3837: *
3838: * @return Content The current object (for fluent API support)
3839: */
3840: public function populateFromVersion($version, $con = null, &$loadedObjects = array())
3841: {
3842:
3843: $loadedObjects['Content'][$version->getId()][$version->getVersion()] = $this;
3844: $this->setId($version->getId());
3845: $this->setVisible($version->getVisible());
3846: $this->setPosition($version->getPosition());
3847: $this->setCreatedAt($version->getCreatedAt());
3848: $this->setUpdatedAt($version->getUpdatedAt());
3849: $this->setVersion($version->getVersion());
3850: $this->setVersionCreatedAt($version->getVersionCreatedAt());
3851: $this->setVersionCreatedBy($version->getVersionCreatedBy());
3852:
3853: return $this;
3854: }
3855:
3856: /**
3857: * Gets the latest persisted version number for the current object
3858: *
3859: * @param PropelPDO $con the connection to use
3860: *
3861: * @return integer
3862: */
3863: public function getLastVersionNumber($con = null)
3864: {
3865: $v = ContentVersionQuery::create()
3866: ->filterByContent($this)
3867: ->orderByVersion('desc')
3868: ->findOne($con);
3869: if (!$v) {
3870: return 0;
3871: }
3872:
3873: return $v->getVersion();
3874: }
3875:
3876: /**
3877: * Checks whether the current object is the latest one
3878: *
3879: * @param PropelPDO $con the connection to use
3880: *
3881: * @return boolean
3882: */
3883: public function isLastVersion($con = null)
3884: {
3885: return $this->getLastVersionNumber($con) == $this->getVersion();
3886: }
3887:
3888: /**
3889: * Retrieves a version object for this entity and a version number
3890: *
3891: * @param integer $versionNumber The version number to read
3892: * @param PropelPDO $con the connection to use
3893: *
3894: * @return ContentVersion A version object
3895: */
3896: public function getOneVersion($versionNumber, $con = null)
3897: {
3898: return ContentVersionQuery::create()
3899: ->filterByContent($this)
3900: ->filterByVersion($versionNumber)
3901: ->findOne($con);
3902: }
3903:
3904: /**
3905: * Gets all the versions of this object, in incremental order
3906: *
3907: * @param PropelPDO $con the connection to use
3908: *
3909: * @return PropelObjectCollection A list of ContentVersion objects
3910: */
3911: public function getAllVersions($con = null)
3912: {
3913: $criteria = new Criteria();
3914: $criteria->addAscendingOrderByColumn(ContentVersionPeer::VERSION);
3915:
3916: return $this->getContentVersions($criteria, $con);
3917: }
3918:
3919: /**
3920: * Compares the current object with another of its version.
3921: * <code>
3922: * print_r($book->compareVersion(1));
3923: * => array(
3924: * '1' => array('Title' => 'Book title at version 1'),
3925: * '2' => array('Title' => 'Book title at version 2')
3926: * );
3927: * </code>
3928: *
3929: * @param integer $versionNumber
3930: * @param string $keys Main key used for the result diff (versions|columns)
3931: * @param PropelPDO $con the connection to use
3932: * @param array $ignoredColumns The columns to exclude from the diff.
3933: *
3934: * @return array A list of differences
3935: */
3936: public function compareVersion($versionNumber, $keys = 'columns', $con = null, $ignoredColumns = array())
3937: {
3938: $fromVersion = $this->toArray();
3939: $toVersion = $this->getOneVersion($versionNumber, $con)->toArray();
3940:
3941: return $this->computeDiff($fromVersion, $toVersion, $keys, $ignoredColumns);
3942: }
3943:
3944: /**
3945: * Compares two versions of the current object.
3946: * <code>
3947: * print_r($book->compareVersions(1, 2));
3948: * => array(
3949: * '1' => array('Title' => 'Book title at version 1'),
3950: * '2' => array('Title' => 'Book title at version 2')
3951: * );
3952: * </code>
3953: *
3954: * @param integer $fromVersionNumber
3955: * @param integer $toVersionNumber
3956: * @param string $keys Main key used for the result diff (versions|columns)
3957: * @param PropelPDO $con the connection to use
3958: * @param array $ignoredColumns The columns to exclude from the diff.
3959: *
3960: * @return array A list of differences
3961: */
3962: public function compareVersions($fromVersionNumber, $toVersionNumber, $keys = 'columns', $con = null, $ignoredColumns = array())
3963: {
3964: $fromVersion = $this->getOneVersion($fromVersionNumber, $con)->toArray();
3965: $toVersion = $this->getOneVersion($toVersionNumber, $con)->toArray();
3966:
3967: return $this->computeDiff($fromVersion, $toVersion, $keys, $ignoredColumns);
3968: }
3969:
3970: /**
3971: * Computes the diff between two versions.
3972: * <code>
3973: * print_r($this->computeDiff(1, 2));
3974: * => array(
3975: * '1' => array('Title' => 'Book title at version 1'),
3976: * '2' => array('Title' => 'Book title at version 2')
3977: * );
3978: * </code>
3979: *
3980: * @param array $fromVersion An array representing the original version.
3981: * @param array $toVersion An array representing the destination version.
3982: * @param string $keys Main key used for the result diff (versions|columns).
3983: * @param array $ignoredColumns The columns to exclude from the diff.
3984: *
3985: * @return array A list of differences
3986: */
3987: protected function computeDiff($fromVersion, $toVersion, $keys = 'columns', $ignoredColumns = array())
3988: {
3989: $fromVersionNumber = $fromVersion['Version'];
3990: $toVersionNumber = $toVersion['Version'];
3991: $ignoredColumns = array_merge(array(
3992: 'Version',
3993: 'VersionCreatedAt',
3994: 'VersionCreatedBy',
3995: ), $ignoredColumns);
3996: $diff = array();
3997: foreach ($fromVersion as $key => $value) {
3998: if (in_array($key, $ignoredColumns)) {
3999: continue;
4000: }
4001: if ($toVersion[$key] != $value) {
4002: switch ($keys) {
4003: case 'versions':
4004: $diff[$fromVersionNumber][$key] = $value;
4005: $diff[$toVersionNumber][$key] = $toVersion[$key];
4006: break;
4007: default:
4008: $diff[$key] = array(
4009: $fromVersionNumber => $value,
4010: $toVersionNumber => $toVersion[$key],
4011: );
4012: break;
4013: }
4014: }
4015: }
4016:
4017: return $diff;
4018: }
4019: /**
4020: * retrieve the last $number versions.
4021: *
4022: * @param integer $number the number of record to return.
4023: * @param ContentVersionQuery|Criteria $criteria Additional criteria to filter.
4024: * @param PropelPDO $con An optional connection to use.
4025: *
4026: * @return PropelCollection|ContentVersion[] List of ContentVersion objects
4027: */
4028: public function getLastVersions($number = 10, $criteria = null, PropelPDO $con = null)
4029: {
4030: $criteria = ContentVersionQuery::create(null, $criteria);
4031: $criteria->addDescendingOrderByColumn(ContentVersionPeer::VERSION);
4032: $criteria->limit($number);
4033:
4034: return $this->getContentVersions($criteria, $con);
4035: }
4036: }
4037: