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 \PropelDateTime;
14: use \PropelException;
15: use \PropelPDO;
16: use Thelia\Model\Combination;
17: use Thelia\Model\CombinationQuery;
18: use Thelia\Model\Product;
19: use Thelia\Model\ProductQuery;
20: use Thelia\Model\Stock;
21: use Thelia\Model\StockPeer;
22: use Thelia\Model\StockQuery;
23:
24: /**
25: * Base class that represents a row from the 'stock' table.
26: *
27: *
28: *
29: * @package propel.generator.Thelia.Model.om
30: */
31: abstract class BaseStock extends BaseObject implements Persistent
32: {
33: /**
34: * Peer class name
35: */
36: const PEER = 'Thelia\\Model\\StockPeer';
37:
38: /**
39: * The Peer class.
40: * Instance provides a convenient way of calling static methods on a class
41: * that calling code may not be able to identify.
42: * @var StockPeer
43: */
44: protected static $peer;
45:
46: /**
47: * The flag var to prevent infinit loop in deep copy
48: * @var boolean
49: */
50: protected $startCopy = false;
51:
52: /**
53: * The value for the id field.
54: * @var int
55: */
56: protected $id;
57:
58: /**
59: * The value for the combination_id field.
60: * @var int
61: */
62: protected $combination_id;
63:
64: /**
65: * The value for the product_id field.
66: * @var int
67: */
68: protected $product_id;
69:
70: /**
71: * The value for the increase field.
72: * @var double
73: */
74: protected $increase;
75:
76: /**
77: * The value for the value field.
78: * @var double
79: */
80: protected $value;
81:
82: /**
83: * The value for the created_at field.
84: * @var string
85: */
86: protected $created_at;
87:
88: /**
89: * The value for the updated_at field.
90: * @var string
91: */
92: protected $updated_at;
93:
94: /**
95: * @var Combination
96: */
97: protected $aCombination;
98:
99: /**
100: * @var Product
101: */
102: protected $aProduct;
103:
104: /**
105: * Flag to prevent endless save loop, if this object is referenced
106: * by another object which falls in this transaction.
107: * @var boolean
108: */
109: protected $alreadyInSave = false;
110:
111: /**
112: * Flag to prevent endless validation loop, if this object is referenced
113: * by another object which falls in this transaction.
114: * @var boolean
115: */
116: protected $alreadyInValidation = false;
117:
118: /**
119: * Get the [id] column value.
120: *
121: * @return int
122: */
123: public function getId()
124: {
125: return $this->id;
126: }
127:
128: /**
129: * Get the [combination_id] column value.
130: *
131: * @return int
132: */
133: public function getCombinationId()
134: {
135: return $this->combination_id;
136: }
137:
138: /**
139: * Get the [product_id] column value.
140: *
141: * @return int
142: */
143: public function getProductId()
144: {
145: return $this->product_id;
146: }
147:
148: /**
149: * Get the [increase] column value.
150: *
151: * @return double
152: */
153: public function getIncrease()
154: {
155: return $this->increase;
156: }
157:
158: /**
159: * Get the [value] column value.
160: *
161: * @return double
162: */
163: public function getValue()
164: {
165: return $this->value;
166: }
167:
168: /**
169: * Get the [optionally formatted] temporal [created_at] column value.
170: *
171: *
172: * @param string $format The date/time format string (either date()-style or strftime()-style).
173: * If format is null, then the raw DateTime object will be returned.
174: * @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
175: * @throws PropelException - if unable to parse/validate the date/time value.
176: */
177: public function getCreatedAt($format = 'Y-m-d H:i:s')
178: {
179: if ($this->created_at === null) {
180: return null;
181: }
182:
183: if ($this->created_at === '0000-00-00 00:00:00') {
184: // while technically this is not a default value of null,
185: // this seems to be closest in meaning.
186: return null;
187: } else {
188: try {
189: $dt = new DateTime($this->created_at);
190: } catch (Exception $x) {
191: throw new PropelException("Internally stored date/time/timestamp value could not be converted to DateTime: " . var_export($this->created_at, true), $x);
192: }
193: }
194:
195: if ($format === null) {
196: // Because propel.useDateTimeClass is true, we return a DateTime object.
197: return $dt;
198: } elseif (strpos($format, '%') !== false) {
199: return strftime($format, $dt->format('U'));
200: } else {
201: return $dt->format($format);
202: }
203: }
204:
205: /**
206: * Get the [optionally formatted] temporal [updated_at] column value.
207: *
208: *
209: * @param string $format The date/time format string (either date()-style or strftime()-style).
210: * If format is null, then the raw DateTime object will be returned.
211: * @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
212: * @throws PropelException - if unable to parse/validate the date/time value.
213: */
214: public function getUpdatedAt($format = 'Y-m-d H:i:s')
215: {
216: if ($this->updated_at === null) {
217: return null;
218: }
219:
220: if ($this->updated_at === '0000-00-00 00:00:00') {
221: // while technically this is not a default value of null,
222: // this seems to be closest in meaning.
223: return null;
224: } else {
225: try {
226: $dt = new DateTime($this->updated_at);
227: } catch (Exception $x) {
228: throw new PropelException("Internally stored date/time/timestamp value could not be converted to DateTime: " . var_export($this->updated_at, true), $x);
229: }
230: }
231:
232: if ($format === null) {
233: // Because propel.useDateTimeClass is true, we return a DateTime object.
234: return $dt;
235: } elseif (strpos($format, '%') !== false) {
236: return strftime($format, $dt->format('U'));
237: } else {
238: return $dt->format($format);
239: }
240: }
241:
242: /**
243: * Set the value of [id] column.
244: *
245: * @param int $v new value
246: * @return Stock The current object (for fluent API support)
247: */
248: public function setId($v)
249: {
250: if ($v !== null) {
251: $v = (int) $v;
252: }
253:
254: if ($this->id !== $v) {
255: $this->id = $v;
256: $this->modifiedColumns[] = StockPeer::ID;
257: }
258:
259:
260: return $this;
261: } // setId()
262:
263: /**
264: * Set the value of [combination_id] column.
265: *
266: * @param int $v new value
267: * @return Stock The current object (for fluent API support)
268: */
269: public function setCombinationId($v)
270: {
271: if ($v !== null) {
272: $v = (int) $v;
273: }
274:
275: if ($this->combination_id !== $v) {
276: $this->combination_id = $v;
277: $this->modifiedColumns[] = StockPeer::COMBINATION_ID;
278: }
279:
280: if ($this->aCombination !== null && $this->aCombination->getId() !== $v) {
281: $this->aCombination = null;
282: }
283:
284:
285: return $this;
286: } // setCombinationId()
287:
288: /**
289: * Set the value of [product_id] column.
290: *
291: * @param int $v new value
292: * @return Stock The current object (for fluent API support)
293: */
294: public function setProductId($v)
295: {
296: if ($v !== null) {
297: $v = (int) $v;
298: }
299:
300: if ($this->product_id !== $v) {
301: $this->product_id = $v;
302: $this->modifiedColumns[] = StockPeer::PRODUCT_ID;
303: }
304:
305: if ($this->aProduct !== null && $this->aProduct->getId() !== $v) {
306: $this->aProduct = null;
307: }
308:
309:
310: return $this;
311: } // setProductId()
312:
313: /**
314: * Set the value of [increase] column.
315: *
316: * @param double $v new value
317: * @return Stock The current object (for fluent API support)
318: */
319: public function setIncrease($v)
320: {
321: if ($v !== null) {
322: $v = (double) $v;
323: }
324:
325: if ($this->increase !== $v) {
326: $this->increase = $v;
327: $this->modifiedColumns[] = StockPeer::INCREASE;
328: }
329:
330:
331: return $this;
332: } // setIncrease()
333:
334: /**
335: * Set the value of [value] column.
336: *
337: * @param double $v new value
338: * @return Stock The current object (for fluent API support)
339: */
340: public function setValue($v)
341: {
342: if ($v !== null) {
343: $v = (double) $v;
344: }
345:
346: if ($this->value !== $v) {
347: $this->value = $v;
348: $this->modifiedColumns[] = StockPeer::VALUE;
349: }
350:
351:
352: return $this;
353: } // setValue()
354:
355: /**
356: * Sets the value of [created_at] column to a normalized version of the date/time value specified.
357: *
358: * @param mixed $v string, integer (timestamp), or DateTime value.
359: * Empty strings are treated as null.
360: * @return Stock The current object (for fluent API support)
361: */
362: public function setCreatedAt($v)
363: {
364: $dt = PropelDateTime::newInstance($v, null, 'DateTime');
365: if ($this->created_at !== null || $dt !== null) {
366: $currentDateAsString = ($this->created_at !== null && $tmpDt = new DateTime($this->created_at)) ? $tmpDt->format('Y-m-d H:i:s') : null;
367: $newDateAsString = $dt ? $dt->format('Y-m-d H:i:s') : null;
368: if ($currentDateAsString !== $newDateAsString) {
369: $this->created_at = $newDateAsString;
370: $this->modifiedColumns[] = StockPeer::CREATED_AT;
371: }
372: } // if either are not null
373:
374:
375: return $this;
376: } // setCreatedAt()
377:
378: /**
379: * Sets the value of [updated_at] column to a normalized version of the date/time value specified.
380: *
381: * @param mixed $v string, integer (timestamp), or DateTime value.
382: * Empty strings are treated as null.
383: * @return Stock The current object (for fluent API support)
384: */
385: public function setUpdatedAt($v)
386: {
387: $dt = PropelDateTime::newInstance($v, null, 'DateTime');
388: if ($this->updated_at !== null || $dt !== null) {
389: $currentDateAsString = ($this->updated_at !== null && $tmpDt = new DateTime($this->updated_at)) ? $tmpDt->format('Y-m-d H:i:s') : null;
390: $newDateAsString = $dt ? $dt->format('Y-m-d H:i:s') : null;
391: if ($currentDateAsString !== $newDateAsString) {
392: $this->updated_at = $newDateAsString;
393: $this->modifiedColumns[] = StockPeer::UPDATED_AT;
394: }
395: } // if either are not null
396:
397:
398: return $this;
399: } // setUpdatedAt()
400:
401: /**
402: * Indicates whether the columns in this object are only set to default values.
403: *
404: * This method can be used in conjunction with isModified() to indicate whether an object is both
405: * modified _and_ has some values set which are non-default.
406: *
407: * @return boolean Whether the columns in this object are only been set with default values.
408: */
409: public function hasOnlyDefaultValues()
410: {
411: // otherwise, everything was equal, so return true
412: return true;
413: } // hasOnlyDefaultValues()
414:
415: /**
416: * Hydrates (populates) the object variables with values from the database resultset.
417: *
418: * An offset (0-based "start column") is specified so that objects can be hydrated
419: * with a subset of the columns in the resultset rows. This is needed, for example,
420: * for results of JOIN queries where the resultset row includes columns from two or
421: * more tables.
422: *
423: * @param array $row The row returned by PDOStatement->fetch(PDO::FETCH_NUM)
424: * @param int $startcol 0-based offset column which indicates which restultset column to start with.
425: * @param boolean $rehydrate Whether this object is being re-hydrated from the database.
426: * @return int next starting column
427: * @throws PropelException - Any caught Exception will be rewrapped as a PropelException.
428: */
429: public function hydrate($row, $startcol = 0, $rehydrate = false)
430: {
431: try {
432:
433: $this->id = ($row[$startcol + 0] !== null) ? (int) $row[$startcol + 0] : null;
434: $this->combination_id = ($row[$startcol + 1] !== null) ? (int) $row[$startcol + 1] : null;
435: $this->product_id = ($row[$startcol + 2] !== null) ? (int) $row[$startcol + 2] : null;
436: $this->increase = ($row[$startcol + 3] !== null) ? (double) $row[$startcol + 3] : null;
437: $this->value = ($row[$startcol + 4] !== null) ? (double) $row[$startcol + 4] : null;
438: $this->created_at = ($row[$startcol + 5] !== null) ? (string) $row[$startcol + 5] : null;
439: $this->updated_at = ($row[$startcol + 6] !== null) ? (string) $row[$startcol + 6] : null;
440: $this->resetModified();
441:
442: $this->setNew(false);
443:
444: if ($rehydrate) {
445: $this->ensureConsistency();
446: }
447:
448: return $startcol + 7; // 7 = StockPeer::NUM_HYDRATE_COLUMNS.
449:
450: } catch (Exception $e) {
451: throw new PropelException("Error populating Stock object", $e);
452: }
453: }
454:
455: /**
456: * Checks and repairs the internal consistency of the object.
457: *
458: * This method is executed after an already-instantiated object is re-hydrated
459: * from the database. It exists to check any foreign keys to make sure that
460: * the objects related to the current object are correct based on foreign key.
461: *
462: * You can override this method in the stub class, but you should always invoke
463: * the base method from the overridden method (i.e. parent::ensureConsistency()),
464: * in case your model changes.
465: *
466: * @throws PropelException
467: */
468: public function ensureConsistency()
469: {
470:
471: if ($this->aCombination !== null && $this->combination_id !== $this->aCombination->getId()) {
472: $this->aCombination = null;
473: }
474: if ($this->aProduct !== null && $this->product_id !== $this->aProduct->getId()) {
475: $this->aProduct = null;
476: }
477: } // ensureConsistency
478:
479: /**
480: * Reloads this object from datastore based on primary key and (optionally) resets all associated objects.
481: *
482: * This will only work if the object has been saved and has a valid primary key set.
483: *
484: * @param boolean $deep (optional) Whether to also de-associated any related objects.
485: * @param PropelPDO $con (optional) The PropelPDO connection to use.
486: * @return void
487: * @throws PropelException - if this object is deleted, unsaved or doesn't have pk match in db
488: */
489: public function reload($deep = false, PropelPDO $con = null)
490: {
491: if ($this->isDeleted()) {
492: throw new PropelException("Cannot reload a deleted object.");
493: }
494:
495: if ($this->isNew()) {
496: throw new PropelException("Cannot reload an unsaved object.");
497: }
498:
499: if ($con === null) {
500: $con = Propel::getConnection(StockPeer::DATABASE_NAME, Propel::CONNECTION_READ);
501: }
502:
503: // We don't need to alter the object instance pool; we're just modifying this instance
504: // already in the pool.
505:
506: $stmt = StockPeer::doSelectStmt($this->buildPkeyCriteria(), $con);
507: $row = $stmt->fetch(PDO::FETCH_NUM);
508: $stmt->closeCursor();
509: if (!$row) {
510: throw new PropelException('Cannot find matching row in the database to reload object values.');
511: }
512: $this->hydrate($row, 0, true); // rehydrate
513:
514: if ($deep) { // also de-associate any related objects?
515:
516: $this->aCombination = null;
517: $this->aProduct = null;
518: } // if (deep)
519: }
520:
521: /**
522: * Removes this object from datastore and sets delete attribute.
523: *
524: * @param PropelPDO $con
525: * @return void
526: * @throws PropelException
527: * @throws Exception
528: * @see BaseObject::setDeleted()
529: * @see BaseObject::isDeleted()
530: */
531: public function delete(PropelPDO $con = null)
532: {
533: if ($this->isDeleted()) {
534: throw new PropelException("This object has already been deleted.");
535: }
536:
537: if ($con === null) {
538: $con = Propel::getConnection(StockPeer::DATABASE_NAME, Propel::CONNECTION_WRITE);
539: }
540:
541: $con->beginTransaction();
542: try {
543: $deleteQuery = StockQuery::create()
544: ->filterByPrimaryKey($this->getPrimaryKey());
545: $ret = $this->preDelete($con);
546: if ($ret) {
547: $deleteQuery->delete($con);
548: $this->postDelete($con);
549: $con->commit();
550: $this->setDeleted(true);
551: } else {
552: $con->commit();
553: }
554: } catch (Exception $e) {
555: $con->rollBack();
556: throw $e;
557: }
558: }
559:
560: /**
561: * Persists this object to the database.
562: *
563: * If the object is new, it inserts it; otherwise an update is performed.
564: * All modified related objects will also be persisted in the doSave()
565: * method. This method wraps all precipitate database operations in a
566: * single transaction.
567: *
568: * @param PropelPDO $con
569: * @return int The number of rows affected by this insert/update and any referring fk objects' save() operations.
570: * @throws PropelException
571: * @throws Exception
572: * @see doSave()
573: */
574: public function save(PropelPDO $con = null)
575: {
576: if ($this->isDeleted()) {
577: throw new PropelException("You cannot save an object that has been deleted.");
578: }
579:
580: if ($con === null) {
581: $con = Propel::getConnection(StockPeer::DATABASE_NAME, Propel::CONNECTION_WRITE);
582: }
583:
584: $con->beginTransaction();
585: $isInsert = $this->isNew();
586: try {
587: $ret = $this->preSave($con);
588: if ($isInsert) {
589: $ret = $ret && $this->preInsert($con);
590: // timestampable behavior
591: if (!$this->isColumnModified(StockPeer::CREATED_AT)) {
592: $this->setCreatedAt(time());
593: }
594: if (!$this->isColumnModified(StockPeer::UPDATED_AT)) {
595: $this->setUpdatedAt(time());
596: }
597: } else {
598: $ret = $ret && $this->preUpdate($con);
599: // timestampable behavior
600: if ($this->isModified() && !$this->isColumnModified(StockPeer::UPDATED_AT)) {
601: $this->setUpdatedAt(time());
602: }
603: }
604: if ($ret) {
605: $affectedRows = $this->doSave($con);
606: if ($isInsert) {
607: $this->postInsert($con);
608: } else {
609: $this->postUpdate($con);
610: }
611: $this->postSave($con);
612: StockPeer::addInstanceToPool($this);
613: } else {
614: $affectedRows = 0;
615: }
616: $con->commit();
617:
618: return $affectedRows;
619: } catch (Exception $e) {
620: $con->rollBack();
621: throw $e;
622: }
623: }
624:
625: /**
626: * Performs the work of inserting or updating the row in the database.
627: *
628: * If the object is new, it inserts it; otherwise an update is performed.
629: * All related objects are also updated in this method.
630: *
631: * @param PropelPDO $con
632: * @return int The number of rows affected by this insert/update and any referring fk objects' save() operations.
633: * @throws PropelException
634: * @see save()
635: */
636: protected function doSave(PropelPDO $con)
637: {
638: $affectedRows = 0; // initialize var to track total num of affected rows
639: if (!$this->alreadyInSave) {
640: $this->alreadyInSave = true;
641:
642: // We call the save method on the following object(s) if they
643: // were passed to this object by their coresponding set
644: // method. This object relates to these object(s) by a
645: // foreign key reference.
646:
647: if ($this->aCombination !== null) {
648: if ($this->aCombination->isModified() || $this->aCombination->isNew()) {
649: $affectedRows += $this->aCombination->save($con);
650: }
651: $this->setCombination($this->aCombination);
652: }
653:
654: if ($this->aProduct !== null) {
655: if ($this->aProduct->isModified() || $this->aProduct->isNew()) {
656: $affectedRows += $this->aProduct->save($con);
657: }
658: $this->setProduct($this->aProduct);
659: }
660:
661: if ($this->isNew() || $this->isModified()) {
662: // persist changes
663: if ($this->isNew()) {
664: $this->doInsert($con);
665: } else {
666: $this->doUpdate($con);
667: }
668: $affectedRows += 1;
669: $this->resetModified();
670: }
671:
672: $this->alreadyInSave = false;
673:
674: }
675:
676: return $affectedRows;
677: } // doSave()
678:
679: /**
680: * Insert the row in the database.
681: *
682: * @param PropelPDO $con
683: *
684: * @throws PropelException
685: * @see doSave()
686: */
687: protected function doInsert(PropelPDO $con)
688: {
689: $modifiedColumns = array();
690: $index = 0;
691:
692: $this->modifiedColumns[] = StockPeer::ID;
693: if (null !== $this->id) {
694: throw new PropelException('Cannot insert a value for auto-increment primary key (' . StockPeer::ID . ')');
695: }
696:
697: // check the columns in natural order for more readable SQL queries
698: if ($this->isColumnModified(StockPeer::ID)) {
699: $modifiedColumns[':p' . $index++] = '`ID`';
700: }
701: if ($this->isColumnModified(StockPeer::COMBINATION_ID)) {
702: $modifiedColumns[':p' . $index++] = '`COMBINATION_ID`';
703: }
704: if ($this->isColumnModified(StockPeer::PRODUCT_ID)) {
705: $modifiedColumns[':p' . $index++] = '`PRODUCT_ID`';
706: }
707: if ($this->isColumnModified(StockPeer::INCREASE)) {
708: $modifiedColumns[':p' . $index++] = '`INCREASE`';
709: }
710: if ($this->isColumnModified(StockPeer::VALUE)) {
711: $modifiedColumns[':p' . $index++] = '`VALUE`';
712: }
713: if ($this->isColumnModified(StockPeer::CREATED_AT)) {
714: $modifiedColumns[':p' . $index++] = '`CREATED_AT`';
715: }
716: if ($this->isColumnModified(StockPeer::UPDATED_AT)) {
717: $modifiedColumns[':p' . $index++] = '`UPDATED_AT`';
718: }
719:
720: $sql = sprintf(
721: 'INSERT INTO `stock` (%s) VALUES (%s)',
722: implode(', ', $modifiedColumns),
723: implode(', ', array_keys($modifiedColumns))
724: );
725:
726: try {
727: $stmt = $con->prepare($sql);
728: foreach ($modifiedColumns as $identifier => $columnName) {
729: switch ($columnName) {
730: case '`ID`':
731: $stmt->bindValue($identifier, $this->id, PDO::PARAM_INT);
732: break;
733: case '`COMBINATION_ID`':
734: $stmt->bindValue($identifier, $this->combination_id, PDO::PARAM_INT);
735: break;
736: case '`PRODUCT_ID`':
737: $stmt->bindValue($identifier, $this->product_id, PDO::PARAM_INT);
738: break;
739: case '`INCREASE`':
740: $stmt->bindValue($identifier, $this->increase, PDO::PARAM_STR);
741: break;
742: case '`VALUE`':
743: $stmt->bindValue($identifier, $this->value, PDO::PARAM_STR);
744: break;
745: case '`CREATED_AT`':
746: $stmt->bindValue($identifier, $this->created_at, PDO::PARAM_STR);
747: break;
748: case '`UPDATED_AT`':
749: $stmt->bindValue($identifier, $this->updated_at, PDO::PARAM_STR);
750: break;
751: }
752: }
753: $stmt->execute();
754: } catch (Exception $e) {
755: Propel::log($e->getMessage(), Propel::LOG_ERR);
756: throw new PropelException(sprintf('Unable to execute INSERT statement [%s]', $sql), $e);
757: }
758:
759: try {
760: $pk = $con->lastInsertId();
761: } catch (Exception $e) {
762: throw new PropelException('Unable to get autoincrement id.', $e);
763: }
764: $this->setId($pk);
765:
766: $this->setNew(false);
767: }
768:
769: /**
770: * Update the row in the database.
771: *
772: * @param PropelPDO $con
773: *
774: * @see doSave()
775: */
776: protected function doUpdate(PropelPDO $con)
777: {
778: $selectCriteria = $this->buildPkeyCriteria();
779: $valuesCriteria = $this->buildCriteria();
780: BasePeer::doUpdate($selectCriteria, $valuesCriteria, $con);
781: }
782:
783: /**
784: * Array of ValidationFailed objects.
785: * @var array ValidationFailed[]
786: */
787: protected $validationFailures = array();
788:
789: /**
790: * Gets any ValidationFailed objects that resulted from last call to validate().
791: *
792: *
793: * @return array ValidationFailed[]
794: * @see validate()
795: */
796: public function getValidationFailures()
797: {
798: return $this->validationFailures;
799: }
800:
801: /**
802: * Validates the objects modified field values and all objects related to this table.
803: *
804: * If $columns is either a column name or an array of column names
805: * only those columns are validated.
806: *
807: * @param mixed $columns Column name or an array of column names.
808: * @return boolean Whether all columns pass validation.
809: * @see doValidate()
810: * @see getValidationFailures()
811: */
812: public function validate($columns = null)
813: {
814: $res = $this->doValidate($columns);
815: if ($res === true) {
816: $this->validationFailures = array();
817:
818: return true;
819: } else {
820: $this->validationFailures = $res;
821:
822: return false;
823: }
824: }
825:
826: /**
827: * This function performs the validation work for complex object models.
828: *
829: * In addition to checking the current object, all related objects will
830: * also be validated. If all pass then <code>true</code> is returned; otherwise
831: * an aggreagated array of ValidationFailed objects will be returned.
832: *
833: * @param array $columns Array of column names to validate.
834: * @return mixed <code>true</code> if all validations pass; array of <code>ValidationFailed</code> objets otherwise.
835: */
836: protected function doValidate($columns = null)
837: {
838: if (!$this->alreadyInValidation) {
839: $this->alreadyInValidation = true;
840: $retval = null;
841:
842: $failureMap = array();
843:
844:
845: // We call the validate method on the following object(s) if they
846: // were passed to this object by their coresponding set
847: // method. This object relates to these object(s) by a
848: // foreign key reference.
849:
850: if ($this->aCombination !== null) {
851: if (!$this->aCombination->validate($columns)) {
852: $failureMap = array_merge($failureMap, $this->aCombination->getValidationFailures());
853: }
854: }
855:
856: if ($this->aProduct !== null) {
857: if (!$this->aProduct->validate($columns)) {
858: $failureMap = array_merge($failureMap, $this->aProduct->getValidationFailures());
859: }
860: }
861:
862:
863: if (($retval = StockPeer::doValidate($this, $columns)) !== true) {
864: $failureMap = array_merge($failureMap, $retval);
865: }
866:
867:
868:
869: $this->alreadyInValidation = false;
870: }
871:
872: return (!empty($failureMap) ? $failureMap : true);
873: }
874:
875: /**
876: * Retrieves a field from the object by name passed in as a string.
877: *
878: * @param string $name name
879: * @param string $type The type of fieldname the $name is of:
880: * one of the class type constants BasePeer::TYPE_PHPNAME, BasePeer::TYPE_STUDLYPHPNAME
881: * BasePeer::TYPE_COLNAME, BasePeer::TYPE_FIELDNAME, BasePeer::TYPE_NUM.
882: * Defaults to BasePeer::TYPE_PHPNAME
883: * @return mixed Value of field.
884: */
885: public function getByName($name, $type = BasePeer::TYPE_PHPNAME)
886: {
887: $pos = StockPeer::translateFieldName($name, $type, BasePeer::TYPE_NUM);
888: $field = $this->getByPosition($pos);
889:
890: return $field;
891: }
892:
893: /**
894: * Retrieves a field from the object by Position as specified in the xml schema.
895: * Zero-based.
896: *
897: * @param int $pos position in xml schema
898: * @return mixed Value of field at $pos
899: */
900: public function getByPosition($pos)
901: {
902: switch ($pos) {
903: case 0:
904: return $this->getId();
905: break;
906: case 1:
907: return $this->getCombinationId();
908: break;
909: case 2:
910: return $this->getProductId();
911: break;
912: case 3:
913: return $this->getIncrease();
914: break;
915: case 4:
916: return $this->getValue();
917: break;
918: case 5:
919: return $this->getCreatedAt();
920: break;
921: case 6:
922: return $this->getUpdatedAt();
923: break;
924: default:
925: return null;
926: break;
927: } // switch()
928: }
929:
930: /**
931: * Exports the object as an array.
932: *
933: * You can specify the key type of the array by passing one of the class
934: * type constants.
935: *
936: * @param string $keyType (optional) One of the class type constants BasePeer::TYPE_PHPNAME, BasePeer::TYPE_STUDLYPHPNAME,
937: * BasePeer::TYPE_COLNAME, BasePeer::TYPE_FIELDNAME, BasePeer::TYPE_NUM.
938: * Defaults to BasePeer::TYPE_PHPNAME.
939: * @param boolean $includeLazyLoadColumns (optional) Whether to include lazy loaded columns. Defaults to true.
940: * @param array $alreadyDumpedObjects List of objects to skip to avoid recursion
941: * @param boolean $includeForeignObjects (optional) Whether to include hydrated related objects. Default to FALSE.
942: *
943: * @return array an associative array containing the field names (as keys) and field values
944: */
945: public function toArray($keyType = BasePeer::TYPE_PHPNAME, $includeLazyLoadColumns = true, $alreadyDumpedObjects = array(), $includeForeignObjects = false)
946: {
947: if (isset($alreadyDumpedObjects['Stock'][$this->getPrimaryKey()])) {
948: return '*RECURSION*';
949: }
950: $alreadyDumpedObjects['Stock'][$this->getPrimaryKey()] = true;
951: $keys = StockPeer::getFieldNames($keyType);
952: $result = array(
953: $keys[0] => $this->getId(),
954: $keys[1] => $this->getCombinationId(),
955: $keys[2] => $this->getProductId(),
956: $keys[3] => $this->getIncrease(),
957: $keys[4] => $this->getValue(),
958: $keys[5] => $this->getCreatedAt(),
959: $keys[6] => $this->getUpdatedAt(),
960: );
961: if ($includeForeignObjects) {
962: if (null !== $this->aCombination) {
963: $result['Combination'] = $this->aCombination->toArray($keyType, $includeLazyLoadColumns, $alreadyDumpedObjects, true);
964: }
965: if (null !== $this->aProduct) {
966: $result['Product'] = $this->aProduct->toArray($keyType, $includeLazyLoadColumns, $alreadyDumpedObjects, true);
967: }
968: }
969:
970: return $result;
971: }
972:
973: /**
974: * Sets a field from the object by name passed in as a string.
975: *
976: * @param string $name peer name
977: * @param mixed $value field value
978: * @param string $type The type of fieldname the $name is of:
979: * one of the class type constants BasePeer::TYPE_PHPNAME, BasePeer::TYPE_STUDLYPHPNAME
980: * BasePeer::TYPE_COLNAME, BasePeer::TYPE_FIELDNAME, BasePeer::TYPE_NUM.
981: * Defaults to BasePeer::TYPE_PHPNAME
982: * @return void
983: */
984: public function setByName($name, $value, $type = BasePeer::TYPE_PHPNAME)
985: {
986: $pos = StockPeer::translateFieldName($name, $type, BasePeer::TYPE_NUM);
987:
988: $this->setByPosition($pos, $value);
989: }
990:
991: /**
992: * Sets a field from the object by Position as specified in the xml schema.
993: * Zero-based.
994: *
995: * @param int $pos position in xml schema
996: * @param mixed $value field value
997: * @return void
998: */
999: public function setByPosition($pos, $value)
1000: {
1001: switch ($pos) {
1002: case 0:
1003: $this->setId($value);
1004: break;
1005: case 1:
1006: $this->setCombinationId($value);
1007: break;
1008: case 2:
1009: $this->setProductId($value);
1010: break;
1011: case 3:
1012: $this->setIncrease($value);
1013: break;
1014: case 4:
1015: $this->setValue($value);
1016: break;
1017: case 5:
1018: $this->setCreatedAt($value);
1019: break;
1020: case 6:
1021: $this->setUpdatedAt($value);
1022: break;
1023: } // switch()
1024: }
1025:
1026: /**
1027: * Populates the object using an array.
1028: *
1029: * This is particularly useful when populating an object from one of the
1030: * request arrays (e.g. $_POST). This method goes through the column
1031: * names, checking to see whether a matching key exists in populated
1032: * array. If so the setByName() method is called for that column.
1033: *
1034: * You can specify the key type of the array by additionally passing one
1035: * of the class type constants BasePeer::TYPE_PHPNAME, BasePeer::TYPE_STUDLYPHPNAME,
1036: * BasePeer::TYPE_COLNAME, BasePeer::TYPE_FIELDNAME, BasePeer::TYPE_NUM.
1037: * The default key type is the column's BasePeer::TYPE_PHPNAME
1038: *
1039: * @param array $arr An array to populate the object from.
1040: * @param string $keyType The type of keys the array uses.
1041: * @return void
1042: */
1043: public function fromArray($arr, $keyType = BasePeer::TYPE_PHPNAME)
1044: {
1045: $keys = StockPeer::getFieldNames($keyType);
1046:
1047: if (array_key_exists($keys[0], $arr)) $this->setId($arr[$keys[0]]);
1048: if (array_key_exists($keys[1], $arr)) $this->setCombinationId($arr[$keys[1]]);
1049: if (array_key_exists($keys[2], $arr)) $this->setProductId($arr[$keys[2]]);
1050: if (array_key_exists($keys[3], $arr)) $this->setIncrease($arr[$keys[3]]);
1051: if (array_key_exists($keys[4], $arr)) $this->setValue($arr[$keys[4]]);
1052: if (array_key_exists($keys[5], $arr)) $this->setCreatedAt($arr[$keys[5]]);
1053: if (array_key_exists($keys[6], $arr)) $this->setUpdatedAt($arr[$keys[6]]);
1054: }
1055:
1056: /**
1057: * Build a Criteria object containing the values of all modified columns in this object.
1058: *
1059: * @return Criteria The Criteria object containing all modified values.
1060: */
1061: public function buildCriteria()
1062: {
1063: $criteria = new Criteria(StockPeer::DATABASE_NAME);
1064:
1065: if ($this->isColumnModified(StockPeer::ID)) $criteria->add(StockPeer::ID, $this->id);
1066: if ($this->isColumnModified(StockPeer::COMBINATION_ID)) $criteria->add(StockPeer::COMBINATION_ID, $this->combination_id);
1067: if ($this->isColumnModified(StockPeer::PRODUCT_ID)) $criteria->add(StockPeer::PRODUCT_ID, $this->product_id);
1068: if ($this->isColumnModified(StockPeer::INCREASE)) $criteria->add(StockPeer::INCREASE, $this->increase);
1069: if ($this->isColumnModified(StockPeer::VALUE)) $criteria->add(StockPeer::VALUE, $this->value);
1070: if ($this->isColumnModified(StockPeer::CREATED_AT)) $criteria->add(StockPeer::CREATED_AT, $this->created_at);
1071: if ($this->isColumnModified(StockPeer::UPDATED_AT)) $criteria->add(StockPeer::UPDATED_AT, $this->updated_at);
1072:
1073: return $criteria;
1074: }
1075:
1076: /**
1077: * Builds a Criteria object containing the primary key for this object.
1078: *
1079: * Unlike buildCriteria() this method includes the primary key values regardless
1080: * of whether or not they have been modified.
1081: *
1082: * @return Criteria The Criteria object containing value(s) for primary key(s).
1083: */
1084: public function buildPkeyCriteria()
1085: {
1086: $criteria = new Criteria(StockPeer::DATABASE_NAME);
1087: $criteria->add(StockPeer::ID, $this->id);
1088:
1089: return $criteria;
1090: }
1091:
1092: /**
1093: * Returns the primary key for this object (row).
1094: * @return int
1095: */
1096: public function getPrimaryKey()
1097: {
1098: return $this->getId();
1099: }
1100:
1101: /**
1102: * Generic method to set the primary key (id column).
1103: *
1104: * @param int $key Primary key.
1105: * @return void
1106: */
1107: public function setPrimaryKey($key)
1108: {
1109: $this->setId($key);
1110: }
1111:
1112: /**
1113: * Returns true if the primary key for this object is null.
1114: * @return boolean
1115: */
1116: public function isPrimaryKeyNull()
1117: {
1118:
1119: return null === $this->getId();
1120: }
1121:
1122: /**
1123: * Sets contents of passed object to values from current object.
1124: *
1125: * If desired, this method can also make copies of all associated (fkey referrers)
1126: * objects.
1127: *
1128: * @param object $copyObj An object of Stock (or compatible) type.
1129: * @param boolean $deepCopy Whether to also copy all rows that refer (by fkey) to the current row.
1130: * @param boolean $makeNew Whether to reset autoincrement PKs and make the object new.
1131: * @throws PropelException
1132: */
1133: public function copyInto($copyObj, $deepCopy = false, $makeNew = true)
1134: {
1135: $copyObj->setCombinationId($this->getCombinationId());
1136: $copyObj->setProductId($this->getProductId());
1137: $copyObj->setIncrease($this->getIncrease());
1138: $copyObj->setValue($this->getValue());
1139: $copyObj->setCreatedAt($this->getCreatedAt());
1140: $copyObj->setUpdatedAt($this->getUpdatedAt());
1141:
1142: if ($deepCopy && !$this->startCopy) {
1143: // important: temporarily setNew(false) because this affects the behavior of
1144: // the getter/setter methods for fkey referrer objects.
1145: $copyObj->setNew(false);
1146: // store object hash to prevent cycle
1147: $this->startCopy = true;
1148:
1149: //unflag object copy
1150: $this->startCopy = false;
1151: } // if ($deepCopy)
1152:
1153: if ($makeNew) {
1154: $copyObj->setNew(true);
1155: $copyObj->setId(NULL); // this is a auto-increment column, so set to default value
1156: }
1157: }
1158:
1159: /**
1160: * Makes a copy of this object that will be inserted as a new row in table when saved.
1161: * It creates a new object filling in the simple attributes, but skipping any primary
1162: * keys that are defined for the table.
1163: *
1164: * If desired, this method can also make copies of all associated (fkey referrers)
1165: * objects.
1166: *
1167: * @param boolean $deepCopy Whether to also copy all rows that refer (by fkey) to the current row.
1168: * @return Stock Clone of current object.
1169: * @throws PropelException
1170: */
1171: public function copy($deepCopy = false)
1172: {
1173: // we use get_class(), because this might be a subclass
1174: $clazz = get_class($this);
1175: $copyObj = new $clazz();
1176: $this->copyInto($copyObj, $deepCopy);
1177:
1178: return $copyObj;
1179: }
1180:
1181: /**
1182: * Returns a peer instance associated with this om.
1183: *
1184: * Since Peer classes are not to have any instance attributes, this method returns the
1185: * same instance for all member of this class. The method could therefore
1186: * be static, but this would prevent one from overriding the behavior.
1187: *
1188: * @return StockPeer
1189: */
1190: public function getPeer()
1191: {
1192: if (self::$peer === null) {
1193: self::$peer = new StockPeer();
1194: }
1195:
1196: return self::$peer;
1197: }
1198:
1199: /**
1200: * Declares an association between this object and a Combination object.
1201: *
1202: * @param Combination $v
1203: * @return Stock The current object (for fluent API support)
1204: * @throws PropelException
1205: */
1206: public function setCombination(Combination $v = null)
1207: {
1208: if ($v === null) {
1209: $this->setCombinationId(NULL);
1210: } else {
1211: $this->setCombinationId($v->getId());
1212: }
1213:
1214: $this->aCombination = $v;
1215:
1216: // Add binding for other direction of this n:n relationship.
1217: // If this object has already been added to the Combination object, it will not be re-added.
1218: if ($v !== null) {
1219: $v->addStock($this);
1220: }
1221:
1222:
1223: return $this;
1224: }
1225:
1226:
1227: /**
1228: * Get the associated Combination object
1229: *
1230: * @param PropelPDO $con Optional Connection object.
1231: * @return Combination The associated Combination object.
1232: * @throws PropelException
1233: */
1234: public function getCombination(PropelPDO $con = null)
1235: {
1236: if ($this->aCombination === null && ($this->combination_id !== null)) {
1237: $this->aCombination = CombinationQuery::create()->findPk($this->combination_id, $con);
1238: /* The following can be used additionally to
1239: guarantee the related object contains a reference
1240: to this object. This level of coupling may, however, be
1241: undesirable since it could result in an only partially populated collection
1242: in the referenced object.
1243: $this->aCombination->addStocks($this);
1244: */
1245: }
1246:
1247: return $this->aCombination;
1248: }
1249:
1250: /**
1251: * Declares an association between this object and a Product object.
1252: *
1253: * @param Product $v
1254: * @return Stock The current object (for fluent API support)
1255: * @throws PropelException
1256: */
1257: public function setProduct(Product $v = null)
1258: {
1259: if ($v === null) {
1260: $this->setProductId(NULL);
1261: } else {
1262: $this->setProductId($v->getId());
1263: }
1264:
1265: $this->aProduct = $v;
1266:
1267: // Add binding for other direction of this n:n relationship.
1268: // If this object has already been added to the Product object, it will not be re-added.
1269: if ($v !== null) {
1270: $v->addStock($this);
1271: }
1272:
1273:
1274: return $this;
1275: }
1276:
1277:
1278: /**
1279: * Get the associated Product object
1280: *
1281: * @param PropelPDO $con Optional Connection object.
1282: * @return Product The associated Product object.
1283: * @throws PropelException
1284: */
1285: public function getProduct(PropelPDO $con = null)
1286: {
1287: if ($this->aProduct === null && ($this->product_id !== null)) {
1288: $this->aProduct = ProductQuery::create()->findPk($this->product_id, $con);
1289: /* The following can be used additionally to
1290: guarantee the related object contains a reference
1291: to this object. This level of coupling may, however, be
1292: undesirable since it could result in an only partially populated collection
1293: in the referenced object.
1294: $this->aProduct->addStocks($this);
1295: */
1296: }
1297:
1298: return $this->aProduct;
1299: }
1300:
1301: /**
1302: * Clears the current object and sets all attributes to their default values
1303: */
1304: public function clear()
1305: {
1306: $this->id = null;
1307: $this->combination_id = null;
1308: $this->product_id = null;
1309: $this->increase = null;
1310: $this->value = null;
1311: $this->created_at = null;
1312: $this->updated_at = null;
1313: $this->alreadyInSave = false;
1314: $this->alreadyInValidation = false;
1315: $this->clearAllReferences();
1316: $this->resetModified();
1317: $this->setNew(true);
1318: $this->setDeleted(false);
1319: }
1320:
1321: /**
1322: * Resets all references to other model objects or collections of model objects.
1323: *
1324: * This method is a user-space workaround for PHP's inability to garbage collect
1325: * objects with circular references (even in PHP 5.3). This is currently necessary
1326: * when using Propel in certain daemon or large-volumne/high-memory operations.
1327: *
1328: * @param boolean $deep Whether to also clear the references on all referrer objects.
1329: */
1330: public function clearAllReferences($deep = false)
1331: {
1332: if ($deep) {
1333: } // if ($deep)
1334:
1335: $this->aCombination = null;
1336: $this->aProduct = null;
1337: }
1338:
1339: /**
1340: * return the string representation of this object
1341: *
1342: * @return string
1343: */
1344: public function __toString()
1345: {
1346: return (string) $this->exportTo(StockPeer::DEFAULT_STRING_FORMAT);
1347: }
1348:
1349: /**
1350: * return true is the object is in saving state
1351: *
1352: * @return boolean
1353: */
1354: public function isAlreadyInSave()
1355: {
1356: return $this->alreadyInSave;
1357: }
1358:
1359: // timestampable behavior
1360:
1361: /**
1362: * Mark the current object so that the update date doesn't get updated during next save
1363: *
1364: * @return Stock The current object (for fluent API support)
1365: */
1366: public function keepUpdateDateUnchanged()
1367: {
1368: $this->modifiedColumns[] = StockPeer::UPDATED_AT;
1369:
1370: return $this;
1371: }
1372:
1373: }
1374: