Overview

---

   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\Address;
  19: use Thelia\Model\AddressQuery;
  20: use Thelia\Model\Customer;
  21: use Thelia\Model\CustomerPeer;
  22: use Thelia\Model\CustomerQuery;
  23: use Thelia\Model\CustomerTitle;
  24: use Thelia\Model\CustomerTitleQuery;
  25: use Thelia\Model\Order;
  26: use Thelia\Model\OrderQuery;
  27: 
  28: /**
  29:  * Base class that represents a row from the 'customer' table.
  30:  *
  31:  *
  32:  *
  33:  * @package    propel.generator.Thelia.Model.om
  34:  */
  35: abstract class BaseCustomer extends BaseObject implements Persistent
  36: {
  37:     /**
  38:      * Peer class name
  39:      */
  40:     const PEER = 'Thelia\\Model\\CustomerPeer';
  41: 
  42:     /**
  43:      * The Peer class.
  44:      * Instance provides a convenient way of calling static methods on a class
  45:      * that calling code may not be able to identify.
  46:      * @var        CustomerPeer
  47:      */
  48:     protected static $peer;
  49: 
  50:     /**
  51:      * The flag var to prevent infinit loop in deep copy
  52:      * @var       boolean
  53:      */
  54:     protected $startCopy = false;
  55: 
  56:     /**
  57:      * The value for the id field.
  58:      * @var        int
  59:      */
  60:     protected $id;
  61: 
  62:     /**
  63:      * The value for the ref field.
  64:      * @var        string
  65:      */
  66:     protected $ref;
  67: 
  68:     /**
  69:      * The value for the customer_title_id field.
  70:      * @var        int
  71:      */
  72:     protected $customer_title_id;
  73: 
  74:     /**
  75:      * The value for the company field.
  76:      * @var        string
  77:      */
  78:     protected $company;
  79: 
  80:     /**
  81:      * The value for the firstname field.
  82:      * @var        string
  83:      */
  84:     protected $firstname;
  85: 
  86:     /**
  87:      * The value for the lastname field.
  88:      * @var        string
  89:      */
  90:     protected $lastname;
  91: 
  92:     /**
  93:      * The value for the address1 field.
  94:      * @var        string
  95:      */
  96:     protected $address1;
  97: 
  98:     /**
  99:      * The value for the address2 field.
 100:      * @var        string
 101:      */
 102:     protected $address2;
 103: 
 104:     /**
 105:      * The value for the address3 field.
 106:      * @var        string
 107:      */
 108:     protected $address3;
 109: 
 110:     /**
 111:      * The value for the zipcode field.
 112:      * @var        string
 113:      */
 114:     protected $zipcode;
 115: 
 116:     /**
 117:      * The value for the city field.
 118:      * @var        string
 119:      */
 120:     protected $city;
 121: 
 122:     /**
 123:      * The value for the country_id field.
 124:      * @var        int
 125:      */
 126:     protected $country_id;
 127: 
 128:     /**
 129:      * The value for the phone field.
 130:      * @var        string
 131:      */
 132:     protected $phone;
 133: 
 134:     /**
 135:      * The value for the cellphone field.
 136:      * @var        string
 137:      */
 138:     protected $cellphone;
 139: 
 140:     /**
 141:      * The value for the email field.
 142:      * @var        string
 143:      */
 144:     protected $email;
 145: 
 146:     /**
 147:      * The value for the password field.
 148:      * @var        string
 149:      */
 150:     protected $password;
 151: 
 152:     /**
 153:      * The value for the algo field.
 154:      * @var        string
 155:      */
 156:     protected $algo;
 157: 
 158:     /**
 159:      * The value for the salt field.
 160:      * @var        string
 161:      */
 162:     protected $salt;
 163: 
 164:     /**
 165:      * The value for the reseller field.
 166:      * @var        int
 167:      */
 168:     protected $reseller;
 169: 
 170:     /**
 171:      * The value for the lang field.
 172:      * @var        string
 173:      */
 174:     protected $lang;
 175: 
 176:     /**
 177:      * The value for the sponsor field.
 178:      * @var        string
 179:      */
 180:     protected $sponsor;
 181: 
 182:     /**
 183:      * The value for the discount field.
 184:      * @var        double
 185:      */
 186:     protected $discount;
 187: 
 188:     /**
 189:      * The value for the created_at field.
 190:      * @var        string
 191:      */
 192:     protected $created_at;
 193: 
 194:     /**
 195:      * The value for the updated_at field.
 196:      * @var        string
 197:      */
 198:     protected $updated_at;
 199: 
 200:     /**
 201:      * @var        CustomerTitle
 202:      */
 203:     protected $aCustomerTitle;
 204: 
 205:     /**
 206:      * @var        PropelObjectCollection|Address[] Collection to store aggregation of Address objects.
 207:      */
 208:     protected $collAddresss;
 209:     protected $collAddresssPartial;
 210: 
 211:     /**
 212:      * @var        PropelObjectCollection|Order[] Collection to store aggregation of Order objects.
 213:      */
 214:     protected $collOrders;
 215:     protected $collOrdersPartial;
 216: 
 217:     /**
 218:      * Flag to prevent endless save loop, if this object is referenced
 219:      * by another object which falls in this transaction.
 220:      * @var        boolean
 221:      */
 222:     protected $alreadyInSave = false;
 223: 
 224:     /**
 225:      * Flag to prevent endless validation loop, if this object is referenced
 226:      * by another object which falls in this transaction.
 227:      * @var        boolean
 228:      */
 229:     protected $alreadyInValidation = false;
 230: 
 231:     /**
 232:      * Flag to prevent endless clearAllReferences($deep=true) loop, if this object is referenced
 233:      * @var        boolean
 234:      */
 235:     protected $alreadyInClearAllReferencesDeep = false;
 236: 
 237:     /**
 238:      * An array of objects scheduled for deletion.
 239:      * @var     PropelObjectCollection
 240:      */
 241:     protected $addresssScheduledForDeletion = null;
 242: 
 243:     /**
 244:      * An array of objects scheduled for deletion.
 245:      * @var     PropelObjectCollection
 246:      */
 247:     protected $ordersScheduledForDeletion = null;
 248: 
 249:     /**
 250:      * Get the [id] column value.
 251:      *
 252:      * @return int
 253:      */
 254:     public function getId()
 255:     {
 256:         return $this->id;
 257:     }
 258: 
 259:     /**
 260:      * Get the [ref] column value.
 261:      *
 262:      * @return string
 263:      */
 264:     public function getRef()
 265:     {
 266:         return $this->ref;
 267:     }
 268: 
 269:     /**
 270:      * Get the [customer_title_id] column value.
 271:      *
 272:      * @return int
 273:      */
 274:     public function getCustomerTitleId()
 275:     {
 276:         return $this->customer_title_id;
 277:     }
 278: 
 279:     /**
 280:      * Get the [company] column value.
 281:      *
 282:      * @return string
 283:      */
 284:     public function getCompany()
 285:     {
 286:         return $this->company;
 287:     }
 288: 
 289:     /**
 290:      * Get the [firstname] column value.
 291:      *
 292:      * @return string
 293:      */
 294:     public function getFirstname()
 295:     {
 296:         return $this->firstname;
 297:     }
 298: 
 299:     /**
 300:      * Get the [lastname] column value.
 301:      *
 302:      * @return string
 303:      */
 304:     public function getLastname()
 305:     {
 306:         return $this->lastname;
 307:     }
 308: 
 309:     /**
 310:      * Get the [address1] column value.
 311:      *
 312:      * @return string
 313:      */
 314:     public function getAddress1()
 315:     {
 316:         return $this->address1;
 317:     }
 318: 
 319:     /**
 320:      * Get the [address2] column value.
 321:      *
 322:      * @return string
 323:      */
 324:     public function getAddress2()
 325:     {
 326:         return $this->address2;
 327:     }
 328: 
 329:     /**
 330:      * Get the [address3] column value.
 331:      *
 332:      * @return string
 333:      */
 334:     public function getAddress3()
 335:     {
 336:         return $this->address3;
 337:     }
 338: 
 339:     /**
 340:      * Get the [zipcode] column value.
 341:      *
 342:      * @return string
 343:      */
 344:     public function getZipcode()
 345:     {
 346:         return $this->zipcode;
 347:     }
 348: 
 349:     /**
 350:      * Get the [city] column value.
 351:      *
 352:      * @return string
 353:      */
 354:     public function getCity()
 355:     {
 356:         return $this->city;
 357:     }
 358: 
 359:     /**
 360:      * Get the [country_id] column value.
 361:      *
 362:      * @return int
 363:      */
 364:     public function getCountryId()
 365:     {
 366:         return $this->country_id;
 367:     }
 368: 
 369:     /**
 370:      * Get the [phone] column value.
 371:      *
 372:      * @return string
 373:      */
 374:     public function getPhone()
 375:     {
 376:         return $this->phone;
 377:     }
 378: 
 379:     /**
 380:      * Get the [cellphone] column value.
 381:      *
 382:      * @return string
 383:      */
 384:     public function getCellphone()
 385:     {
 386:         return $this->cellphone;
 387:     }
 388: 
 389:     /**
 390:      * Get the [email] column value.
 391:      *
 392:      * @return string
 393:      */
 394:     public function getEmail()
 395:     {
 396:         return $this->email;
 397:     }
 398: 
 399:     /**
 400:      * Get the [password] column value.
 401:      *
 402:      * @return string
 403:      */
 404:     public function getPassword()
 405:     {
 406:         return $this->password;
 407:     }
 408: 
 409:     /**
 410:      * Get the [algo] column value.
 411:      *
 412:      * @return string
 413:      */
 414:     public function getAlgo()
 415:     {
 416:         return $this->algo;
 417:     }
 418: 
 419:     /**
 420:      * Get the [salt] column value.
 421:      *
 422:      * @return string
 423:      */
 424:     public function getSalt()
 425:     {
 426:         return $this->salt;
 427:     }
 428: 
 429:     /**
 430:      * Get the [reseller] column value.
 431:      *
 432:      * @return int
 433:      */
 434:     public function getReseller()
 435:     {
 436:         return $this->reseller;
 437:     }
 438: 
 439:     /**
 440:      * Get the [lang] column value.
 441:      *
 442:      * @return string
 443:      */
 444:     public function getLang()
 445:     {
 446:         return $this->lang;
 447:     }
 448: 
 449:     /**
 450:      * Get the [sponsor] column value.
 451:      *
 452:      * @return string
 453:      */
 454:     public function getSponsor()
 455:     {
 456:         return $this->sponsor;
 457:     }
 458: 
 459:     /**
 460:      * Get the [discount] column value.
 461:      *
 462:      * @return double
 463:      */
 464:     public function getDiscount()
 465:     {
 466:         return $this->discount;
 467:     }
 468: 
 469:     /**
 470:      * Get the [optionally formatted] temporal [created_at] column value.
 471:      *
 472:      *
 473:      * @param string $format The date/time format string (either date()-style or strftime()-style).
 474:      *               If format is null, then the raw DateTime object will be returned.
 475:      * @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
 476:      * @throws PropelException - if unable to parse/validate the date/time value.
 477:      */
 478:     public function getCreatedAt($format = 'Y-m-d H:i:s')
 479:     {
 480:         if ($this->created_at === null) {
 481:             return null;
 482:         }
 483: 
 484:         if ($this->created_at === '0000-00-00 00:00:00') {
 485:             // while technically this is not a default value of null,
 486:             // this seems to be closest in meaning.
 487:             return null;
 488:         }
 489: 
 490:         try {
 491:             $dt = new DateTime($this->created_at);
 492:         } catch (Exception $x) {
 493:             throw new PropelException("Internally stored date/time/timestamp value could not be converted to DateTime: " . var_export($this->created_at, true), $x);
 494:         }
 495: 
 496:         if ($format === null) {
 497:             // Because propel.useDateTimeClass is true, we return a DateTime object.
 498:             return $dt;
 499:         }
 500: 
 501:         if (strpos($format, '%') !== false) {
 502:             return strftime($format, $dt->format('U'));
 503:         }
 504: 
 505:         return $dt->format($format);
 506: 
 507:     }
 508: 
 509:     /**
 510:      * Get the [optionally formatted] temporal [updated_at] column value.
 511:      *
 512:      *
 513:      * @param string $format The date/time format string (either date()-style or strftime()-style).
 514:      *               If format is null, then the raw DateTime object will be returned.
 515:      * @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
 516:      * @throws PropelException - if unable to parse/validate the date/time value.
 517:      */
 518:     public function getUpdatedAt($format = 'Y-m-d H:i:s')
 519:     {
 520:         if ($this->updated_at === null) {
 521:             return null;
 522:         }
 523: 
 524:         if ($this->updated_at === '0000-00-00 00:00:00') {
 525:             // while technically this is not a default value of null,
 526:             // this seems to be closest in meaning.
 527:             return null;
 528:         }
 529: 
 530:         try {
 531:             $dt = new DateTime($this->updated_at);
 532:         } catch (Exception $x) {
 533:             throw new PropelException("Internally stored date/time/timestamp value could not be converted to DateTime: " . var_export($this->updated_at, true), $x);
 534:         }
 535: 
 536:         if ($format === null) {
 537:             // Because propel.useDateTimeClass is true, we return a DateTime object.
 538:             return $dt;
 539:         }
 540: 
 541:         if (strpos($format, '%') !== false) {
 542:             return strftime($format, $dt->format('U'));
 543:         }
 544: 
 545:         return $dt->format($format);
 546: 
 547:     }
 548: 
 549:     /**
 550:      * Set the value of [id] column.
 551:      *
 552:      * @param int $v new value
 553:      * @return Customer The current object (for fluent API support)
 554:      */
 555:     public function setId($v)
 556:     {
 557:         if ($v !== null && is_numeric($v)) {
 558:             $v = (int) $v;
 559:         }
 560: 
 561:         if ($this->id !== $v) {
 562:             $this->id = $v;
 563:             $this->modifiedColumns[] = CustomerPeer::ID;
 564:         }
 565: 
 566: 
 567:         return $this;
 568:     } // setId()
 569: 
 570:     /**
 571:      * Set the value of [ref] column.
 572:      *
 573:      * @param string $v new value
 574:      * @return Customer The current object (for fluent API support)
 575:      */
 576:     public function setRef($v)
 577:     {
 578:         if ($v !== null && is_numeric($v)) {
 579:             $v = (string) $v;
 580:         }
 581: 
 582:         if ($this->ref !== $v) {
 583:             $this->ref = $v;
 584:             $this->modifiedColumns[] = CustomerPeer::REF;
 585:         }
 586: 
 587: 
 588:         return $this;
 589:     } // setRef()
 590: 
 591:     /**
 592:      * Set the value of [customer_title_id] column.
 593:      *
 594:      * @param int $v new value
 595:      * @return Customer The current object (for fluent API support)
 596:      */
 597:     public function setCustomerTitleId($v)
 598:     {
 599:         if ($v !== null && is_numeric($v)) {
 600:             $v = (int) $v;
 601:         }
 602: 
 603:         if ($this->customer_title_id !== $v) {
 604:             $this->customer_title_id = $v;
 605:             $this->modifiedColumns[] = CustomerPeer::CUSTOMER_TITLE_ID;
 606:         }
 607: 
 608:         if ($this->aCustomerTitle !== null && $this->aCustomerTitle->getId() !== $v) {
 609:             $this->aCustomerTitle = null;
 610:         }
 611: 
 612: 
 613:         return $this;
 614:     } // setCustomerTitleId()
 615: 
 616:     /**
 617:      * Set the value of [company] column.
 618:      *
 619:      * @param string $v new value
 620:      * @return Customer The current object (for fluent API support)
 621:      */
 622:     public function setCompany($v)
 623:     {
 624:         if ($v !== null && is_numeric($v)) {
 625:             $v = (string) $v;
 626:         }
 627: 
 628:         if ($this->company !== $v) {
 629:             $this->company = $v;
 630:             $this->modifiedColumns[] = CustomerPeer::COMPANY;
 631:         }
 632: 
 633: 
 634:         return $this;
 635:     } // setCompany()
 636: 
 637:     /**
 638:      * Set the value of [firstname] column.
 639:      *
 640:      * @param string $v new value
 641:      * @return Customer The current object (for fluent API support)
 642:      */
 643:     public function setFirstname($v)
 644:     {
 645:         if ($v !== null && is_numeric($v)) {
 646:             $v = (string) $v;
 647:         }
 648: 
 649:         if ($this->firstname !== $v) {
 650:             $this->firstname = $v;
 651:             $this->modifiedColumns[] = CustomerPeer::FIRSTNAME;
 652:         }
 653: 
 654: 
 655:         return $this;
 656:     } // setFirstname()
 657: 
 658:     /**
 659:      * Set the value of [lastname] column.
 660:      *
 661:      * @param string $v new value
 662:      * @return Customer The current object (for fluent API support)
 663:      */
 664:     public function setLastname($v)
 665:     {
 666:         if ($v !== null && is_numeric($v)) {
 667:             $v = (string) $v;
 668:         }
 669: 
 670:         if ($this->lastname !== $v) {
 671:             $this->lastname = $v;
 672:             $this->modifiedColumns[] = CustomerPeer::LASTNAME;
 673:         }
 674: 
 675: 
 676:         return $this;
 677:     } // setLastname()
 678: 
 679:     /**
 680:      * Set the value of [address1] column.
 681:      *
 682:      * @param string $v new value
 683:      * @return Customer The current object (for fluent API support)
 684:      */
 685:     public function setAddress1($v)
 686:     {
 687:         if ($v !== null && is_numeric($v)) {
 688:             $v = (string) $v;
 689:         }
 690: 
 691:         if ($this->address1 !== $v) {
 692:             $this->address1 = $v;
 693:             $this->modifiedColumns[] = CustomerPeer::ADDRESS1;
 694:         }
 695: 
 696: 
 697:         return $this;
 698:     } // setAddress1()
 699: 
 700:     /**
 701:      * Set the value of [address2] column.
 702:      *
 703:      * @param string $v new value
 704:      * @return Customer The current object (for fluent API support)
 705:      */
 706:     public function setAddress2($v)
 707:     {
 708:         if ($v !== null && is_numeric($v)) {
 709:             $v = (string) $v;
 710:         }
 711: 
 712:         if ($this->address2 !== $v) {
 713:             $this->address2 = $v;
 714:             $this->modifiedColumns[] = CustomerPeer::ADDRESS2;
 715:         }
 716: 
 717: 
 718:         return $this;
 719:     } // setAddress2()
 720: 
 721:     /**
 722:      * Set the value of [address3] column.
 723:      *
 724:      * @param string $v new value
 725:      * @return Customer The current object (for fluent API support)
 726:      */
 727:     public function setAddress3($v)
 728:     {
 729:         if ($v !== null && is_numeric($v)) {
 730:             $v = (string) $v;
 731:         }
 732: 
 733:         if ($this->address3 !== $v) {
 734:             $this->address3 = $v;
 735:             $this->modifiedColumns[] = CustomerPeer::ADDRESS3;
 736:         }
 737: 
 738: 
 739:         return $this;
 740:     } // setAddress3()
 741: 
 742:     /**
 743:      * Set the value of [zipcode] column.
 744:      *
 745:      * @param string $v new value
 746:      * @return Customer The current object (for fluent API support)
 747:      */
 748:     public function setZipcode($v)
 749:     {
 750:         if ($v !== null && is_numeric($v)) {
 751:             $v = (string) $v;
 752:         }
 753: 
 754:         if ($this->zipcode !== $v) {
 755:             $this->zipcode = $v;
 756:             $this->modifiedColumns[] = CustomerPeer::ZIPCODE;
 757:         }
 758: 
 759: 
 760:         return $this;
 761:     } // setZipcode()
 762: 
 763:     /**
 764:      * Set the value of [city] column.
 765:      *
 766:      * @param string $v new value
 767:      * @return Customer The current object (for fluent API support)
 768:      */
 769:     public function setCity($v)
 770:     {
 771:         if ($v !== null && is_numeric($v)) {
 772:             $v = (string) $v;
 773:         }
 774: 
 775:         if ($this->city !== $v) {
 776:             $this->city = $v;
 777:             $this->modifiedColumns[] = CustomerPeer::CITY;
 778:         }
 779: 
 780: 
 781:         return $this;
 782:     } // setCity()
 783: 
 784:     /**
 785:      * Set the value of [country_id] column.
 786:      *
 787:      * @param int $v new value
 788:      * @return Customer The current object (for fluent API support)
 789:      */
 790:     public function setCountryId($v)
 791:     {
 792:         if ($v !== null && is_numeric($v)) {
 793:             $v = (int) $v;
 794:         }
 795: 
 796:         if ($this->country_id !== $v) {
 797:             $this->country_id = $v;
 798:             $this->modifiedColumns[] = CustomerPeer::COUNTRY_ID;
 799:         }
 800: 
 801: 
 802:         return $this;
 803:     } // setCountryId()
 804: 
 805:     /**
 806:      * Set the value of [phone] column.
 807:      *
 808:      * @param string $v new value
 809:      * @return Customer The current object (for fluent API support)
 810:      */
 811:     public function setPhone($v)
 812:     {
 813:         if ($v !== null && is_numeric($v)) {
 814:             $v = (string) $v;
 815:         }
 816: 
 817:         if ($this->phone !== $v) {
 818:             $this->phone = $v;
 819:             $this->modifiedColumns[] = CustomerPeer::PHONE;
 820:         }
 821: 
 822: 
 823:         return $this;
 824:     } // setPhone()
 825: 
 826:     /**
 827:      * Set the value of [cellphone] column.
 828:      *
 829:      * @param string $v new value
 830:      * @return Customer The current object (for fluent API support)
 831:      */
 832:     public function setCellphone($v)
 833:     {
 834:         if ($v !== null && is_numeric($v)) {
 835:             $v = (string) $v;
 836:         }
 837: 
 838:         if ($this->cellphone !== $v) {
 839:             $this->cellphone = $v;
 840:             $this->modifiedColumns[] = CustomerPeer::CELLPHONE;
 841:         }
 842: 
 843: 
 844:         return $this;
 845:     } // setCellphone()
 846: 
 847:     /**
 848:      * Set the value of [email] column.
 849:      *
 850:      * @param string $v new value
 851:      * @return Customer The current object (for fluent API support)
 852:      */
 853:     public function setEmail($v)
 854:     {
 855:         if ($v !== null && is_numeric($v)) {
 856:             $v = (string) $v;
 857:         }
 858: 
 859:         if ($this->email !== $v) {
 860:             $this->email = $v;
 861:             $this->modifiedColumns[] = CustomerPeer::EMAIL;
 862:         }
 863: 
 864: 
 865:         return $this;
 866:     } // setEmail()
 867: 
 868:     /**
 869:      * Set the value of [password] column.
 870:      *
 871:      * @param string $v new value
 872:      * @return Customer The current object (for fluent API support)
 873:      */
 874:     public function setPassword($v)
 875:     {
 876:         if ($v !== null && is_numeric($v)) {
 877:             $v = (string) $v;
 878:         }
 879: 
 880:         if ($this->password !== $v) {
 881:             $this->password = $v;
 882:             $this->modifiedColumns[] = CustomerPeer::PASSWORD;
 883:         }
 884: 
 885: 
 886:         return $this;
 887:     } // setPassword()
 888: 
 889:     /**
 890:      * Set the value of [algo] column.
 891:      *
 892:      * @param string $v new value
 893:      * @return Customer The current object (for fluent API support)
 894:      */
 895:     public function setAlgo($v)
 896:     {
 897:         if ($v !== null && is_numeric($v)) {
 898:             $v = (string) $v;
 899:         }
 900: 
 901:         if ($this->algo !== $v) {
 902:             $this->algo = $v;
 903:             $this->modifiedColumns[] = CustomerPeer::ALGO;
 904:         }
 905: 
 906: 
 907:         return $this;
 908:     } // setAlgo()
 909: 
 910:     /**
 911:      * Set the value of [salt] column.
 912:      *
 913:      * @param string $v new value
 914:      * @return Customer The current object (for fluent API support)
 915:      */
 916:     public function setSalt($v)
 917:     {
 918:         if ($v !== null && is_numeric($v)) {
 919:             $v = (string) $v;
 920:         }
 921: 
 922:         if ($this->salt !== $v) {
 923:             $this->salt = $v;
 924:             $this->modifiedColumns[] = CustomerPeer::SALT;
 925:         }
 926: 
 927: 
 928:         return $this;
 929:     } // setSalt()
 930: 
 931:     /**
 932:      * Set the value of [reseller] column.
 933:      *
 934:      * @param int $v new value
 935:      * @return Customer The current object (for fluent API support)
 936:      */
 937:     public function setReseller($v)
 938:     {
 939:         if ($v !== null && is_numeric($v)) {
 940:             $v = (int) $v;
 941:         }
 942: 
 943:         if ($this->reseller !== $v) {
 944:             $this->reseller = $v;
 945:             $this->modifiedColumns[] = CustomerPeer::RESELLER;
 946:         }
 947: 
 948: 
 949:         return $this;
 950:     } // setReseller()
 951: 
 952:     /**
 953:      * Set the value of [lang] column.
 954:      *
 955:      * @param string $v new value
 956:      * @return Customer The current object (for fluent API support)
 957:      */
 958:     public function setLang($v)
 959:     {
 960:         if ($v !== null && is_numeric($v)) {
 961:             $v = (string) $v;
 962:         }
 963: 
 964:         if ($this->lang !== $v) {
 965:             $this->lang = $v;
 966:             $this->modifiedColumns[] = CustomerPeer::LANG;
 967:         }
 968: 
 969: 
 970:         return $this;
 971:     } // setLang()
 972: 
 973:     /**
 974:      * Set the value of [sponsor] column.
 975:      *
 976:      * @param string $v new value
 977:      * @return Customer The current object (for fluent API support)
 978:      */
 979:     public function setSponsor($v)
 980:     {
 981:         if ($v !== null && is_numeric($v)) {
 982:             $v = (string) $v;
 983:         }
 984: 
 985:         if ($this->sponsor !== $v) {
 986:             $this->sponsor = $v;
 987:             $this->modifiedColumns[] = CustomerPeer::SPONSOR;
 988:         }
 989: 
 990: 
 991:         return $this;
 992:     } // setSponsor()
 993: 
 994:     /**
 995:      * Set the value of [discount] column.
 996:      *
 997:      * @param double $v new value
 998:      * @return Customer The current object (for fluent API support)
 999:      */
1000:     public function setDiscount($v)
1001:     {
1002:         if ($v !== null && is_numeric($v)) {
1003:             $v = (double) $v;
1004:         }
1005: 
1006:         if ($this->discount !== $v) {
1007:             $this->discount = $v;
1008:             $this->modifiedColumns[] = CustomerPeer::DISCOUNT;
1009:         }
1010: 
1011: 
1012:         return $this;
1013:     } // setDiscount()
1014: 
1015:     /**
1016:      * Sets the value of [created_at] column to a normalized version of the date/time value specified.
1017:      *
1018:      * @param mixed $v string, integer (timestamp), or DateTime value.
1019:      *               Empty strings are treated as null.
1020:      * @return Customer The current object (for fluent API support)
1021:      */
1022:     public function setCreatedAt($v)
1023:     {
1024:         $dt = PropelDateTime::newInstance($v, null, 'DateTime');
1025:         if ($this->created_at !== null || $dt !== null) {
1026:             $currentDateAsString = ($this->created_at !== null && $tmpDt = new DateTime($this->created_at)) ? $tmpDt->format('Y-m-d H:i:s') : null;
1027:             $newDateAsString = $dt ? $dt->format('Y-m-d H:i:s') : null;
1028:             if ($currentDateAsString !== $newDateAsString) {
1029:                 $this->created_at = $newDateAsString;
1030:                 $this->modifiedColumns[] = CustomerPeer::CREATED_AT;
1031:             }
1032:         } // if either are not null
1033: 
1034: 
1035:         return $this;
1036:     } // setCreatedAt()
1037: 
1038:     /**
1039:      * Sets the value of [updated_at] column to a normalized version of the date/time value specified.
1040:      *
1041:      * @param mixed $v string, integer (timestamp), or DateTime value.
1042:      *               Empty strings are treated as null.
1043:      * @return Customer The current object (for fluent API support)
1044:      */
1045:     public function setUpdatedAt($v)
1046:     {
1047:         $dt = PropelDateTime::newInstance($v, null, 'DateTime');
1048:         if ($this->updated_at !== null || $dt !== null) {
1049:             $currentDateAsString = ($this->updated_at !== null && $tmpDt = new DateTime($this->updated_at)) ? $tmpDt->format('Y-m-d H:i:s') : null;
1050:             $newDateAsString = $dt ? $dt->format('Y-m-d H:i:s') : null;
1051:             if ($currentDateAsString !== $newDateAsString) {
1052:                 $this->updated_at = $newDateAsString;
1053:                 $this->modifiedColumns[] = CustomerPeer::UPDATED_AT;
1054:             }
1055:         } // if either are not null
1056: 
1057: 
1058:         return $this;
1059:     } // setUpdatedAt()
1060: 
1061:     /**
1062:      * Indicates whether the columns in this object are only set to default values.
1063:      *
1064:      * This method can be used in conjunction with isModified() to indicate whether an object is both
1065:      * modified _and_ has some values set which are non-default.
1066:      *
1067:      * @return boolean Whether the columns in this object are only been set with default values.
1068:      */
1069:     public function hasOnlyDefaultValues()
1070:     {
1071:         // otherwise, everything was equal, so return true
1072:         return true;
1073:     } // hasOnlyDefaultValues()
1074: 
1075:     /**
1076:      * Hydrates (populates) the object variables with values from the database resultset.
1077:      *
1078:      * An offset (0-based "start column") is specified so that objects can be hydrated
1079:      * with a subset of the columns in the resultset rows.  This is needed, for example,
1080:      * for results of JOIN queries where the resultset row includes columns from two or
1081:      * more tables.
1082:      *
1083:      * @param array $row The row returned by PDOStatement->fetch(PDO::FETCH_NUM)
1084:      * @param int $startcol 0-based offset column which indicates which restultset column to start with.
1085:      * @param boolean $rehydrate Whether this object is being re-hydrated from the database.
1086:      * @return int             next starting column
1087:      * @throws PropelException - Any caught Exception will be rewrapped as a PropelException.
1088:      */
1089:     public function hydrate($row, $startcol = 0, $rehydrate = false)
1090:     {
1091:         try {
1092: 
1093:             $this->id = ($row[$startcol + 0] !== null) ? (int) $row[$startcol + 0] : null;
1094:             $this->ref = ($row[$startcol + 1] !== null) ? (string) $row[$startcol + 1] : null;
1095:             $this->customer_title_id = ($row[$startcol + 2] !== null) ? (int) $row[$startcol + 2] : null;
1096:             $this->company = ($row[$startcol + 3] !== null) ? (string) $row[$startcol + 3] : null;
1097:             $this->firstname = ($row[$startcol + 4] !== null) ? (string) $row[$startcol + 4] : null;
1098:             $this->lastname = ($row[$startcol + 5] !== null) ? (string) $row[$startcol + 5] : null;
1099:             $this->address1 = ($row[$startcol + 6] !== null) ? (string) $row[$startcol + 6] : null;
1100:             $this->address2 = ($row[$startcol + 7] !== null) ? (string) $row[$startcol + 7] : null;
1101:             $this->address3 = ($row[$startcol + 8] !== null) ? (string) $row[$startcol + 8] : null;
1102:             $this->zipcode = ($row[$startcol + 9] !== null) ? (string) $row[$startcol + 9] : null;
1103:             $this->city = ($row[$startcol + 10] !== null) ? (string) $row[$startcol + 10] : null;
1104:             $this->country_id = ($row[$startcol + 11] !== null) ? (int) $row[$startcol + 11] : null;
1105:             $this->phone = ($row[$startcol + 12] !== null) ? (string) $row[$startcol + 12] : null;
1106:             $this->cellphone = ($row[$startcol + 13] !== null) ? (string) $row[$startcol + 13] : null;
1107:             $this->email = ($row[$startcol + 14] !== null) ? (string) $row[$startcol + 14] : null;
1108:             $this->password = ($row[$startcol + 15] !== null) ? (string) $row[$startcol + 15] : null;
1109:             $this->algo = ($row[$startcol + 16] !== null) ? (string) $row[$startcol + 16] : null;
1110:             $this->salt = ($row[$startcol + 17] !== null) ? (string) $row[$startcol + 17] : null;
1111:             $this->reseller = ($row[$startcol + 18] !== null) ? (int) $row[$startcol + 18] : null;
1112:             $this->lang = ($row[$startcol + 19] !== null) ? (string) $row[$startcol + 19] : null;
1113:             $this->sponsor = ($row[$startcol + 20] !== null) ? (string) $row[$startcol + 20] : null;
1114:             $this->discount = ($row[$startcol + 21] !== null) ? (double) $row[$startcol + 21] : null;
1115:             $this->created_at = ($row[$startcol + 22] !== null) ? (string) $row[$startcol + 22] : null;
1116:             $this->updated_at = ($row[$startcol + 23] !== null) ? (string) $row[$startcol + 23] : null;
1117:             $this->resetModified();
1118: 
1119:             $this->setNew(false);
1120: 
1121:             if ($rehydrate) {
1122:                 $this->ensureConsistency();
1123:             }
1124:             $this->postHydrate($row, $startcol, $rehydrate);
1125:             return $startcol + 24; // 24 = CustomerPeer::NUM_HYDRATE_COLUMNS.
1126: 
1127:         } catch (Exception $e) {
1128:             throw new PropelException("Error populating Customer object", $e);
1129:         }
1130:     }
1131: 
1132:     /**
1133:      * Checks and repairs the internal consistency of the object.
1134:      *
1135:      * This method is executed after an already-instantiated object is re-hydrated
1136:      * from the database.  It exists to check any foreign keys to make sure that
1137:      * the objects related to the current object are correct based on foreign key.
1138:      *
1139:      * You can override this method in the stub class, but you should always invoke
1140:      * the base method from the overridden method (i.e. parent::ensureConsistency()),
1141:      * in case your model changes.
1142:      *
1143:      * @throws PropelException
1144:      */
1145:     public function ensureConsistency()
1146:     {
1147: 
1148:         if ($this->aCustomerTitle !== null && $this->customer_title_id !== $this->aCustomerTitle->getId()) {
1149:             $this->aCustomerTitle = null;
1150:         }
1151:     } // ensureConsistency
1152: 
1153:     /**
1154:      * Reloads this object from datastore based on primary key and (optionally) resets all associated objects.
1155:      *
1156:      * This will only work if the object has been saved and has a valid primary key set.
1157:      *
1158:      * @param boolean $deep (optional) Whether to also de-associated any related objects.
1159:      * @param PropelPDO $con (optional) The PropelPDO connection to use.
1160:      * @return void
1161:      * @throws PropelException - if this object is deleted, unsaved or doesn't have pk match in db
1162:      */
1163:     public function reload($deep = false, PropelPDO $con = null)
1164:     {
1165:         if ($this->isDeleted()) {
1166:             throw new PropelException("Cannot reload a deleted object.");
1167:         }
1168: 
1169:         if ($this->isNew()) {
1170:             throw new PropelException("Cannot reload an unsaved object.");
1171:         }
1172: 
1173:         if ($con === null) {
1174:             $con = Propel::getConnection(CustomerPeer::DATABASE_NAME, Propel::CONNECTION_READ);
1175:         }
1176: 
1177:         // We don't need to alter the object instance pool; we're just modifying this instance
1178:         // already in the pool.
1179: 
1180:         $stmt = CustomerPeer::doSelectStmt($this->buildPkeyCriteria(), $con);
1181:         $row = $stmt->fetch(PDO::FETCH_NUM);
1182:         $stmt->closeCursor();
1183:         if (!$row) {
1184:             throw new PropelException('Cannot find matching row in the database to reload object values.');
1185:         }
1186:         $this->hydrate($row, 0, true); // rehydrate
1187: 
1188:         if ($deep) {  // also de-associate any related objects?
1189: 
1190:             $this->aCustomerTitle = null;
1191:             $this->collAddresss = null;
1192: 
1193:             $this->collOrders = null;
1194: 
1195:         } // if (deep)
1196:     }
1197: 
1198:     /**
1199:      * Removes this object from datastore and sets delete attribute.
1200:      *
1201:      * @param PropelPDO $con
1202:      * @return void
1203:      * @throws PropelException
1204:      * @throws Exception
1205:      * @see        BaseObject::setDeleted()
1206:      * @see        BaseObject::isDeleted()
1207:      */
1208:     public function delete(PropelPDO $con = null)
1209:     {
1210:         if ($this->isDeleted()) {
1211:             throw new PropelException("This object has already been deleted.");
1212:         }
1213: 
1214:         if ($con === null) {
1215:             $con = Propel::getConnection(CustomerPeer::DATABASE_NAME, Propel::CONNECTION_WRITE);
1216:         }
1217: 
1218:         $con->beginTransaction();
1219:         try {
1220:             $deleteQuery = CustomerQuery::create()
1221:                 ->filterByPrimaryKey($this->getPrimaryKey());
1222:             $ret = $this->preDelete($con);
1223:             if ($ret) {
1224:                 $deleteQuery->delete($con);
1225:                 $this->postDelete($con);
1226:                 $con->commit();
1227:                 $this->setDeleted(true);
1228:             } else {
1229:                 $con->commit();
1230:             }
1231:         } catch (Exception $e) {
1232:             $con->rollBack();
1233:             throw $e;
1234:         }
1235:     }
1236: 
1237:     /**
1238:      * Persists this object to the database.
1239:      *
1240:      * If the object is new, it inserts it; otherwise an update is performed.
1241:      * All modified related objects will also be persisted in the doSave()
1242:      * method.  This method wraps all precipitate database operations in a
1243:      * single transaction.
1244:      *
1245:      * @param PropelPDO $con
1246:      * @return int             The number of rows affected by this insert/update and any referring fk objects' save() operations.
1247:      * @throws PropelException
1248:      * @throws Exception
1249:      * @see        doSave()
1250:      */
1251:     public function save(PropelPDO $con = null)
1252:     {
1253:         if ($this->isDeleted()) {
1254:             throw new PropelException("You cannot save an object that has been deleted.");
1255:         }
1256: 
1257:         if ($con === null) {
1258:             $con = Propel::getConnection(CustomerPeer::DATABASE_NAME, Propel::CONNECTION_WRITE);
1259:         }
1260: 
1261:         $con->beginTransaction();
1262:         $isInsert = $this->isNew();
1263:         try {
1264:             $ret = $this->preSave($con);
1265:             if ($isInsert) {
1266:                 $ret = $ret && $this->preInsert($con);
1267:                 // timestampable behavior
1268:                 if (!$this->isColumnModified(CustomerPeer::CREATED_AT)) {
1269:                     $this->setCreatedAt(time());
1270:                 }
1271:                 if (!$this->isColumnModified(CustomerPeer::UPDATED_AT)) {
1272:                     $this->setUpdatedAt(time());
1273:                 }
1274:             } else {
1275:                 $ret = $ret && $this->preUpdate($con);
1276:                 // timestampable behavior
1277:                 if ($this->isModified() && !$this->isColumnModified(CustomerPeer::UPDATED_AT)) {
1278:                     $this->setUpdatedAt(time());
1279:                 }
1280:             }
1281:             if ($ret) {
1282:                 $affectedRows = $this->doSave($con);
1283:                 if ($isInsert) {
1284:                     $this->postInsert($con);
1285:                 } else {
1286:                     $this->postUpdate($con);
1287:                 }
1288:                 $this->postSave($con);
1289:                 CustomerPeer::addInstanceToPool($this);
1290:             } else {
1291:                 $affectedRows = 0;
1292:             }
1293:             $con->commit();
1294: 
1295:             return $affectedRows;
1296:         } catch (Exception $e) {
1297:             $con->rollBack();
1298:             throw $e;
1299:         }
1300:     }
1301: 
1302:     /**
1303:      * Performs the work of inserting or updating the row in the database.
1304:      *
1305:      * If the object is new, it inserts it; otherwise an update is performed.
1306:      * All related objects are also updated in this method.
1307:      *
1308:      * @param PropelPDO $con
1309:      * @return int             The number of rows affected by this insert/update and any referring fk objects' save() operations.
1310:      * @throws PropelException
1311:      * @see        save()
1312:      */
1313:     protected function doSave(PropelPDO $con)
1314:     {
1315:         $affectedRows = 0; // initialize var to track total num of affected rows
1316:         if (!$this->alreadyInSave) {
1317:             $this->alreadyInSave = true;
1318: 
1319:             // We call the save method on the following object(s) if they
1320:             // were passed to this object by their coresponding set
1321:             // method.  This object relates to these object(s) by a
1322:             // foreign key reference.
1323: 
1324:             if ($this->aCustomerTitle !== null) {
1325:                 if ($this->aCustomerTitle->isModified() || $this->aCustomerTitle->isNew()) {
1326:                     $affectedRows += $this->aCustomerTitle->save($con);
1327:                 }
1328:                 $this->setCustomerTitle($this->aCustomerTitle);
1329:             }
1330: 
1331:             if ($this->isNew() || $this->isModified()) {
1332:                 // persist changes
1333:                 if ($this->isNew()) {
1334:                     $this->doInsert($con);
1335:                 } else {
1336:                     $this->doUpdate($con);
1337:                 }
1338:                 $affectedRows += 1;
1339:                 $this->resetModified();
1340:             }
1341: 
1342:             if ($this->addresssScheduledForDeletion !== null) {
1343:                 if (!$this->addresssScheduledForDeletion->isEmpty()) {
1344:                     AddressQuery::create()
1345:                         ->filterByPrimaryKeys($this->addresssScheduledForDeletion->getPrimaryKeys(false))
1346:                         ->delete($con);
1347:                     $this->addresssScheduledForDeletion = null;
1348:                 }
1349:             }
1350: 
1351:             if ($this->collAddresss !== null) {
1352:                 foreach ($this->collAddresss as $referrerFK) {
1353:                     if (!$referrerFK->isDeleted() && ($referrerFK->isNew() || $referrerFK->isModified())) {
1354:                         $affectedRows += $referrerFK->save($con);
1355:                     }
1356:                 }
1357:             }
1358: 
1359:             if ($this->ordersScheduledForDeletion !== null) {
1360:                 if (!$this->ordersScheduledForDeletion->isEmpty()) {
1361:                     OrderQuery::create()
1362:                         ->filterByPrimaryKeys($this->ordersScheduledForDeletion->getPrimaryKeys(false))
1363:                         ->delete($con);
1364:                     $this->ordersScheduledForDeletion = null;
1365:                 }
1366:             }
1367: 
1368:             if ($this->collOrders !== null) {
1369:                 foreach ($this->collOrders as $referrerFK) {
1370:                     if (!$referrerFK->isDeleted() && ($referrerFK->isNew() || $referrerFK->isModified())) {
1371:                         $affectedRows += $referrerFK->save($con);
1372:                     }
1373:                 }
1374:             }
1375: 
1376:             $this->alreadyInSave = false;
1377: 
1378:         }
1379: 
1380:         return $affectedRows;
1381:     } // doSave()
1382: 
1383:     /**
1384:      * Insert the row in the database.
1385:      *
1386:      * @param PropelPDO $con
1387:      *
1388:      * @throws PropelException
1389:      * @see        doSave()
1390:      */
1391:     protected function doInsert(PropelPDO $con)
1392:     {
1393:         $modifiedColumns = array();
1394:         $index = 0;
1395: 
1396:         $this->modifiedColumns[] = CustomerPeer::ID;
1397:         if (null !== $this->id) {
1398:             throw new PropelException('Cannot insert a value for auto-increment primary key (' . CustomerPeer::ID . ')');
1399:         }
1400: 
1401:          // check the columns in natural order for more readable SQL queries
1402:         if ($this->isColumnModified(CustomerPeer::ID)) {
1403:             $modifiedColumns[':p' . $index++]  = '`id`';
1404:         }
1405:         if ($this->isColumnModified(CustomerPeer::REF)) {
1406:             $modifiedColumns[':p' . $index++]  = '`ref`';
1407:         }
1408:         if ($this->isColumnModified(CustomerPeer::CUSTOMER_TITLE_ID)) {
1409:             $modifiedColumns[':p' . $index++]  = '`customer_title_id`';
1410:         }
1411:         if ($this->isColumnModified(CustomerPeer::COMPANY)) {
1412:             $modifiedColumns[':p' . $index++]  = '`company`';
1413:         }
1414:         if ($this->isColumnModified(CustomerPeer::FIRSTNAME)) {
1415:             $modifiedColumns[':p' . $index++]  = '`firstname`';
1416:         }
1417:         if ($this->isColumnModified(CustomerPeer::LASTNAME)) {
1418:             $modifiedColumns[':p' . $index++]  = '`lastname`';
1419:         }
1420:         if ($this->isColumnModified(CustomerPeer::ADDRESS1)) {
1421:             $modifiedColumns[':p' . $index++]  = '`address1`';
1422:         }
1423:         if ($this->isColumnModified(CustomerPeer::ADDRESS2)) {
1424:             $modifiedColumns[':p' . $index++]  = '`address2`';
1425:         }
1426:         if ($this->isColumnModified(CustomerPeer::ADDRESS3)) {
1427:             $modifiedColumns[':p' . $index++]  = '`address3`';
1428:         }
1429:         if ($this->isColumnModified(CustomerPeer::ZIPCODE)) {
1430:             $modifiedColumns[':p' . $index++]  = '`zipcode`';
1431:         }
1432:         if ($this->isColumnModified(CustomerPeer::CITY)) {
1433:             $modifiedColumns[':p' . $index++]  = '`city`';
1434:         }
1435:         if ($this->isColumnModified(CustomerPeer::COUNTRY_ID)) {
1436:             $modifiedColumns[':p' . $index++]  = '`country_id`';
1437:         }
1438:         if ($this->isColumnModified(CustomerPeer::PHONE)) {
1439:             $modifiedColumns[':p' . $index++]  = '`phone`';
1440:         }
1441:         if ($this->isColumnModified(CustomerPeer::CELLPHONE)) {
1442:             $modifiedColumns[':p' . $index++]  = '`cellphone`';
1443:         }
1444:         if ($this->isColumnModified(CustomerPeer::EMAIL)) {
1445:             $modifiedColumns[':p' . $index++]  = '`email`';
1446:         }
1447:         if ($this->isColumnModified(CustomerPeer::PASSWORD)) {
1448:             $modifiedColumns[':p' . $index++]  = '`password`';
1449:         }
1450:         if ($this->isColumnModified(CustomerPeer::ALGO)) {
1451:             $modifiedColumns[':p' . $index++]  = '`algo`';
1452:         }
1453:         if ($this->isColumnModified(CustomerPeer::SALT)) {
1454:             $modifiedColumns[':p' . $index++]  = '`salt`';
1455:         }
1456:         if ($this->isColumnModified(CustomerPeer::RESELLER)) {
1457:             $modifiedColumns[':p' . $index++]  = '`reseller`';
1458:         }
1459:         if ($this->isColumnModified(CustomerPeer::LANG)) {
1460:             $modifiedColumns[':p' . $index++]  = '`lang`';
1461:         }
1462:         if ($this->isColumnModified(CustomerPeer::SPONSOR)) {
1463:             $modifiedColumns[':p' . $index++]  = '`sponsor`';
1464:         }
1465:         if ($this->isColumnModified(CustomerPeer::DISCOUNT)) {
1466:             $modifiedColumns[':p' . $index++]  = '`discount`';
1467:         }
1468:         if ($this->isColumnModified(CustomerPeer::CREATED_AT)) {
1469:             $modifiedColumns[':p' . $index++]  = '`created_at`';
1470:         }
1471:         if ($this->isColumnModified(CustomerPeer::UPDATED_AT)) {
1472:             $modifiedColumns[':p' . $index++]  = '`updated_at`';
1473:         }
1474: 
1475:         $sql = sprintf(
1476:             'INSERT INTO `customer` (%s) VALUES (%s)',
1477:             implode(', ', $modifiedColumns),
1478:             implode(', ', array_keys($modifiedColumns))
1479:         );
1480: 
1481:         try {
1482:             $stmt = $con->prepare($sql);
1483:             foreach ($modifiedColumns as $identifier => $columnName) {
1484:                 switch ($columnName) {
1485:                     case '`id`':
1486:                         $stmt->bindValue($identifier, $this->id, PDO::PARAM_INT);
1487:                         break;
1488:                     case '`ref`':
1489:                         $stmt->bindValue($identifier, $this->ref, PDO::PARAM_STR);
1490:                         break;
1491:                     case '`customer_title_id`':
1492:                         $stmt->bindValue($identifier, $this->customer_title_id, PDO::PARAM_INT);
1493:                         break;
1494:                     case '`company`':
1495:                         $stmt->bindValue($identifier, $this->company, PDO::PARAM_STR);
1496:                         break;
1497:                     case '`firstname`':
1498:                         $stmt->bindValue($identifier, $this->firstname, PDO::PARAM_STR);
1499:                         break;
1500:                     case '`lastname`':
1501:                         $stmt->bindValue($identifier, $this->lastname, PDO::PARAM_STR);
1502:                         break;
1503:                     case '`address1`':
1504:                         $stmt->bindValue($identifier, $this->address1, PDO::PARAM_STR);
1505:                         break;
1506:                     case '`address2`':
1507:                         $stmt->bindValue($identifier, $this->address2, PDO::PARAM_STR);
1508:                         break;
1509:                     case '`address3`':
1510:                         $stmt->bindValue($identifier, $this->address3, PDO::PARAM_STR);
1511:                         break;
1512:                     case '`zipcode`':
1513:                         $stmt->bindValue($identifier, $this->zipcode, PDO::PARAM_STR);
1514:                         break;
1515:                     case '`city`':
1516:                         $stmt->bindValue($identifier, $this->city, PDO::PARAM_STR);
1517:                         break;
1518:                     case '`country_id`':
1519:                         $stmt->bindValue($identifier, $this->country_id, PDO::PARAM_INT);
1520:                         break;
1521:                     case '`phone`':
1522:                         $stmt->bindValue($identifier, $this->phone, PDO::PARAM_STR);
1523:                         break;
1524:                     case '`cellphone`':
1525:                         $stmt->bindValue($identifier, $this->cellphone, PDO::PARAM_STR);
1526:                         break;
1527:                     case '`email`':
1528:                         $stmt->bindValue($identifier, $this->email, PDO::PARAM_STR);
1529:                         break;
1530:                     case '`password`':
1531:                         $stmt->bindValue($identifier, $this->password, PDO::PARAM_STR);
1532:                         break;
1533:                     case '`algo`':
1534:                         $stmt->bindValue($identifier, $this->algo, PDO::PARAM_STR);
1535:                         break;
1536:                     case '`salt`':
1537:                         $stmt->bindValue($identifier, $this->salt, PDO::PARAM_STR);
1538:                         break;
1539:                     case '`reseller`':
1540:                         $stmt->bindValue($identifier, $this->reseller, PDO::PARAM_INT);
1541:                         break;
1542:                     case '`lang`':
1543:                         $stmt->bindValue($identifier, $this->lang, PDO::PARAM_STR);
1544:                         break;
1545:                     case '`sponsor`':
1546:                         $stmt->bindValue($identifier, $this->sponsor, PDO::PARAM_STR);
1547:                         break;
1548:                     case '`discount`':
1549:                         $stmt->bindValue($identifier, $this->discount, PDO::PARAM_STR);
1550:                         break;
1551:                     case '`created_at`':
1552:                         $stmt->bindValue($identifier, $this->created_at, PDO::PARAM_STR);
1553:                         break;
1554:                     case '`updated_at`':
1555:                         $stmt->bindValue($identifier, $this->updated_at, PDO::PARAM_STR);
1556:                         break;
1557:                 }
1558:             }
1559:             $stmt->execute();
1560:         } catch (Exception $e) {
1561:             Propel::log($e->getMessage(), Propel::LOG_ERR);
1562:             throw new PropelException(sprintf('Unable to execute INSERT statement [%s]', $sql), $e);
1563:         }
1564: 
1565:         try {
1566:             $pk = $con->lastInsertId();
1567:         } catch (Exception $e) {
1568:             throw new PropelException('Unable to get autoincrement id.', $e);
1569:         }
1570:         $this->setId($pk);
1571: 
1572:         $this->setNew(false);
1573:     }
1574: 
1575:     /**
1576:      * Update the row in the database.
1577:      *
1578:      * @param PropelPDO $con
1579:      *
1580:      * @see        doSave()
1581:      */
1582:     protected function doUpdate(PropelPDO $con)
1583:     {
1584:         $selectCriteria = $this->buildPkeyCriteria();
1585:         $valuesCriteria = $this->buildCriteria();
1586:         BasePeer::doUpdate($selectCriteria, $valuesCriteria, $con);
1587:     }
1588: 
1589:     /**
1590:      * Array of ValidationFailed objects.
1591:      * @var        array ValidationFailed[]
1592:      */
1593:     protected $validationFailures = array();
1594: 
1595:     /**
1596:      * Gets any ValidationFailed objects that resulted from last call to validate().
1597:      *
1598:      *
1599:      * @return array ValidationFailed[]
1600:      * @see        validate()
1601:      */
1602:     public function getValidationFailures()
1603:     {
1604:         return $this->validationFailures;
1605:     }
1606: 
1607:     /**
1608:      * Validates the objects modified field values and all objects related to this table.
1609:      *
1610:      * If $columns is either a column name or an array of column names
1611:      * only those columns are validated.
1612:      *
1613:      * @param mixed $columns Column name or an array of column names.
1614:      * @return boolean Whether all columns pass validation.
1615:      * @see        doValidate()
1616:      * @see        getValidationFailures()
1617:      */
1618:     public function validate($columns = null)
1619:     {
1620:         $res = $this->doValidate($columns);
1621:         if ($res === true) {
1622:             $this->validationFailures = array();
1623: 
1624:             return true;
1625:         }
1626: 
1627:         $this->validationFailures = $res;
1628: 
1629:         return false;
1630:     }
1631: 
1632:     /**
1633:      * This function performs the validation work for complex object models.
1634:      *
1635:      * In addition to checking the current object, all related objects will
1636:      * also be validated.  If all pass then <code>true</code> is returned; otherwise
1637:      * an aggreagated array of ValidationFailed objects will be returned.
1638:      *
1639:      * @param array $columns Array of column names to validate.
1640:      * @return mixed <code>true</code> if all validations pass; array of <code>ValidationFailed</code> objets otherwise.
1641:      */
1642:     protected function doValidate($columns = null)
1643:     {
1644:         if (!$this->alreadyInValidation) {
1645:             $this->alreadyInValidation = true;
1646:             $retval = null;
1647: 
1648:             $failureMap = array();
1649: 
1650: 
1651:             // We call the validate method on the following object(s) if they
1652:             // were passed to this object by their coresponding set
1653:             // method.  This object relates to these object(s) by a
1654:             // foreign key reference.
1655: 
1656:             if ($this->aCustomerTitle !== null) {
1657:                 if (!$this->aCustomerTitle->validate($columns)) {
1658:                     $failureMap = array_merge($failureMap, $this->aCustomerTitle->getValidationFailures());
1659:                 }
1660:             }
1661: 
1662: 
1663:             if (($retval = CustomerPeer::doValidate($this, $columns)) !== true) {
1664:                 $failureMap = array_merge($failureMap, $retval);
1665:             }
1666: 
1667: 
1668:                 if ($this->collAddresss !== null) {
1669:                     foreach ($this->collAddresss as $referrerFK) {
1670:                         if (!$referrerFK->validate($columns)) {
1671:                             $failureMap = array_merge($failureMap, $referrerFK->getValidationFailures());
1672:                         }
1673:                     }
1674:                 }
1675: 
1676:                 if ($this->collOrders !== null) {
1677:                     foreach ($this->collOrders as $referrerFK) {
1678:                         if (!$referrerFK->validate($columns)) {
1679:                             $failureMap = array_merge($failureMap, $referrerFK->getValidationFailures());
1680:                         }
1681:                     }
1682:                 }
1683: 
1684: 
1685:             $this->alreadyInValidation = false;
1686:         }
1687: 
1688:         return (!empty($failureMap) ? $failureMap : true);
1689:     }
1690: 
1691:     /**
1692:      * Retrieves a field from the object by name passed in as a string.
1693:      *
1694:      * @param string $name name
1695:      * @param string $type The type of fieldname the $name is of:
1696:      *               one of the class type constants BasePeer::TYPE_PHPNAME, BasePeer::TYPE_STUDLYPHPNAME
1697:      *               BasePeer::TYPE_COLNAME, BasePeer::TYPE_FIELDNAME, BasePeer::TYPE_NUM.
1698:      *               Defaults to BasePeer::TYPE_PHPNAME
1699:      * @return mixed Value of field.
1700:      */
1701:     public function getByName($name, $type = BasePeer::TYPE_PHPNAME)
1702:     {
1703:         $pos = CustomerPeer::translateFieldName($name, $type, BasePeer::TYPE_NUM);
1704:         $field = $this->getByPosition($pos);
1705: 
1706:         return $field;
1707:     }
1708: 
1709:     /**
1710:      * Retrieves a field from the object by Position as specified in the xml schema.
1711:      * Zero-based.
1712:      *
1713:      * @param int $pos position in xml schema
1714:      * @return mixed Value of field at $pos
1715:      */
1716:     public function getByPosition($pos)
1717:     {
1718:         switch ($pos) {
1719:             case 0:
1720:                 return $this->getId();
1721:                 break;
1722:             case 1:
1723:                 return $this->getRef();
1724:                 break;
1725:             case 2:
1726:                 return $this->getCustomerTitleId();
1727:                 break;
1728:             case 3:
1729:                 return $this->getCompany();
1730:                 break;
1731:             case 4:
1732:                 return $this->getFirstname();
1733:                 break;
1734:             case 5:
1735:                 return $this->getLastname();
1736:                 break;
1737:             case 6:
1738:                 return $this->getAddress1();
1739:                 break;
1740:             case 7:
1741:                 return $this->getAddress2();
1742:                 break;
1743:             case 8:
1744:                 return $this->getAddress3();
1745:                 break;
1746:             case 9:
1747:                 return $this->getZipcode();
1748:                 break;
1749:             case 10:
1750:                 return $this->getCity();
1751:                 break;
1752:             case 11:
1753:                 return $this->getCountryId();
1754:                 break;
1755:             case 12:
1756:                 return $this->getPhone();
1757:                 break;
1758:             case 13:
1759:                 return $this->getCellphone();
1760:                 break;
1761:             case 14:
1762:                 return $this->getEmail();
1763:                 break;
1764:             case 15:
1765:                 return $this->getPassword();
1766:                 break;
1767:             case 16:
1768:                 return $this->getAlgo();
1769:                 break;
1770:             case 17:
1771:                 return $this->getSalt();
1772:                 break;
1773:             case 18:
1774:                 return $this->getReseller();
1775:                 break;
1776:             case 19:
1777:                 return $this->getLang();
1778:                 break;
1779:             case 20:
1780:                 return $this->getSponsor();
1781:                 break;
1782:             case 21:
1783:                 return $this->getDiscount();
1784:                 break;
1785:             case 22:
1786:                 return $this->getCreatedAt();
1787:                 break;
1788:             case 23:
1789:                 return $this->getUpdatedAt();
1790:                 break;
1791:             default:
1792:                 return null;
1793:                 break;
1794:         } // switch()
1795:     }
1796: 
1797:     /**
1798:      * Exports the object as an array.
1799:      *
1800:      * You can specify the key type of the array by passing one of the class
1801:      * type constants.
1802:      *
1803:      * @param     string  $keyType (optional) One of the class type constants BasePeer::TYPE_PHPNAME, BasePeer::TYPE_STUDLYPHPNAME,
1804:      *                    BasePeer::TYPE_COLNAME, BasePeer::TYPE_FIELDNAME, BasePeer::TYPE_NUM.
1805:      *                    Defaults to BasePeer::TYPE_PHPNAME.
1806:      * @param     boolean $includeLazyLoadColumns (optional) Whether to include lazy loaded columns. Defaults to true.
1807:      * @param     array $alreadyDumpedObjects List of objects to skip to avoid recursion
1808:      * @param     boolean $includeForeignObjects (optional) Whether to include hydrated related objects. Default to FALSE.
1809:      *
1810:      * @return array an associative array containing the field names (as keys) and field values
1811:      */
1812:     public function toArray($keyType = BasePeer::TYPE_PHPNAME, $includeLazyLoadColumns = true, $alreadyDumpedObjects = array(), $includeForeignObjects = false)
1813:     {
1814:         if (isset($alreadyDumpedObjects['Customer'][$this->getPrimaryKey()])) {
1815:             return '*RECURSION*';
1816:         }
1817:         $alreadyDumpedObjects['Customer'][$this->getPrimaryKey()] = true;
1818:         $keys = CustomerPeer::getFieldNames($keyType);
1819:         $result = array(
1820:             $keys[0] => $this->getId(),
1821:             $keys[1] => $this->getRef(),
1822:             $keys[2] => $this->getCustomerTitleId(),
1823:             $keys[3] => $this->getCompany(),
1824:             $keys[4] => $this->getFirstname(),
1825:             $keys[5] => $this->getLastname(),
1826:             $keys[6] => $this->getAddress1(),
1827:             $keys[7] => $this->getAddress2(),
1828:             $keys[8] => $this->getAddress3(),
1829:             $keys[9] => $this->getZipcode(),
1830:             $keys[10] => $this->getCity(),
1831:             $keys[11] => $this->getCountryId(),
1832:             $keys[12] => $this->getPhone(),
1833:             $keys[13] => $this->getCellphone(),
1834:             $keys[14] => $this->getEmail(),
1835:             $keys[15] => $this->getPassword(),
1836:             $keys[16] => $this->getAlgo(),
1837:             $keys[17] => $this->getSalt(),
1838:             $keys[18] => $this->getReseller(),
1839:             $keys[19] => $this->getLang(),
1840:             $keys[20] => $this->getSponsor(),
1841:             $keys[21] => $this->getDiscount(),
1842:             $keys[22] => $this->getCreatedAt(),
1843:             $keys[23] => $this->getUpdatedAt(),
1844:         );
1845:         if ($includeForeignObjects) {
1846:             if (null !== $this->aCustomerTitle) {
1847:                 $result['CustomerTitle'] = $this->aCustomerTitle->toArray($keyType, $includeLazyLoadColumns,  $alreadyDumpedObjects, true);
1848:             }
1849:             if (null !== $this->collAddresss) {
1850:                 $result['Addresss'] = $this->collAddresss->toArray(null, true, $keyType, $includeLazyLoadColumns, $alreadyDumpedObjects);
1851:             }
1852:             if (null !== $this->collOrders) {
1853:                 $result['Orders'] = $this->collOrders->toArray(null, true, $keyType, $includeLazyLoadColumns, $alreadyDumpedObjects);
1854:             }
1855:         }
1856: 
1857:         return $result;
1858:     }
1859: 
1860:     /**
1861:      * Sets a field from the object by name passed in as a string.
1862:      *
1863:      * @param string $name peer name
1864:      * @param mixed $value field value
1865:      * @param string $type The type of fieldname the $name is of:
1866:      *                     one of the class type constants BasePeer::TYPE_PHPNAME, BasePeer::TYPE_STUDLYPHPNAME
1867:      *                     BasePeer::TYPE_COLNAME, BasePeer::TYPE_FIELDNAME, BasePeer::TYPE_NUM.
1868:      *                     Defaults to BasePeer::TYPE_PHPNAME
1869:      * @return void
1870:      */
1871:     public function setByName($name, $value, $type = BasePeer::TYPE_PHPNAME)
1872:     {
1873:         $pos = CustomerPeer::translateFieldName($name, $type, BasePeer::TYPE_NUM);
1874: 
1875:         $this->setByPosition($pos, $value);
1876:     }
1877: 
1878:     /**
1879:      * Sets a field from the object by Position as specified in the xml schema.
1880:      * Zero-based.
1881:      *
1882:      * @param int $pos position in xml schema
1883:      * @param mixed $value field value
1884:      * @return void
1885:      */
1886:     public function setByPosition($pos, $value)
1887:     {
1888:         switch ($pos) {
1889:             case 0:
1890:                 $this->setId($value);
1891:                 break;
1892:             case 1:
1893:                 $this->setRef($value);
1894:                 break;
1895:             case 2:
1896:                 $this->setCustomerTitleId($value);
1897:                 break;
1898:             case 3:
1899:                 $this->setCompany($value);
1900:                 break;
1901:             case 4:
1902:                 $this->setFirstname($value);
1903:                 break;
1904:             case 5:
1905:                 $this->setLastname($value);
1906:                 break;
1907:             case 6:
1908:                 $this->setAddress1($value);
1909:                 break;
1910:             case 7:
1911:                 $this->setAddress2($value);
1912:                 break;
1913:             case 8:
1914:                 $this->setAddress3($value);
1915:                 break;
1916:             case 9:
1917:                 $this->setZipcode($value);
1918:                 break;
1919:             case 10:
1920:                 $this->setCity($value);
1921:                 break;
1922:             case 11:
1923:                 $this->setCountryId($value);
1924:                 break;
1925:             case 12:
1926:                 $this->setPhone($value);
1927:                 break;
1928:             case 13:
1929:                 $this->setCellphone($value);
1930:                 break;
1931:             case 14:
1932:                 $this->setEmail($value);
1933:                 break;
1934:             case 15:
1935:                 $this->setPassword($value);
1936:                 break;
1937:             case 16:
1938:                 $this->setAlgo($value);
1939:                 break;
1940:             case 17:
1941:                 $this->setSalt($value);
1942:                 break;
1943:             case 18:
1944:                 $this->setReseller($value);
1945:                 break;
1946:             case 19:
1947:                 $this->setLang($value);
1948:                 break;
1949:             case 20:
1950:                 $this->setSponsor($value);
1951:                 break;
1952:             case 21:
1953:                 $this->setDiscount($value);
1954:                 break;
1955:             case 22:
1956:                 $this->setCreatedAt($value);
1957:                 break;
1958:             case 23:
1959:                 $this->setUpdatedAt($value);
1960:                 break;
1961:         } // switch()
1962:     }
1963: 
1964:     /**
1965:      * Populates the object using an array.
1966:      *
1967:      * This is particularly useful when populating an object from one of the
1968:      * request arrays (e.g. $_POST).  This method goes through the column
1969:      * names, checking to see whether a matching key exists in populated
1970:      * array. If so the setByName() method is called for that column.
1971:      *
1972:      * You can specify the key type of the array by additionally passing one
1973:      * of the class type constants BasePeer::TYPE_PHPNAME, BasePeer::TYPE_STUDLYPHPNAME,
1974:      * BasePeer::TYPE_COLNAME, BasePeer::TYPE_FIELDNAME, BasePeer::TYPE_NUM.
1975:      * The default key type is the column's BasePeer::TYPE_PHPNAME
1976:      *
1977:      * @param array  $arr     An array to populate the object from.
1978:      * @param string $keyType The type of keys the array uses.
1979:      * @return void
1980:      */
1981:     public function fromArray($arr, $keyType = BasePeer::TYPE_PHPNAME)
1982:     {
1983:         $keys = CustomerPeer::getFieldNames($keyType);
1984: 
1985:         if (array_key_exists($keys[0], $arr)) $this->setId($arr[$keys[0]]);
1986:         if (array_key_exists($keys[1], $arr)) $this->setRef($arr[$keys[1]]);
1987:         if (array_key_exists($keys[2], $arr)) $this->setCustomerTitleId($arr[$keys[2]]);
1988:         if (array_key_exists($keys[3], $arr)) $this->setCompany($arr[$keys[3]]);
1989:         if (array_key_exists($keys[4], $arr)) $this->setFirstname($arr[$keys[4]]);
1990:         if (array_key_exists($keys[5], $arr)) $this->setLastname($arr[$keys[5]]);
1991:         if (array_key_exists($keys[6], $arr)) $this->setAddress1($arr[$keys[6]]);
1992:         if (array_key_exists($keys[7], $arr)) $this->setAddress2($arr[$keys[7]]);
1993:         if (array_key_exists($keys[8], $arr)) $this->setAddress3($arr[$keys[8]]);
1994:         if (array_key_exists($keys[9], $arr)) $this->setZipcode($arr[$keys[9]]);
1995:         if (array_key_exists($keys[10], $arr)) $this->setCity($arr[$keys[10]]);
1996:         if (array_key_exists($keys[11], $arr)) $this->setCountryId($arr[$keys[11]]);
1997:         if (array_key_exists($keys[12], $arr)) $this->setPhone($arr[$keys[12]]);
1998:         if (array_key_exists($keys[13], $arr)) $this->setCellphone($arr[$keys[13]]);
1999:         if (array_key_exists($keys[14], $arr)) $this->setEmail($arr[$keys[14]]);
2000:         if (array_key_exists($keys[15], $arr)) $this->setPassword($arr[$keys[15]]);
2001:         if (array_key_exists($keys[16], $arr)) $this->setAlgo($arr[$keys[16]]);
2002:         if (array_key_exists($keys[17], $arr)) $this->setSalt($arr[$keys[17]]);
2003:         if (array_key_exists($keys[18], $arr)) $this->setReseller($arr[$keys[18]]);
2004:         if (array_key_exists($keys[19], $arr)) $this->setLang($arr[$keys[19]]);
2005:         if (array_key_exists($keys[20], $arr)) $this->setSponsor($arr[$keys[20]]);
2006:         if (array_key_exists($keys[21], $arr)) $this->setDiscount($arr[$keys[21]]);
2007:         if (array_key_exists($keys[22], $arr)) $this->setCreatedAt($arr[$keys[22]]);
2008:         if (array_key_exists($keys[23], $arr)) $this->setUpdatedAt($arr[$keys[23]]);
2009:     }
2010: 
2011:     /**
2012:      * Build a Criteria object containing the values of all modified columns in this object.
2013:      *
2014:      * @return Criteria The Criteria object containing all modified values.
2015:      */
2016:     public function buildCriteria()
2017:     {
2018:         $criteria = new Criteria(CustomerPeer::DATABASE_NAME);
2019: 
2020:         if ($this->isColumnModified(CustomerPeer::ID)) $criteria->add(CustomerPeer::ID, $this->id);
2021:         if ($this->isColumnModified(CustomerPeer::REF)) $criteria->add(CustomerPeer::REF, $this->ref);
2022:         if ($this->isColumnModified(CustomerPeer::CUSTOMER_TITLE_ID)) $criteria->add(CustomerPeer::CUSTOMER_TITLE_ID, $this->customer_title_id);
2023:         if ($this->isColumnModified(CustomerPeer::COMPANY)) $criteria->add(CustomerPeer::COMPANY, $this->company);
2024:         if ($this->isColumnModified(CustomerPeer::FIRSTNAME)) $criteria->add(CustomerPeer::FIRSTNAME, $this->firstname);
2025:         if ($this->isColumnModified(CustomerPeer::LASTNAME)) $criteria->add(CustomerPeer::LASTNAME, $this->lastname);
2026:         if ($this->isColumnModified(CustomerPeer::ADDRESS1)) $criteria->add(CustomerPeer::ADDRESS1, $this->address1);
2027:         if ($this->isColumnModified(CustomerPeer::ADDRESS2)) $criteria->add(CustomerPeer::ADDRESS2, $this->address2);
2028:         if ($this->isColumnModified(CustomerPeer::ADDRESS3)) $criteria->add(CustomerPeer::ADDRESS3, $this->address3);
2029:         if ($this->isColumnModified(CustomerPeer::ZIPCODE)) $criteria->add(CustomerPeer::ZIPCODE, $this->zipcode);
2030:         if ($this->isColumnModified(CustomerPeer::CITY)) $criteria->add(CustomerPeer::CITY, $this->city);
2031:         if ($this->isColumnModified(CustomerPeer::COUNTRY_ID)) $criteria->add(CustomerPeer::COUNTRY_ID, $this->country_id);
2032:         if ($this->isColumnModified(CustomerPeer::PHONE)) $criteria->add(CustomerPeer::PHONE, $this->phone);
2033:         if ($this->isColumnModified(CustomerPeer::CELLPHONE)) $criteria->add(CustomerPeer::CELLPHONE, $this->cellphone);
2034:         if ($this->isColumnModified(CustomerPeer::EMAIL)) $criteria->add(CustomerPeer::EMAIL, $this->email);
2035:         if ($this->isColumnModified(CustomerPeer::PASSWORD)) $criteria->add(CustomerPeer::PASSWORD, $this->password);
2036:         if ($this->isColumnModified(CustomerPeer::ALGO)) $criteria->add(CustomerPeer::ALGO, $this->algo);
2037:         if ($this->isColumnModified(CustomerPeer::SALT)) $criteria->add(CustomerPeer::SALT, $this->salt);
2038:         if ($this->isColumnModified(CustomerPeer::RESELLER)) $criteria->add(CustomerPeer::RESELLER, $this->reseller);
2039:         if ($this->isColumnModified(CustomerPeer::LANG)) $criteria->add(CustomerPeer::LANG, $this->lang);
2040:         if ($this->isColumnModified(CustomerPeer::SPONSOR)) $criteria->add(CustomerPeer::SPONSOR, $this->sponsor);
2041:         if ($this->isColumnModified(CustomerPeer::DISCOUNT)) $criteria->add(CustomerPeer::DISCOUNT, $this->discount);
2042:         if ($this->isColumnModified(CustomerPeer::CREATED_AT)) $criteria->add(CustomerPeer::CREATED_AT, $this->created_at);
2043:         if ($this->isColumnModified(CustomerPeer::UPDATED_AT)) $criteria->add(CustomerPeer::UPDATED_AT, $this->updated_at);
2044: 
2045:         return $criteria;
2046:     }
2047: 
2048:     /**
2049:      * Builds a Criteria object containing the primary key for this object.
2050:      *
2051:      * Unlike buildCriteria() this method includes the primary key values regardless
2052:      * of whether or not they have been modified.
2053:      *
2054:      * @return Criteria The Criteria object containing value(s) for primary key(s).
2055:      */
2056:     public function buildPkeyCriteria()
2057:     {
2058:         $criteria = new Criteria(CustomerPeer::DATABASE_NAME);
2059:         $criteria->add(CustomerPeer::ID, $this->id);
2060: 
2061:         return $criteria;
2062:     }
2063: 
2064:     /**
2065:      * Returns the primary key for this object (row).
2066:      * @return int
2067:      */
2068:     public function getPrimaryKey()
2069:     {
2070:         return $this->getId();
2071:     }
2072: 
2073:     /**
2074:      * Generic method to set the primary key (id column).
2075:      *
2076:      * @param  int $key Primary key.
2077:      * @return void
2078:      */
2079:     public function setPrimaryKey($key)
2080:     {
2081:         $this->setId($key);
2082:     }
2083: 
2084:     /**
2085:      * Returns true if the primary key for this object is null.
2086:      * @return boolean
2087:      */
2088:     public function isPrimaryKeyNull()
2089:     {
2090: 
2091:         return null === $this->getId();
2092:     }
2093: 
2094:     /**
2095:      * Sets contents of passed object to values from current object.
2096:      *
2097:      * If desired, this method can also make copies of all associated (fkey referrers)
2098:      * objects.
2099:      *
2100:      * @param object $copyObj An object of Customer (or compatible) type.
2101:      * @param boolean $deepCopy Whether to also copy all rows that refer (by fkey) to the current row.
2102:      * @param boolean $makeNew Whether to reset autoincrement PKs and make the object new.
2103:      * @throws PropelException
2104:      */
2105:     public function copyInto($copyObj, $deepCopy = false, $makeNew = true)
2106:     {
2107:         $copyObj->setRef($this->getRef());
2108:         $copyObj->setCustomerTitleId($this->getCustomerTitleId());
2109:         $copyObj->setCompany($this->getCompany());
2110:         $copyObj->setFirstname($this->getFirstname());
2111:         $copyObj->setLastname($this->getLastname());
2112:         $copyObj->setAddress1($this->getAddress1());
2113:         $copyObj->setAddress2($this->getAddress2());
2114:         $copyObj->setAddress3($this->getAddress3());
2115:         $copyObj->setZipcode($this->getZipcode());
2116:         $copyObj->setCity($this->getCity());
2117:         $copyObj->setCountryId($this->getCountryId());
2118:         $copyObj->setPhone($this->getPhone());
2119:         $copyObj->setCellphone($this->getCellphone());
2120:         $copyObj->setEmail($this->getEmail());
2121:         $copyObj->setPassword($this->getPassword());
2122:         $copyObj->setAlgo($this->getAlgo());
2123:         $copyObj->setSalt($this->getSalt());
2124:         $copyObj->setReseller($this->getReseller());
2125:         $copyObj->setLang($this->getLang());
2126:         $copyObj->setSponsor($this->getSponsor());
2127:         $copyObj->setDiscount($this->getDiscount());
2128:         $copyObj->setCreatedAt($this->getCreatedAt());
2129:         $copyObj->setUpdatedAt($this->getUpdatedAt());
2130: 
2131:         if ($deepCopy && !$this->startCopy) {
2132:             // important: temporarily setNew(false) because this affects the behavior of
2133:             // the getter/setter methods for fkey referrer objects.
2134:             $copyObj->setNew(false);
2135:             // store object hash to prevent cycle
2136:             $this->startCopy = true;
2137: 
2138:             foreach ($this->getAddresss() as $relObj) {
2139:                 if ($relObj !== $this) {  // ensure that we don't try to copy a reference to ourselves
2140:                     $copyObj->addAddress($relObj->copy($deepCopy));
2141:                 }
2142:             }
2143: 
2144:             foreach ($this->getOrders() as $relObj) {
2145:                 if ($relObj !== $this) {  // ensure that we don't try to copy a reference to ourselves
2146:                     $copyObj->addOrder($relObj->copy($deepCopy));
2147:                 }
2148:             }
2149: 
2150:             //unflag object copy
2151:             $this->startCopy = false;
2152:         } // if ($deepCopy)
2153: 
2154:         if ($makeNew) {
2155:             $copyObj->setNew(true);
2156:             $copyObj->setId(NULL); // this is a auto-increment column, so set to default value
2157:         }
2158:     }
2159: 
2160:     /**
2161:      * Makes a copy of this object that will be inserted as a new row in table when saved.
2162:      * It creates a new object filling in the simple attributes, but skipping any primary
2163:      * keys that are defined for the table.
2164:      *
2165:      * If desired, this method can also make copies of all associated (fkey referrers)
2166:      * objects.
2167:      *
2168:      * @param boolean $deepCopy Whether to also copy all rows that refer (by fkey) to the current row.
2169:      * @return Customer Clone of current object.
2170:      * @throws PropelException
2171:      */
2172:     public function copy($deepCopy = false)
2173:     {
2174:         // we use get_class(), because this might be a subclass
2175:         $clazz = get_class($this);
2176:         $copyObj = new $clazz();
2177:         $this->copyInto($copyObj, $deepCopy);
2178: 
2179:         return $copyObj;
2180:     }
2181: 
2182:     /**
2183:      * Returns a peer instance associated with this om.
2184:      *
2185:      * Since Peer classes are not to have any instance attributes, this method returns the
2186:      * same instance for all member of this class. The method could therefore
2187:      * be static, but this would prevent one from overriding the behavior.
2188:      *
2189:      * @return CustomerPeer
2190:      */
2191:     public function getPeer()
2192:     {
2193:         if (self::$peer === null) {
2194:             self::$peer = new CustomerPeer();
2195:         }
2196: 
2197:         return self::$peer;
2198:     }
2199: 
2200:     /**
2201:      * Declares an association between this object and a CustomerTitle object.
2202:      *
2203:      * @param             CustomerTitle $v
2204:      * @return Customer The current object (for fluent API support)
2205:      * @throws PropelException
2206:      */
2207:     public function setCustomerTitle(CustomerTitle $v = null)
2208:     {
2209:         if ($v === null) {
2210:             $this->setCustomerTitleId(NULL);
2211:         } else {
2212:             $this->setCustomerTitleId($v->getId());
2213:         }
2214: 
2215:         $this->aCustomerTitle = $v;
2216: 
2217:         // Add binding for other direction of this n:n relationship.
2218:         // If this object has already been added to the CustomerTitle object, it will not be re-added.
2219:         if ($v !== null) {
2220:             $v->addCustomer($this);
2221:         }
2222: 
2223: 
2224:         return $this;
2225:     }
2226: 
2227: 
2228:     /**
2229:      * Get the associated CustomerTitle object
2230:      *
2231:      * @param PropelPDO $con Optional Connection object.
2232:      * @param $doQuery Executes a query to get the object if required
2233:      * @return CustomerTitle The associated CustomerTitle object.
2234:      * @throws PropelException
2235:      */
2236:     public function getCustomerTitle(PropelPDO $con = null, $doQuery = true)
2237:     {
2238:         if ($this->aCustomerTitle === null && ($this->customer_title_id !== null) && $doQuery) {
2239:             $this->aCustomerTitle = CustomerTitleQuery::create()->findPk($this->customer_title_id, $con);
2240:             /* The following can be used additionally to
2241:                 guarantee the related object contains a reference
2242:                 to this object.  This level of coupling may, however, be
2243:                 undesirable since it could result in an only partially populated collection
2244:                 in the referenced object.
2245:                 $this->aCustomerTitle->addCustomers($this);
2246:              */
2247:         }
2248: 
2249:         return $this->aCustomerTitle;
2250:     }
2251: 
2252: 
2253:     /**
2254:      * Initializes a collection based on the name of a relation.
2255:      * Avoids crafting an 'init[$relationName]s' method name
2256:      * that wouldn't work when StandardEnglishPluralizer is used.
2257:      *
2258:      * @param string $relationName The name of the relation to initialize
2259:      * @return void
2260:      */
2261:     public function initRelation($relationName)
2262:     {
2263:         if ('Address' == $relationName) {
2264:             $this->initAddresss();
2265:         }
2266:         if ('Order' == $relationName) {
2267:             $this->initOrders();
2268:         }
2269:     }
2270: 
2271:     /**
2272:      * Clears out the collAddresss collection
2273:      *
2274:      * This does not modify the database; however, it will remove any associated objects, causing
2275:      * them to be refetched by subsequent calls to accessor method.
2276:      *
2277:      * @return Customer The current object (for fluent API support)
2278:      * @see        addAddresss()
2279:      */
2280:     public function clearAddresss()
2281:     {
2282:         $this->collAddresss = null; // important to set this to null since that means it is uninitialized
2283:         $this->collAddresssPartial = null;
2284: 
2285:         return $this;
2286:     }
2287: 
2288:     /**
2289:      * reset is the collAddresss collection loaded partially
2290:      *
2291:      * @return void
2292:      */
2293:     public function resetPartialAddresss($v = true)
2294:     {
2295:         $this->collAddresssPartial = $v;
2296:     }
2297: 
2298:     /**
2299:      * Initializes the collAddresss collection.
2300:      *
2301:      * By default this just sets the collAddresss collection to an empty array (like clearcollAddresss());
2302:      * however, you may wish to override this method in your stub class to provide setting appropriate
2303:      * to your application -- for example, setting the initial array to the values stored in database.
2304:      *
2305:      * @param boolean $overrideExisting If set to true, the method call initializes
2306:      *                                        the collection even if it is not empty
2307:      *
2308:      * @return void
2309:      */
2310:     public function initAddresss($overrideExisting = true)
2311:     {
2312:         if (null !== $this->collAddresss && !$overrideExisting) {
2313:             return;
2314:         }
2315:         $this->collAddresss = new PropelObjectCollection();
2316:         $this->collAddresss->setModel('Address');
2317:     }
2318: 
2319:     /**
2320:      * Gets an array of Address objects which contain a foreign key that references this object.
2321:      *
2322:      * If the $criteria is not null, it is used to always fetch the results from the database.
2323:      * Otherwise the results are fetched from the database the first time, then cached.
2324:      * Next time the same method is called without $criteria, the cached collection is returned.
2325:      * If this Customer is new, it will return
2326:      * an empty collection or the current collection; the criteria is ignored on a new object.
2327:      *
2328:      * @param Criteria $criteria optional Criteria object to narrow the query
2329:      * @param PropelPDO $con optional connection object
2330:      * @return PropelObjectCollection|Address[] List of Address objects
2331:      * @throws PropelException
2332:      */
2333:     public function getAddresss($criteria = null, PropelPDO $con = null)
2334:     {
2335:         $partial = $this->collAddresssPartial && !$this->isNew();
2336:         if (null === $this->collAddresss || null !== $criteria  || $partial) {
2337:             if ($this->isNew() && null === $this->collAddresss) {
2338:                 // return empty collection
2339:                 $this->initAddresss();
2340:             } else {
2341:                 $collAddresss = AddressQuery::create(null, $criteria)
2342:                     ->filterByCustomer($this)
2343:                     ->find($con);
2344:                 if (null !== $criteria) {
2345:                     if (false !== $this->collAddresssPartial && count($collAddresss)) {
2346:                       $this->initAddresss(false);
2347: 
2348:                       foreach($collAddresss as $obj) {
2349:                         if (false == $this->collAddresss->contains($obj)) {
2350:                           $this->collAddresss->append($obj);
2351:                         }
2352:                       }
2353: 
2354:                       $this->collAddresssPartial = true;
2355:                     }
2356: 
2357:                     $collAddresss->getInternalIterator()->rewind();
2358:                     return $collAddresss;
2359:                 }
2360: 
2361:                 if($partial && $this->collAddresss) {
2362:                     foreach($this->collAddresss as $obj) {
2363:                         if($obj->isNew()) {
2364:                             $collAddresss[] = $obj;
2365:                         }
2366:                     }
2367:                 }
2368: 
2369:                 $this->collAddresss = $collAddresss;
2370:                 $this->collAddresssPartial = false;
2371:             }
2372:         }
2373: 
2374:         return $this->collAddresss;
2375:     }
2376: 
2377:     /**
2378:      * Sets a collection of Address objects related by a one-to-many relationship
2379:      * to the current object.
2380:      * It will also schedule objects for deletion based on a diff between old objects (aka persisted)
2381:      * and new objects from the given Propel collection.
2382:      *
2383:      * @param PropelCollection $addresss A Propel collection.
2384:      * @param PropelPDO $con Optional connection object
2385:      * @return Customer The current object (for fluent API support)
2386:      */
2387:     public function setAddresss(PropelCollection $addresss, PropelPDO $con = null)
2388:     {
2389:         $addresssToDelete = $this->getAddresss(new Criteria(), $con)->diff($addresss);
2390: 
2391:         $this->addresssScheduledForDeletion = unserialize(serialize($addresssToDelete));
2392: 
2393:         foreach ($addresssToDelete as $addressRemoved) {
2394:             $addressRemoved->setCustomer(null);
2395:         }
2396: 
2397:         $this->collAddresss = null;
2398:         foreach ($addresss as $address) {
2399:             $this->addAddress($address);
2400:         }
2401: 
2402:         $this->collAddresss = $addresss;
2403:         $this->collAddresssPartial = false;
2404: 
2405:         return $this;
2406:     }
2407: 
2408:     /**
2409:      * Returns the number of related Address objects.
2410:      *
2411:      * @param Criteria $criteria
2412:      * @param boolean $distinct
2413:      * @param PropelPDO $con
2414:      * @return int             Count of related Address objects.
2415:      * @throws PropelException
2416:      */
2417:     public function countAddresss(Criteria $criteria = null, $distinct = false, PropelPDO $con = null)
2418:     {
2419:         $partial = $this->collAddresssPartial && !$this->isNew();
2420:         if (null === $this->collAddresss || null !== $criteria || $partial) {
2421:             if ($this->isNew() && null === $this->collAddresss) {
2422:                 return 0;
2423:             }
2424: 
2425:             if($partial && !$criteria) {
2426:                 return count($this->getAddresss());
2427:             }
2428:             $query = AddressQuery::create(null, $criteria);
2429:             if ($distinct) {
2430:                 $query->distinct();
2431:             }
2432: 
2433:             return $query
2434:                 ->filterByCustomer($this)
2435:                 ->count($con);
2436:         }
2437: 
2438:         return count($this->collAddresss);
2439:     }
2440: 
2441:     /**
2442:      * Method called to associate a Address object to this object
2443:      * through the Address foreign key attribute.
2444:      *
2445:      * @param    Address $l Address
2446:      * @return Customer The current object (for fluent API support)
2447:      */
2448:     public function addAddress(Address $l)
2449:     {
2450:         if ($this->collAddresss === null) {
2451:             $this->initAddresss();
2452:             $this->collAddresssPartial = true;
2453:         }
2454:         if (!in_array($l, $this->collAddresss->getArrayCopy(), true)) { // only add it if the **same** object is not already associated
2455:             $this->doAddAddress($l);
2456:         }
2457: 
2458:         return $this;
2459:     }
2460: 
2461:     /**
2462:      * @param   Address $address The address object to add.
2463:      */
2464:     protected function doAddAddress($address)
2465:     {
2466:         $this->collAddresss[]= $address;
2467:         $address->setCustomer($this);
2468:     }
2469: 
2470:     /**
2471:      * @param   Address $address The address object to remove.
2472:      * @return Customer The current object (for fluent API support)
2473:      */
2474:     public function removeAddress($address)
2475:     {
2476:         if ($this->getAddresss()->contains($address)) {
2477:             $this->collAddresss->remove($this->collAddresss->search($address));
2478:             if (null === $this->addresssScheduledForDeletion) {
2479:                 $this->addresssScheduledForDeletion = clone $this->collAddresss;
2480:                 $this->addresssScheduledForDeletion->clear();
2481:             }
2482:             $this->addresssScheduledForDeletion[]= clone $address;
2483:             $address->setCustomer(null);
2484:         }
2485: 
2486:         return $this;
2487:     }
2488: 
2489: 
2490:     /**
2491:      * If this collection has already been initialized with
2492:      * an identical criteria, it returns the collection.
2493:      * Otherwise if this Customer is new, it will return
2494:      * an empty collection; or if this Customer has previously
2495:      * been saved, it will retrieve related Addresss from storage.
2496:      *
2497:      * This method is protected by default in order to keep the public
2498:      * api reasonable.  You can provide public methods for those you
2499:      * actually need in Customer.
2500:      *
2501:      * @param Criteria $criteria optional Criteria object to narrow the query
2502:      * @param PropelPDO $con optional connection object
2503:      * @param string $join_behavior optional join type to use (defaults to Criteria::LEFT_JOIN)
2504:      * @return PropelObjectCollection|Address[] List of Address objects
2505:      */
2506:     public function getAddresssJoinCustomerTitle($criteria = null, $con = null, $join_behavior = Criteria::LEFT_JOIN)
2507:     {
2508:         $query = AddressQuery::create(null, $criteria);
2509:         $query->joinWith('CustomerTitle', $join_behavior);
2510: 
2511:         return $this->getAddresss($query, $con);
2512:     }
2513: 
2514:     /**
2515:      * Clears out the collOrders collection
2516:      *
2517:      * This does not modify the database; however, it will remove any associated objects, causing
2518:      * them to be refetched by subsequent calls to accessor method.
2519:      *
2520:      * @return Customer The current object (for fluent API support)
2521:      * @see        addOrders()
2522:      */
2523:     public function clearOrders()
2524:     {
2525:         $this->collOrders = null; // important to set this to null since that means it is uninitialized
2526:         $this->collOrdersPartial = null;
2527: 
2528:         return $this;
2529:     }
2530: 
2531:     /**
2532:      * reset is the collOrders collection loaded partially
2533:      *
2534:      * @return void
2535:      */
2536:     public function resetPartialOrders($v = true)
2537:     {
2538:         $this->collOrdersPartial = $v;
2539:     }
2540: 
2541:     /**
2542:      * Initializes the collOrders collection.
2543:      *
2544:      * By default this just sets the collOrders collection to an empty array (like clearcollOrders());
2545:      * however, you may wish to override this method in your stub class to provide setting appropriate
2546:      * to your application -- for example, setting the initial array to the values stored in database.
2547:      *
2548:      * @param boolean $overrideExisting If set to true, the method call initializes
2549:      *                                        the collection even if it is not empty
2550:      *
2551:      * @return void
2552:      */
2553:     public function initOrders($overrideExisting = true)
2554:     {
2555:         if (null !== $this->collOrders && !$overrideExisting) {
2556:             return;
2557:         }
2558:         $this->collOrders = new PropelObjectCollection();
2559:         $this->collOrders->setModel('Order');
2560:     }
2561: 
2562:     /**
2563:      * Gets an array of Order objects which contain a foreign key that references this object.
2564:      *
2565:      * If the $criteria is not null, it is used to always fetch the results from the database.
2566:      * Otherwise the results are fetched from the database the first time, then cached.
2567:      * Next time the same method is called without $criteria, the cached collection is returned.
2568:      * If this Customer is new, it will return
2569:      * an empty collection or the current collection; the criteria is ignored on a new object.
2570:      *
2571:      * @param Criteria $criteria optional Criteria object to narrow the query
2572:      * @param PropelPDO $con optional connection object
2573:      * @return PropelObjectCollection|Order[] List of Order objects
2574:      * @throws PropelException
2575:      */
2576:     public function getOrders($criteria = null, PropelPDO $con = null)
2577:     {
2578:         $partial = $this->collOrdersPartial && !$this->isNew();
2579:         if (null === $this->collOrders || null !== $criteria  || $partial) {
2580:             if ($this->isNew() && null === $this->collOrders) {
2581:                 // return empty collection
2582:                 $this->initOrders();
2583:             } else {
2584:                 $collOrders = OrderQuery::create(null, $criteria)
2585:                     ->filterByCustomer($this)
2586:                     ->find($con);
2587:                 if (null !== $criteria) {
2588:                     if (false !== $this->collOrdersPartial && count($collOrders)) {
2589:                       $this->initOrders(false);
2590: 
2591:                       foreach($collOrders as $obj) {
2592:                         if (false == $this->collOrders->contains($obj)) {
2593:                           $this->collOrders->append($obj);
2594:                         }
2595:                       }
2596: 
2597:                       $this->collOrdersPartial = true;
2598:                     }
2599: 
2600:                     $collOrders->getInternalIterator()->rewind();
2601:                     return $collOrders;
2602:                 }
2603: 
2604:                 if($partial && $this->collOrders) {
2605:                     foreach($this->collOrders as $obj) {
2606:                         if($obj->isNew()) {
2607:                             $collOrders[] = $obj;
2608:                         }
2609:                     }
2610:                 }
2611: 
2612:                 $this->collOrders = $collOrders;
2613:                 $this->collOrdersPartial = false;
2614:             }
2615:         }
2616: 
2617:         return $this->collOrders;
2618:     }
2619: 
2620:     /**
2621:      * Sets a collection of Order objects related by a one-to-many relationship
2622:      * to the current object.
2623:      * It will also schedule objects for deletion based on a diff between old objects (aka persisted)
2624:      * and new objects from the given Propel collection.
2625:      *
2626:      * @param PropelCollection $orders A Propel collection.
2627:      * @param PropelPDO $con Optional connection object
2628:      * @return Customer The current object (for fluent API support)
2629:      */
2630:     public function setOrders(PropelCollection $orders, PropelPDO $con = null)
2631:     {
2632:         $ordersToDelete = $this->getOrders(new Criteria(), $con)->diff($orders);
2633: 
2634:         $this->ordersScheduledForDeletion = unserialize(serialize($ordersToDelete));
2635: 
2636:         foreach ($ordersToDelete as $orderRemoved) {
2637:             $orderRemoved->setCustomer(null);
2638:         }
2639: 
2640:         $this->collOrders = null;
2641:         foreach ($orders as $order) {
2642:             $this->addOrder($order);
2643:         }
2644: 
2645:         $this->collOrders = $orders;
2646:         $this->collOrdersPartial = false;
2647: 
2648:         return $this;
2649:     }
2650: 
2651:     /**
2652:      * Returns the number of related Order objects.
2653:      *
2654:      * @param Criteria $criteria
2655:      * @param boolean $distinct
2656:      * @param PropelPDO $con
2657:      * @return int             Count of related Order objects.
2658:      * @throws PropelException
2659:      */
2660:     public function countOrders(Criteria $criteria = null, $distinct = false, PropelPDO $con = null)
2661:     {
2662:         $partial = $this->collOrdersPartial && !$this->isNew();
2663:         if (null === $this->collOrders || null !== $criteria || $partial) {
2664:             if ($this->isNew() && null === $this->collOrders) {
2665:                 return 0;
2666:             }
2667: 
2668:             if($partial && !$criteria) {
2669:                 return count($this->getOrders());
2670:             }
2671:             $query = OrderQuery::create(null, $criteria);
2672:             if ($distinct) {
2673:                 $query->distinct();
2674:             }
2675: 
2676:             return $query
2677:                 ->filterByCustomer($this)
2678:                 ->count($con);
2679:         }
2680: 
2681:         return count($this->collOrders);
2682:     }
2683: 
2684:     /**
2685:      * Method called to associate a Order object to this object
2686:      * through the Order foreign key attribute.
2687:      *
2688:      * @param    Order $l Order
2689:      * @return Customer The current object (for fluent API support)
2690:      */
2691:     public function addOrder(Order $l)
2692:     {
2693:         if ($this->collOrders === null) {
2694:             $this->initOrders();
2695:             $this->collOrdersPartial = true;
2696:         }
2697:         if (!in_array($l, $this->collOrders->getArrayCopy(), true)) { // only add it if the **same** object is not already associated
2698:             $this->doAddOrder($l);
2699:         }
2700: 
2701:         return $this;
2702:     }
2703: 
2704:     /**
2705:      * @param   Order $order The order object to add.
2706:      */
2707:     protected function doAddOrder($order)
2708:     {
2709:         $this->collOrders[]= $order;
2710:         $order->setCustomer($this);
2711:     }
2712: 
2713:     /**
2714:      * @param   Order $order The order object to remove.
2715:      * @return Customer The current object (for fluent API support)
2716:      */
2717:     public function removeOrder($order)
2718:     {
2719:         if ($this->getOrders()->contains($order)) {
2720:             $this->collOrders->remove($this->collOrders->search($order));
2721:             if (null === $this->ordersScheduledForDeletion) {
2722:                 $this->ordersScheduledForDeletion = clone $this->collOrders;
2723:                 $this->ordersScheduledForDeletion->clear();
2724:             }
2725:             $this->ordersScheduledForDeletion[]= clone $order;
2726:             $order->setCustomer(null);
2727:         }
2728: 
2729:         return $this;
2730:     }
2731: 
2732: 
2733:     /**
2734:      * If this collection has already been initialized with
2735:      * an identical criteria, it returns the collection.
2736:      * Otherwise if this Customer is new, it will return
2737:      * an empty collection; or if this Customer has previously
2738:      * been saved, it will retrieve related Orders from storage.
2739:      *
2740:      * This method is protected by default in order to keep the public
2741:      * api reasonable.  You can provide public methods for those you
2742:      * actually need in Customer.
2743:      *
2744:      * @param Criteria $criteria optional Criteria object to narrow the query
2745:      * @param PropelPDO $con optional connection object
2746:      * @param string $join_behavior optional join type to use (defaults to Criteria::LEFT_JOIN)
2747:      * @return PropelObjectCollection|Order[] List of Order objects
2748:      */
2749:     public function getOrdersJoinCurrency($criteria = null, $con = null, $join_behavior = Criteria::LEFT_JOIN)
2750:     {
2751:         $query = OrderQuery::create(null, $criteria);
2752:         $query->joinWith('Currency', $join_behavior);
2753: 
2754:         return $this->getOrders($query, $con);
2755:     }
2756: 
2757: 
2758:     /**
2759:      * If this collection has already been initialized with
2760:      * an identical criteria, it returns the collection.
2761:      * Otherwise if this Customer is new, it will return
2762:      * an empty collection; or if this Customer has previously
2763:      * been saved, it will retrieve related Orders from storage.
2764:      *
2765:      * This method is protected by default in order to keep the public
2766:      * api reasonable.  You can provide public methods for those you
2767:      * actually need in Customer.
2768:      *
2769:      * @param Criteria $criteria optional Criteria object to narrow the query
2770:      * @param PropelPDO $con optional connection object
2771:      * @param string $join_behavior optional join type to use (defaults to Criteria::LEFT_JOIN)
2772:      * @return PropelObjectCollection|Order[] List of Order objects
2773:      */
2774:     public function getOrdersJoinOrderAddressRelatedByAddressInvoice($criteria = null, $con = null, $join_behavior = Criteria::LEFT_JOIN)
2775:     {
2776:         $query = OrderQuery::create(null, $criteria);
2777:         $query->joinWith('OrderAddressRelatedByAddressInvoice', $join_behavior);
2778: 
2779:         return $this->getOrders($query, $con);
2780:     }
2781: 
2782: 
2783:     /**
2784:      * If this collection has already been initialized with
2785:      * an identical criteria, it returns the collection.
2786:      * Otherwise if this Customer is new, it will return
2787:      * an empty collection; or if this Customer has previously
2788:      * been saved, it will retrieve related Orders from storage.
2789:      *
2790:      * This method is protected by default in order to keep the public
2791:      * api reasonable.  You can provide public methods for those you
2792:      * actually need in Customer.
2793:      *
2794:      * @param Criteria $criteria optional Criteria object to narrow the query
2795:      * @param PropelPDO $con optional connection object
2796:      * @param string $join_behavior optional join type to use (defaults to Criteria::LEFT_JOIN)
2797:      * @return PropelObjectCollection|Order[] List of Order objects
2798:      */
2799:     public function getOrdersJoinOrderAddressRelatedByAddressDelivery($criteria = null, $con = null, $join_behavior = Criteria::LEFT_JOIN)
2800:     {
2801:         $query = OrderQuery::create(null, $criteria);
2802:         $query->joinWith('OrderAddressRelatedByAddressDelivery', $join_behavior);
2803: 
2804:         return $this->getOrders($query, $con);
2805:     }
2806: 
2807: 
2808:     /**
2809:      * If this collection has already been initialized with
2810:      * an identical criteria, it returns the collection.
2811:      * Otherwise if this Customer is new, it will return
2812:      * an empty collection; or if this Customer has previously
2813:      * been saved, it will retrieve related Orders from storage.
2814:      *
2815:      * This method is protected by default in order to keep the public
2816:      * api reasonable.  You can provide public methods for those you
2817:      * actually need in Customer.
2818:      *
2819:      * @param Criteria $criteria optional Criteria object to narrow the query
2820:      * @param PropelPDO $con optional connection object
2821:      * @param string $join_behavior optional join type to use (defaults to Criteria::LEFT_JOIN)
2822:      * @return PropelObjectCollection|Order[] List of Order objects
2823:      */
2824:     public function getOrdersJoinOrderStatus($criteria = null, $con = null, $join_behavior = Criteria::LEFT_JOIN)
2825:     {
2826:         $query = OrderQuery::create(null, $criteria);
2827:         $query->joinWith('OrderStatus', $join_behavior);
2828: 
2829:         return $this->getOrders($query, $con);
2830:     }
2831: 
2832:     /**
2833:      * Clears the current object and sets all attributes to their default values
2834:      */
2835:     public function clear()
2836:     {
2837:         $this->id = null;
2838:         $this->ref = null;
2839:         $this->customer_title_id = null;
2840:         $this->company = null;
2841:         $this->firstname = null;
2842:         $this->lastname = null;
2843:         $this->address1 = null;
2844:         $this->address2 = null;
2845:         $this->address3 = null;
2846:         $this->zipcode = null;
2847:         $this->city = null;
2848:         $this->country_id = null;
2849:         $this->phone = null;
2850:         $this->cellphone = null;
2851:         $this->email = null;
2852:         $this->password = null;
2853:         $this->algo = null;
2854:         $this->salt = null;
2855:         $this->reseller = null;
2856:         $this->lang = null;
2857:         $this->sponsor = null;
2858:         $this->discount = null;
2859:         $this->created_at = null;
2860:         $this->updated_at = null;
2861:         $this->alreadyInSave = false;
2862:         $this->alreadyInValidation = false;
2863:         $this->alreadyInClearAllReferencesDeep = false;
2864:         $this->clearAllReferences();
2865:         $this->resetModified();
2866:         $this->setNew(true);
2867:         $this->setDeleted(false);
2868:     }
2869: 
2870:     /**
2871:      * Resets all references to other model objects or collections of model objects.
2872:      *
2873:      * This method is a user-space workaround for PHP's inability to garbage collect
2874:      * objects with circular references (even in PHP 5.3). This is currently necessary
2875:      * when using Propel in certain daemon or large-volumne/high-memory operations.
2876:      *
2877:      * @param boolean $deep Whether to also clear the references on all referrer objects.
2878:      */
2879:     public function clearAllReferences($deep = false)
2880:     {
2881:         if ($deep && !$this->alreadyInClearAllReferencesDeep) {
2882:             $this->alreadyInClearAllReferencesDeep = true;
2883:             if ($this->collAddresss) {
2884:                 foreach ($this->collAddresss as $o) {
2885:                     $o->clearAllReferences($deep);
2886:                 }
2887:             }
2888:             if ($this->collOrders) {
2889:                 foreach ($this->collOrders as $o) {
2890:                     $o->clearAllReferences($deep);
2891:                 }
2892:             }
2893:             if ($this->aCustomerTitle instanceof Persistent) {
2894:               $this->aCustomerTitle->clearAllReferences($deep);
2895:             }
2896: 
2897:             $this->alreadyInClearAllReferencesDeep = false;
2898:         } // if ($deep)
2899: 
2900:         if ($this->collAddresss instanceof PropelCollection) {
2901:             $this->collAddresss->clearIterator();
2902:         }
2903:         $this->collAddresss = null;
2904:         if ($this->collOrders instanceof PropelCollection) {
2905:             $this->collOrders->clearIterator();
2906:         }
2907:         $this->collOrders = null;
2908:         $this->aCustomerTitle = null;
2909:     }
2910: 
2911:     /**
2912:      * return the string representation of this object
2913:      *
2914:      * @return string
2915:      */
2916:     public function __toString()
2917:     {
2918:         return (string) $this->exportTo(CustomerPeer::DEFAULT_STRING_FORMAT);
2919:     }
2920: 
2921:     /**
2922:      * return true is the object is in saving state
2923:      *
2924:      * @return boolean
2925:      */
2926:     public function isAlreadyInSave()
2927:     {
2928:         return $this->alreadyInSave;
2929:     }
2930: 
2931:     // timestampable behavior
2932: 
2933:     /**
2934:      * Mark the current object so that the update date doesn't get updated during next save
2935:      *
2936:      * @return     Customer The current object (for fluent API support)
2937:      */
2938:     public function keepUpdateDateUnchanged()
2939:     {
2940:         $this->modifiedColumns[] = CustomerPeer::UPDATED_AT;
2941: 
2942:         return $this;
2943:     }
2944: 
2945: }
2946: