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