1: <?php
   2: 
   3: namespace Thelia\Model\om;
   4: 
   5: use \Criteria;
   6: use \Exception;
   7: use \ModelCriteria;
   8: use \ModelJoin;
   9: use \PDO;
  10: use \Propel;
  11: use \PropelCollection;
  12: use \PropelException;
  13: use \PropelObjectCollection;
  14: use \PropelPDO;
  15: use Thelia\Model\Accessory;
  16: use Thelia\Model\ContentAssoc;
  17: use Thelia\Model\Document;
  18: use Thelia\Model\FeatureProd;
  19: use Thelia\Model\Image;
  20: use Thelia\Model\Product;
  21: use Thelia\Model\ProductCategory;
  22: use Thelia\Model\ProductI18n;
  23: use Thelia\Model\ProductPeer;
  24: use Thelia\Model\ProductQuery;
  25: use Thelia\Model\ProductVersion;
  26: use Thelia\Model\Rewriting;
  27: use Thelia\Model\Stock;
  28: use Thelia\Model\TaxRule;
  29: 
  30: /**
  31:  * Base class that represents a query for the 'product' table.
  32:  *
  33:  *
  34:  *
  35:  * @method ProductQuery orderById($order = Criteria::ASC) Order by the id column
  36:  * @method ProductQuery orderByTaxRuleId($order = Criteria::ASC) Order by the tax_rule_id column
  37:  * @method ProductQuery orderByRef($order = Criteria::ASC) Order by the ref column
  38:  * @method ProductQuery orderByPrice($order = Criteria::ASC) Order by the price column
  39:  * @method ProductQuery orderByPrice2($order = Criteria::ASC) Order by the price2 column
  40:  * @method ProductQuery orderByEcotax($order = Criteria::ASC) Order by the ecotax column
  41:  * @method ProductQuery orderByNewness($order = Criteria::ASC) Order by the newness column
  42:  * @method ProductQuery orderByPromo($order = Criteria::ASC) Order by the promo column
  43:  * @method ProductQuery orderByStock($order = Criteria::ASC) Order by the stock column
  44:  * @method ProductQuery orderByVisible($order = Criteria::ASC) Order by the visible column
  45:  * @method ProductQuery orderByWeight($order = Criteria::ASC) Order by the weight column
  46:  * @method ProductQuery orderByPosition($order = Criteria::ASC) Order by the position column
  47:  * @method ProductQuery orderByCreatedAt($order = Criteria::ASC) Order by the created_at column
  48:  * @method ProductQuery orderByUpdatedAt($order = Criteria::ASC) Order by the updated_at column
  49:  * @method ProductQuery orderByVersion($order = Criteria::ASC) Order by the version column
  50:  * @method ProductQuery orderByVersionCreatedAt($order = Criteria::ASC) Order by the version_created_at column
  51:  * @method ProductQuery orderByVersionCreatedBy($order = Criteria::ASC) Order by the version_created_by column
  52:  *
  53:  * @method ProductQuery groupById() Group by the id column
  54:  * @method ProductQuery groupByTaxRuleId() Group by the tax_rule_id column
  55:  * @method ProductQuery groupByRef() Group by the ref column
  56:  * @method ProductQuery groupByPrice() Group by the price column
  57:  * @method ProductQuery groupByPrice2() Group by the price2 column
  58:  * @method ProductQuery groupByEcotax() Group by the ecotax column
  59:  * @method ProductQuery groupByNewness() Group by the newness column
  60:  * @method ProductQuery groupByPromo() Group by the promo column
  61:  * @method ProductQuery groupByStock() Group by the stock column
  62:  * @method ProductQuery groupByVisible() Group by the visible column
  63:  * @method ProductQuery groupByWeight() Group by the weight column
  64:  * @method ProductQuery groupByPosition() Group by the position column
  65:  * @method ProductQuery groupByCreatedAt() Group by the created_at column
  66:  * @method ProductQuery groupByUpdatedAt() Group by the updated_at column
  67:  * @method ProductQuery groupByVersion() Group by the version column
  68:  * @method ProductQuery groupByVersionCreatedAt() Group by the version_created_at column
  69:  * @method ProductQuery groupByVersionCreatedBy() Group by the version_created_by column
  70:  *
  71:  * @method ProductQuery leftJoin($relation) Adds a LEFT JOIN clause to the query
  72:  * @method ProductQuery rightJoin($relation) Adds a RIGHT JOIN clause to the query
  73:  * @method ProductQuery innerJoin($relation) Adds a INNER JOIN clause to the query
  74:  *
  75:  * @method ProductQuery leftJoinTaxRule($relationAlias = null) Adds a LEFT JOIN clause to the query using the TaxRule relation
  76:  * @method ProductQuery rightJoinTaxRule($relationAlias = null) Adds a RIGHT JOIN clause to the query using the TaxRule relation
  77:  * @method ProductQuery innerJoinTaxRule($relationAlias = null) Adds a INNER JOIN clause to the query using the TaxRule relation
  78:  *
  79:  * @method ProductQuery leftJoinProductCategory($relationAlias = null) Adds a LEFT JOIN clause to the query using the ProductCategory relation
  80:  * @method ProductQuery rightJoinProductCategory($relationAlias = null) Adds a RIGHT JOIN clause to the query using the ProductCategory relation
  81:  * @method ProductQuery innerJoinProductCategory($relationAlias = null) Adds a INNER JOIN clause to the query using the ProductCategory relation
  82:  *
  83:  * @method ProductQuery leftJoinFeatureProd($relationAlias = null) Adds a LEFT JOIN clause to the query using the FeatureProd relation
  84:  * @method ProductQuery rightJoinFeatureProd($relationAlias = null) Adds a RIGHT JOIN clause to the query using the FeatureProd relation
  85:  * @method ProductQuery innerJoinFeatureProd($relationAlias = null) Adds a INNER JOIN clause to the query using the FeatureProd relation
  86:  *
  87:  * @method ProductQuery leftJoinStock($relationAlias = null) Adds a LEFT JOIN clause to the query using the Stock relation
  88:  * @method ProductQuery rightJoinStock($relationAlias = null) Adds a RIGHT JOIN clause to the query using the Stock relation
  89:  * @method ProductQuery innerJoinStock($relationAlias = null) Adds a INNER JOIN clause to the query using the Stock relation
  90:  *
  91:  * @method ProductQuery leftJoinContentAssoc($relationAlias = null) Adds a LEFT JOIN clause to the query using the ContentAssoc relation
  92:  * @method ProductQuery rightJoinContentAssoc($relationAlias = null) Adds a RIGHT JOIN clause to the query using the ContentAssoc relation
  93:  * @method ProductQuery innerJoinContentAssoc($relationAlias = null) Adds a INNER JOIN clause to the query using the ContentAssoc relation
  94:  *
  95:  * @method ProductQuery leftJoinImage($relationAlias = null) Adds a LEFT JOIN clause to the query using the Image relation
  96:  * @method ProductQuery rightJoinImage($relationAlias = null) Adds a RIGHT JOIN clause to the query using the Image relation
  97:  * @method ProductQuery innerJoinImage($relationAlias = null) Adds a INNER JOIN clause to the query using the Image relation
  98:  *
  99:  * @method ProductQuery leftJoinDocument($relationAlias = null) Adds a LEFT JOIN clause to the query using the Document relation
 100:  * @method ProductQuery rightJoinDocument($relationAlias = null) Adds a RIGHT JOIN clause to the query using the Document relation
 101:  * @method ProductQuery innerJoinDocument($relationAlias = null) Adds a INNER JOIN clause to the query using the Document relation
 102:  *
 103:  * @method ProductQuery leftJoinAccessoryRelatedByProductId($relationAlias = null) Adds a LEFT JOIN clause to the query using the AccessoryRelatedByProductId relation
 104:  * @method ProductQuery rightJoinAccessoryRelatedByProductId($relationAlias = null) Adds a RIGHT JOIN clause to the query using the AccessoryRelatedByProductId relation
 105:  * @method ProductQuery innerJoinAccessoryRelatedByProductId($relationAlias = null) Adds a INNER JOIN clause to the query using the AccessoryRelatedByProductId relation
 106:  *
 107:  * @method ProductQuery leftJoinAccessoryRelatedByAccessory($relationAlias = null) Adds a LEFT JOIN clause to the query using the AccessoryRelatedByAccessory relation
 108:  * @method ProductQuery rightJoinAccessoryRelatedByAccessory($relationAlias = null) Adds a RIGHT JOIN clause to the query using the AccessoryRelatedByAccessory relation
 109:  * @method ProductQuery innerJoinAccessoryRelatedByAccessory($relationAlias = null) Adds a INNER JOIN clause to the query using the AccessoryRelatedByAccessory relation
 110:  *
 111:  * @method ProductQuery leftJoinRewriting($relationAlias = null) Adds a LEFT JOIN clause to the query using the Rewriting relation
 112:  * @method ProductQuery rightJoinRewriting($relationAlias = null) Adds a RIGHT JOIN clause to the query using the Rewriting relation
 113:  * @method ProductQuery innerJoinRewriting($relationAlias = null) Adds a INNER JOIN clause to the query using the Rewriting relation
 114:  *
 115:  * @method ProductQuery leftJoinProductI18n($relationAlias = null) Adds a LEFT JOIN clause to the query using the ProductI18n relation
 116:  * @method ProductQuery rightJoinProductI18n($relationAlias = null) Adds a RIGHT JOIN clause to the query using the ProductI18n relation
 117:  * @method ProductQuery innerJoinProductI18n($relationAlias = null) Adds a INNER JOIN clause to the query using the ProductI18n relation
 118:  *
 119:  * @method ProductQuery leftJoinProductVersion($relationAlias = null) Adds a LEFT JOIN clause to the query using the ProductVersion relation
 120:  * @method ProductQuery rightJoinProductVersion($relationAlias = null) Adds a RIGHT JOIN clause to the query using the ProductVersion relation
 121:  * @method ProductQuery innerJoinProductVersion($relationAlias = null) Adds a INNER JOIN clause to the query using the ProductVersion relation
 122:  *
 123:  * @method Product findOne(PropelPDO $con = null) Return the first Product matching the query
 124:  * @method Product findOneOrCreate(PropelPDO $con = null) Return the first Product matching the query, or a new Product object populated from the query conditions when no match is found
 125:  *
 126:  * @method Product findOneById(int $id) Return the first Product filtered by the id column
 127:  * @method Product findOneByTaxRuleId(int $tax_rule_id) Return the first Product filtered by the tax_rule_id column
 128:  * @method Product findOneByRef(string $ref) Return the first Product filtered by the ref column
 129:  * @method Product findOneByPrice(double $price) Return the first Product filtered by the price column
 130:  * @method Product findOneByPrice2(double $price2) Return the first Product filtered by the price2 column
 131:  * @method Product findOneByEcotax(double $ecotax) Return the first Product filtered by the ecotax column
 132:  * @method Product findOneByNewness(int $newness) Return the first Product filtered by the newness column
 133:  * @method Product findOneByPromo(int $promo) Return the first Product filtered by the promo column
 134:  * @method Product findOneByStock(int $stock) Return the first Product filtered by the stock column
 135:  * @method Product findOneByVisible(int $visible) Return the first Product filtered by the visible column
 136:  * @method Product findOneByWeight(double $weight) Return the first Product filtered by the weight column
 137:  * @method Product findOneByPosition(int $position) Return the first Product filtered by the position column
 138:  * @method Product findOneByCreatedAt(string $created_at) Return the first Product filtered by the created_at column
 139:  * @method Product findOneByUpdatedAt(string $updated_at) Return the first Product filtered by the updated_at column
 140:  * @method Product findOneByVersion(int $version) Return the first Product filtered by the version column
 141:  * @method Product findOneByVersionCreatedAt(string $version_created_at) Return the first Product filtered by the version_created_at column
 142:  * @method Product findOneByVersionCreatedBy(string $version_created_by) Return the first Product filtered by the version_created_by column
 143:  *
 144:  * @method array findById(int $id) Return Product objects filtered by the id column
 145:  * @method array findByTaxRuleId(int $tax_rule_id) Return Product objects filtered by the tax_rule_id column
 146:  * @method array findByRef(string $ref) Return Product objects filtered by the ref column
 147:  * @method array findByPrice(double $price) Return Product objects filtered by the price column
 148:  * @method array findByPrice2(double $price2) Return Product objects filtered by the price2 column
 149:  * @method array findByEcotax(double $ecotax) Return Product objects filtered by the ecotax column
 150:  * @method array findByNewness(int $newness) Return Product objects filtered by the newness column
 151:  * @method array findByPromo(int $promo) Return Product objects filtered by the promo column
 152:  * @method array findByStock(int $stock) Return Product objects filtered by the stock column
 153:  * @method array findByVisible(int $visible) Return Product objects filtered by the visible column
 154:  * @method array findByWeight(double $weight) Return Product objects filtered by the weight column
 155:  * @method array findByPosition(int $position) Return Product objects filtered by the position column
 156:  * @method array findByCreatedAt(string $created_at) Return Product objects filtered by the created_at column
 157:  * @method array findByUpdatedAt(string $updated_at) Return Product objects filtered by the updated_at column
 158:  * @method array findByVersion(int $version) Return Product objects filtered by the version column
 159:  * @method array findByVersionCreatedAt(string $version_created_at) Return Product objects filtered by the version_created_at column
 160:  * @method array findByVersionCreatedBy(string $version_created_by) Return Product objects filtered by the version_created_by column
 161:  *
 162:  * @package    propel.generator.Thelia.Model.om
 163:  */
 164: abstract class BaseProductQuery extends ModelCriteria
 165: {
 166:     /**
 167:      * Initializes internal state of BaseProductQuery object.
 168:      *
 169:      * @param     string $dbName The dabase name
 170:      * @param     string $modelName The phpName of a model, e.g. 'Book'
 171:      * @param     string $modelAlias The alias for the model in this query, e.g. 'b'
 172:      */
 173:     public function __construct($dbName = 'thelia', $modelName = 'Thelia\\Model\\Product', $modelAlias = null)
 174:     {
 175:         parent::__construct($dbName, $modelName, $modelAlias);
 176:     }
 177: 
 178:     /**
 179:      * Returns a new ProductQuery object.
 180:      *
 181:      * @param     string $modelAlias The alias of a model in the query
 182:      * @param     ProductQuery|Criteria $criteria Optional Criteria to build the query from
 183:      *
 184:      * @return ProductQuery
 185:      */
 186:     public static function create($modelAlias = null, $criteria = null)
 187:     {
 188:         if ($criteria instanceof ProductQuery) {
 189:             return $criteria;
 190:         }
 191:         $query = new ProductQuery();
 192:         if (null !== $modelAlias) {
 193:             $query->setModelAlias($modelAlias);
 194:         }
 195:         if ($criteria instanceof Criteria) {
 196:             $query->mergeWith($criteria);
 197:         }
 198: 
 199:         return $query;
 200:     }
 201: 
 202:     /**
 203:      * Find object by primary key.
 204:      * Propel uses the instance pool to skip the database if the object exists.
 205:      * Go fast if the query is untouched.
 206:      *
 207:      * <code>
 208:      * $obj  = $c->findPk(12, $con);
 209:      * </code>
 210:      *
 211:      * @param mixed $key Primary key to use for the query
 212:      * @param     PropelPDO $con an optional connection object
 213:      *
 214:      * @return   Product|Product[]|mixed the result, formatted by the current formatter
 215:      */
 216:     public function findPk($key, $con = null)
 217:     {
 218:         if ($key === null) {
 219:             return null;
 220:         }
 221:         if ((null !== ($obj = ProductPeer::getInstanceFromPool((string) $key))) && !$this->formatter) {
 222:             // the object is alredy in the instance pool
 223:             return $obj;
 224:         }
 225:         if ($con === null) {
 226:             $con = Propel::getConnection(ProductPeer::DATABASE_NAME, Propel::CONNECTION_READ);
 227:         }
 228:         $this->basePreSelect($con);
 229:         if ($this->formatter || $this->modelAlias || $this->with || $this->select
 230:          || $this->selectColumns || $this->asColumns || $this->selectModifiers
 231:          || $this->map || $this->having || $this->joins) {
 232:             return $this->findPkComplex($key, $con);
 233:         } else {
 234:             return $this->findPkSimple($key, $con);
 235:         }
 236:     }
 237: 
 238:     /**
 239:      * Find object by primary key using raw SQL to go fast.
 240:      * Bypass doSelect() and the object formatter by using generated code.
 241:      *
 242:      * @param     mixed $key Primary key to use for the query
 243:      * @param     PropelPDO $con A connection object
 244:      *
 245:      * @return   Product A model object, or null if the key is not found
 246:      * @throws   PropelException
 247:      */
 248:     protected function findPkSimple($key, $con)
 249:     {
 250:         $sql = 'SELECT `ID`, `TAX_RULE_ID`, `REF`, `PRICE`, `PRICE2`, `ECOTAX`, `NEWNESS`, `PROMO`, `STOCK`, `VISIBLE`, `WEIGHT`, `POSITION`, `CREATED_AT`, `UPDATED_AT`, `VERSION`, `VERSION_CREATED_AT`, `VERSION_CREATED_BY` FROM `product` WHERE `ID` = :p0';
 251:         try {
 252:             $stmt = $con->prepare($sql);
 253:             $stmt->bindValue(':p0', $key, PDO::PARAM_INT);
 254:             $stmt->execute();
 255:         } catch (Exception $e) {
 256:             Propel::log($e->getMessage(), Propel::LOG_ERR);
 257:             throw new PropelException(sprintf('Unable to execute SELECT statement [%s]', $sql), $e);
 258:         }
 259:         $obj = null;
 260:         if ($row = $stmt->fetch(PDO::FETCH_NUM)) {
 261:             $obj = new Product();
 262:             $obj->hydrate($row);
 263:             ProductPeer::addInstanceToPool($obj, (string) $key);
 264:         }
 265:         $stmt->closeCursor();
 266: 
 267:         return $obj;
 268:     }
 269: 
 270:     /**
 271:      * Find object by primary key.
 272:      *
 273:      * @param     mixed $key Primary key to use for the query
 274:      * @param     PropelPDO $con A connection object
 275:      *
 276:      * @return Product|Product[]|mixed the result, formatted by the current formatter
 277:      */
 278:     protected function findPkComplex($key, $con)
 279:     {
 280:         // As the query uses a PK condition, no limit(1) is necessary.
 281:         $criteria = $this->isKeepQuery() ? clone $this : $this;
 282:         $stmt = $criteria
 283:             ->filterByPrimaryKey($key)
 284:             ->doSelect($con);
 285: 
 286:         return $criteria->getFormatter()->init($criteria)->formatOne($stmt);
 287:     }
 288: 
 289:     /**
 290:      * Find objects by primary key
 291:      * <code>
 292:      * $objs = $c->findPks(array(12, 56, 832), $con);
 293:      * </code>
 294:      * @param     array $keys Primary keys to use for the query
 295:      * @param     PropelPDO $con an optional connection object
 296:      *
 297:      * @return PropelObjectCollection|Product[]|mixed the list of results, formatted by the current formatter
 298:      */
 299:     public function findPks($keys, $con = null)
 300:     {
 301:         if ($con === null) {
 302:             $con = Propel::getConnection($this->getDbName(), Propel::CONNECTION_READ);
 303:         }
 304:         $this->basePreSelect($con);
 305:         $criteria = $this->isKeepQuery() ? clone $this : $this;
 306:         $stmt = $criteria
 307:             ->filterByPrimaryKeys($keys)
 308:             ->doSelect($con);
 309: 
 310:         return $criteria->getFormatter()->init($criteria)->format($stmt);
 311:     }
 312: 
 313:     /**
 314:      * Filter the query by primary key
 315:      *
 316:      * @param     mixed $key Primary key to use for the query
 317:      *
 318:      * @return ProductQuery The current query, for fluid interface
 319:      */
 320:     public function filterByPrimaryKey($key)
 321:     {
 322: 
 323:         return $this->addUsingAlias(ProductPeer::ID, $key, Criteria::EQUAL);
 324:     }
 325: 
 326:     /**
 327:      * Filter the query by a list of primary keys
 328:      *
 329:      * @param     array $keys The list of primary key to use for the query
 330:      *
 331:      * @return ProductQuery The current query, for fluid interface
 332:      */
 333:     public function filterByPrimaryKeys($keys)
 334:     {
 335: 
 336:         return $this->addUsingAlias(ProductPeer::ID, $keys, Criteria::IN);
 337:     }
 338: 
 339:     /**
 340:      * Filter the query on the id column
 341:      *
 342:      * Example usage:
 343:      * <code>
 344:      * $query->filterById(1234); // WHERE id = 1234
 345:      * $query->filterById(array(12, 34)); // WHERE id IN (12, 34)
 346:      * $query->filterById(array('min' => 12)); // WHERE id > 12
 347:      * </code>
 348:      *
 349:      * @param     mixed $id The value to use as filter.
 350:      *              Use scalar values for equality.
 351:      *              Use array values for in_array() equivalent.
 352:      *              Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
 353:      * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
 354:      *
 355:      * @return ProductQuery The current query, for fluid interface
 356:      */
 357:     public function filterById($id = null, $comparison = null)
 358:     {
 359:         if (is_array($id) && null === $comparison) {
 360:             $comparison = Criteria::IN;
 361:         }
 362: 
 363:         return $this->addUsingAlias(ProductPeer::ID, $id, $comparison);
 364:     }
 365: 
 366:     /**
 367:      * Filter the query on the tax_rule_id column
 368:      *
 369:      * Example usage:
 370:      * <code>
 371:      * $query->filterByTaxRuleId(1234); // WHERE tax_rule_id = 1234
 372:      * $query->filterByTaxRuleId(array(12, 34)); // WHERE tax_rule_id IN (12, 34)
 373:      * $query->filterByTaxRuleId(array('min' => 12)); // WHERE tax_rule_id > 12
 374:      * </code>
 375:      *
 376:      * @see       filterByTaxRule()
 377:      *
 378:      * @param     mixed $taxRuleId The value to use as filter.
 379:      *              Use scalar values for equality.
 380:      *              Use array values for in_array() equivalent.
 381:      *              Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
 382:      * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
 383:      *
 384:      * @return ProductQuery The current query, for fluid interface
 385:      */
 386:     public function filterByTaxRuleId($taxRuleId = null, $comparison = null)
 387:     {
 388:         if (is_array($taxRuleId)) {
 389:             $useMinMax = false;
 390:             if (isset($taxRuleId['min'])) {
 391:                 $this->addUsingAlias(ProductPeer::TAX_RULE_ID, $taxRuleId['min'], Criteria::GREATER_EQUAL);
 392:                 $useMinMax = true;
 393:             }
 394:             if (isset($taxRuleId['max'])) {
 395:                 $this->addUsingAlias(ProductPeer::TAX_RULE_ID, $taxRuleId['max'], Criteria::LESS_EQUAL);
 396:                 $useMinMax = true;
 397:             }
 398:             if ($useMinMax) {
 399:                 return $this;
 400:             }
 401:             if (null === $comparison) {
 402:                 $comparison = Criteria::IN;
 403:             }
 404:         }
 405: 
 406:         return $this->addUsingAlias(ProductPeer::TAX_RULE_ID, $taxRuleId, $comparison);
 407:     }
 408: 
 409:     /**
 410:      * Filter the query on the ref column
 411:      *
 412:      * Example usage:
 413:      * <code>
 414:      * $query->filterByRef('fooValue');   // WHERE ref = 'fooValue'
 415:      * $query->filterByRef('%fooValue%'); // WHERE ref LIKE '%fooValue%'
 416:      * </code>
 417:      *
 418:      * @param     string $ref The value to use as filter.
 419:      *              Accepts wildcards (* and % trigger a LIKE)
 420:      * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
 421:      *
 422:      * @return ProductQuery The current query, for fluid interface
 423:      */
 424:     public function filterByRef($ref = null, $comparison = null)
 425:     {
 426:         if (null === $comparison) {
 427:             if (is_array($ref)) {
 428:                 $comparison = Criteria::IN;
 429:             } elseif (preg_match('/[\%\*]/', $ref)) {
 430:                 $ref = str_replace('*', '%', $ref);
 431:                 $comparison = Criteria::LIKE;
 432:             }
 433:         }
 434: 
 435:         return $this->addUsingAlias(ProductPeer::REF, $ref, $comparison);
 436:     }
 437: 
 438:     /**
 439:      * Filter the query on the price column
 440:      *
 441:      * Example usage:
 442:      * <code>
 443:      * $query->filterByPrice(1234); // WHERE price = 1234
 444:      * $query->filterByPrice(array(12, 34)); // WHERE price IN (12, 34)
 445:      * $query->filterByPrice(array('min' => 12)); // WHERE price > 12
 446:      * </code>
 447:      *
 448:      * @param     mixed $price The value to use as filter.
 449:      *              Use scalar values for equality.
 450:      *              Use array values for in_array() equivalent.
 451:      *              Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
 452:      * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
 453:      *
 454:      * @return ProductQuery The current query, for fluid interface
 455:      */
 456:     public function filterByPrice($price = null, $comparison = null)
 457:     {
 458:         if (is_array($price)) {
 459:             $useMinMax = false;
 460:             if (isset($price['min'])) {
 461:                 $this->addUsingAlias(ProductPeer::PRICE, $price['min'], Criteria::GREATER_EQUAL);
 462:                 $useMinMax = true;
 463:             }
 464:             if (isset($price['max'])) {
 465:                 $this->addUsingAlias(ProductPeer::PRICE, $price['max'], Criteria::LESS_EQUAL);
 466:                 $useMinMax = true;
 467:             }
 468:             if ($useMinMax) {
 469:                 return $this;
 470:             }
 471:             if (null === $comparison) {
 472:                 $comparison = Criteria::IN;
 473:             }
 474:         }
 475: 
 476:         return $this->addUsingAlias(ProductPeer::PRICE, $price, $comparison);
 477:     }
 478: 
 479:     /**
 480:      * Filter the query on the price2 column
 481:      *
 482:      * Example usage:
 483:      * <code>
 484:      * $query->filterByPrice2(1234); // WHERE price2 = 1234
 485:      * $query->filterByPrice2(array(12, 34)); // WHERE price2 IN (12, 34)
 486:      * $query->filterByPrice2(array('min' => 12)); // WHERE price2 > 12
 487:      * </code>
 488:      *
 489:      * @param     mixed $price2 The value to use as filter.
 490:      *              Use scalar values for equality.
 491:      *              Use array values for in_array() equivalent.
 492:      *              Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
 493:      * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
 494:      *
 495:      * @return ProductQuery The current query, for fluid interface
 496:      */
 497:     public function filterByPrice2($price2 = null, $comparison = null)
 498:     {
 499:         if (is_array($price2)) {
 500:             $useMinMax = false;
 501:             if (isset($price2['min'])) {
 502:                 $this->addUsingAlias(ProductPeer::PRICE2, $price2['min'], Criteria::GREATER_EQUAL);
 503:                 $useMinMax = true;
 504:             }
 505:             if (isset($price2['max'])) {
 506:                 $this->addUsingAlias(ProductPeer::PRICE2, $price2['max'], Criteria::LESS_EQUAL);
 507:                 $useMinMax = true;
 508:             }
 509:             if ($useMinMax) {
 510:                 return $this;
 511:             }
 512:             if (null === $comparison) {
 513:                 $comparison = Criteria::IN;
 514:             }
 515:         }
 516: 
 517:         return $this->addUsingAlias(ProductPeer::PRICE2, $price2, $comparison);
 518:     }
 519: 
 520:     /**
 521:      * Filter the query on the ecotax column
 522:      *
 523:      * Example usage:
 524:      * <code>
 525:      * $query->filterByEcotax(1234); // WHERE ecotax = 1234
 526:      * $query->filterByEcotax(array(12, 34)); // WHERE ecotax IN (12, 34)
 527:      * $query->filterByEcotax(array('min' => 12)); // WHERE ecotax > 12
 528:      * </code>
 529:      *
 530:      * @param     mixed $ecotax The value to use as filter.
 531:      *              Use scalar values for equality.
 532:      *              Use array values for in_array() equivalent.
 533:      *              Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
 534:      * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
 535:      *
 536:      * @return ProductQuery The current query, for fluid interface
 537:      */
 538:     public function filterByEcotax($ecotax = null, $comparison = null)
 539:     {
 540:         if (is_array($ecotax)) {
 541:             $useMinMax = false;
 542:             if (isset($ecotax['min'])) {
 543:                 $this->addUsingAlias(ProductPeer::ECOTAX, $ecotax['min'], Criteria::GREATER_EQUAL);
 544:                 $useMinMax = true;
 545:             }
 546:             if (isset($ecotax['max'])) {
 547:                 $this->addUsingAlias(ProductPeer::ECOTAX, $ecotax['max'], Criteria::LESS_EQUAL);
 548:                 $useMinMax = true;
 549:             }
 550:             if ($useMinMax) {
 551:                 return $this;
 552:             }
 553:             if (null === $comparison) {
 554:                 $comparison = Criteria::IN;
 555:             }
 556:         }
 557: 
 558:         return $this->addUsingAlias(ProductPeer::ECOTAX, $ecotax, $comparison);
 559:     }
 560: 
 561:     /**
 562:      * Filter the query on the newness column
 563:      *
 564:      * Example usage:
 565:      * <code>
 566:      * $query->filterByNewness(1234); // WHERE newness = 1234
 567:      * $query->filterByNewness(array(12, 34)); // WHERE newness IN (12, 34)
 568:      * $query->filterByNewness(array('min' => 12)); // WHERE newness > 12
 569:      * </code>
 570:      *
 571:      * @param     mixed $newness The value to use as filter.
 572:      *              Use scalar values for equality.
 573:      *              Use array values for in_array() equivalent.
 574:      *              Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
 575:      * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
 576:      *
 577:      * @return ProductQuery The current query, for fluid interface
 578:      */
 579:     public function filterByNewness($newness = null, $comparison = null)
 580:     {
 581:         if (is_array($newness)) {
 582:             $useMinMax = false;
 583:             if (isset($newness['min'])) {
 584:                 $this->addUsingAlias(ProductPeer::NEWNESS, $newness['min'], Criteria::GREATER_EQUAL);
 585:                 $useMinMax = true;
 586:             }
 587:             if (isset($newness['max'])) {
 588:                 $this->addUsingAlias(ProductPeer::NEWNESS, $newness['max'], Criteria::LESS_EQUAL);
 589:                 $useMinMax = true;
 590:             }
 591:             if ($useMinMax) {
 592:                 return $this;
 593:             }
 594:             if (null === $comparison) {
 595:                 $comparison = Criteria::IN;
 596:             }
 597:         }
 598: 
 599:         return $this->addUsingAlias(ProductPeer::NEWNESS, $newness, $comparison);
 600:     }
 601: 
 602:     /**
 603:      * Filter the query on the promo column
 604:      *
 605:      * Example usage:
 606:      * <code>
 607:      * $query->filterByPromo(1234); // WHERE promo = 1234
 608:      * $query->filterByPromo(array(12, 34)); // WHERE promo IN (12, 34)
 609:      * $query->filterByPromo(array('min' => 12)); // WHERE promo > 12
 610:      * </code>
 611:      *
 612:      * @param     mixed $promo The value to use as filter.
 613:      *              Use scalar values for equality.
 614:      *              Use array values for in_array() equivalent.
 615:      *              Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
 616:      * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
 617:      *
 618:      * @return ProductQuery The current query, for fluid interface
 619:      */
 620:     public function filterByPromo($promo = null, $comparison = null)
 621:     {
 622:         if (is_array($promo)) {
 623:             $useMinMax = false;
 624:             if (isset($promo['min'])) {
 625:                 $this->addUsingAlias(ProductPeer::PROMO, $promo['min'], Criteria::GREATER_EQUAL);
 626:                 $useMinMax = true;
 627:             }
 628:             if (isset($promo['max'])) {
 629:                 $this->addUsingAlias(ProductPeer::PROMO, $promo['max'], Criteria::LESS_EQUAL);
 630:                 $useMinMax = true;
 631:             }
 632:             if ($useMinMax) {
 633:                 return $this;
 634:             }
 635:             if (null === $comparison) {
 636:                 $comparison = Criteria::IN;
 637:             }
 638:         }
 639: 
 640:         return $this->addUsingAlias(ProductPeer::PROMO, $promo, $comparison);
 641:     }
 642: 
 643:     /**
 644:      * Filter the query on the stock column
 645:      *
 646:      * Example usage:
 647:      * <code>
 648:      * $query->filterByStock(1234); // WHERE stock = 1234
 649:      * $query->filterByStock(array(12, 34)); // WHERE stock IN (12, 34)
 650:      * $query->filterByStock(array('min' => 12)); // WHERE stock > 12
 651:      * </code>
 652:      *
 653:      * @param     mixed $stock The value to use as filter.
 654:      *              Use scalar values for equality.
 655:      *              Use array values for in_array() equivalent.
 656:      *              Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
 657:      * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
 658:      *
 659:      * @return ProductQuery The current query, for fluid interface
 660:      */
 661:     public function filterByStock($stock = null, $comparison = null)
 662:     {
 663:         if (is_array($stock)) {
 664:             $useMinMax = false;
 665:             if (isset($stock['min'])) {
 666:                 $this->addUsingAlias(ProductPeer::STOCK, $stock['min'], Criteria::GREATER_EQUAL);
 667:                 $useMinMax = true;
 668:             }
 669:             if (isset($stock['max'])) {
 670:                 $this->addUsingAlias(ProductPeer::STOCK, $stock['max'], Criteria::LESS_EQUAL);
 671:                 $useMinMax = true;
 672:             }
 673:             if ($useMinMax) {
 674:                 return $this;
 675:             }
 676:             if (null === $comparison) {
 677:                 $comparison = Criteria::IN;
 678:             }
 679:         }
 680: 
 681:         return $this->addUsingAlias(ProductPeer::STOCK, $stock, $comparison);
 682:     }
 683: 
 684:     /**
 685:      * Filter the query on the visible column
 686:      *
 687:      * Example usage:
 688:      * <code>
 689:      * $query->filterByVisible(1234); // WHERE visible = 1234
 690:      * $query->filterByVisible(array(12, 34)); // WHERE visible IN (12, 34)
 691:      * $query->filterByVisible(array('min' => 12)); // WHERE visible > 12
 692:      * </code>
 693:      *
 694:      * @param     mixed $visible The value to use as filter.
 695:      *              Use scalar values for equality.
 696:      *              Use array values for in_array() equivalent.
 697:      *              Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
 698:      * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
 699:      *
 700:      * @return ProductQuery The current query, for fluid interface
 701:      */
 702:     public function filterByVisible($visible = null, $comparison = null)
 703:     {
 704:         if (is_array($visible)) {
 705:             $useMinMax = false;
 706:             if (isset($visible['min'])) {
 707:                 $this->addUsingAlias(ProductPeer::VISIBLE, $visible['min'], Criteria::GREATER_EQUAL);
 708:                 $useMinMax = true;
 709:             }
 710:             if (isset($visible['max'])) {
 711:                 $this->addUsingAlias(ProductPeer::VISIBLE, $visible['max'], Criteria::LESS_EQUAL);
 712:                 $useMinMax = true;
 713:             }
 714:             if ($useMinMax) {
 715:                 return $this;
 716:             }
 717:             if (null === $comparison) {
 718:                 $comparison = Criteria::IN;
 719:             }
 720:         }
 721: 
 722:         return $this->addUsingAlias(ProductPeer::VISIBLE, $visible, $comparison);
 723:     }
 724: 
 725:     /**
 726:      * Filter the query on the weight column
 727:      *
 728:      * Example usage:
 729:      * <code>
 730:      * $query->filterByWeight(1234); // WHERE weight = 1234
 731:      * $query->filterByWeight(array(12, 34)); // WHERE weight IN (12, 34)
 732:      * $query->filterByWeight(array('min' => 12)); // WHERE weight > 12
 733:      * </code>
 734:      *
 735:      * @param     mixed $weight The value to use as filter.
 736:      *              Use scalar values for equality.
 737:      *              Use array values for in_array() equivalent.
 738:      *              Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
 739:      * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
 740:      *
 741:      * @return ProductQuery The current query, for fluid interface
 742:      */
 743:     public function filterByWeight($weight = null, $comparison = null)
 744:     {
 745:         if (is_array($weight)) {
 746:             $useMinMax = false;
 747:             if (isset($weight['min'])) {
 748:                 $this->addUsingAlias(ProductPeer::WEIGHT, $weight['min'], Criteria::GREATER_EQUAL);
 749:                 $useMinMax = true;
 750:             }
 751:             if (isset($weight['max'])) {
 752:                 $this->addUsingAlias(ProductPeer::WEIGHT, $weight['max'], Criteria::LESS_EQUAL);
 753:                 $useMinMax = true;
 754:             }
 755:             if ($useMinMax) {
 756:                 return $this;
 757:             }
 758:             if (null === $comparison) {
 759:                 $comparison = Criteria::IN;
 760:             }
 761:         }
 762: 
 763:         return $this->addUsingAlias(ProductPeer::WEIGHT, $weight, $comparison);
 764:     }
 765: 
 766:     /**
 767:      * Filter the query on the position column
 768:      *
 769:      * Example usage:
 770:      * <code>
 771:      * $query->filterByPosition(1234); // WHERE position = 1234
 772:      * $query->filterByPosition(array(12, 34)); // WHERE position IN (12, 34)
 773:      * $query->filterByPosition(array('min' => 12)); // WHERE position > 12
 774:      * </code>
 775:      *
 776:      * @param     mixed $position The value to use as filter.
 777:      *              Use scalar values for equality.
 778:      *              Use array values for in_array() equivalent.
 779:      *              Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
 780:      * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
 781:      *
 782:      * @return ProductQuery The current query, for fluid interface
 783:      */
 784:     public function filterByPosition($position = null, $comparison = null)
 785:     {
 786:         if (is_array($position)) {
 787:             $useMinMax = false;
 788:             if (isset($position['min'])) {
 789:                 $this->addUsingAlias(ProductPeer::POSITION, $position['min'], Criteria::GREATER_EQUAL);
 790:                 $useMinMax = true;
 791:             }
 792:             if (isset($position['max'])) {
 793:                 $this->addUsingAlias(ProductPeer::POSITION, $position['max'], Criteria::LESS_EQUAL);
 794:                 $useMinMax = true;
 795:             }
 796:             if ($useMinMax) {
 797:                 return $this;
 798:             }
 799:             if (null === $comparison) {
 800:                 $comparison = Criteria::IN;
 801:             }
 802:         }
 803: 
 804:         return $this->addUsingAlias(ProductPeer::POSITION, $position, $comparison);
 805:     }
 806: 
 807:     /**
 808:      * Filter the query on the created_at column
 809:      *
 810:      * Example usage:
 811:      * <code>
 812:      * $query->filterByCreatedAt('2011-03-14'); // WHERE created_at = '2011-03-14'
 813:      * $query->filterByCreatedAt('now'); // WHERE created_at = '2011-03-14'
 814:      * $query->filterByCreatedAt(array('max' => 'yesterday')); // WHERE created_at > '2011-03-13'
 815:      * </code>
 816:      *
 817:      * @param     mixed $createdAt The value to use as filter.
 818:      *              Values can be integers (unix timestamps), DateTime objects, or strings.
 819:      *              Empty strings are treated as NULL.
 820:      *              Use scalar values for equality.
 821:      *              Use array values for in_array() equivalent.
 822:      *              Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
 823:      * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
 824:      *
 825:      * @return ProductQuery The current query, for fluid interface
 826:      */
 827:     public function filterByCreatedAt($createdAt = null, $comparison = null)
 828:     {
 829:         if (is_array($createdAt)) {
 830:             $useMinMax = false;
 831:             if (isset($createdAt['min'])) {
 832:                 $this->addUsingAlias(ProductPeer::CREATED_AT, $createdAt['min'], Criteria::GREATER_EQUAL);
 833:                 $useMinMax = true;
 834:             }
 835:             if (isset($createdAt['max'])) {
 836:                 $this->addUsingAlias(ProductPeer::CREATED_AT, $createdAt['max'], Criteria::LESS_EQUAL);
 837:                 $useMinMax = true;
 838:             }
 839:             if ($useMinMax) {
 840:                 return $this;
 841:             }
 842:             if (null === $comparison) {
 843:                 $comparison = Criteria::IN;
 844:             }
 845:         }
 846: 
 847:         return $this->addUsingAlias(ProductPeer::CREATED_AT, $createdAt, $comparison);
 848:     }
 849: 
 850:     /**
 851:      * Filter the query on the updated_at column
 852:      *
 853:      * Example usage:
 854:      * <code>
 855:      * $query->filterByUpdatedAt('2011-03-14'); // WHERE updated_at = '2011-03-14'
 856:      * $query->filterByUpdatedAt('now'); // WHERE updated_at = '2011-03-14'
 857:      * $query->filterByUpdatedAt(array('max' => 'yesterday')); // WHERE updated_at > '2011-03-13'
 858:      * </code>
 859:      *
 860:      * @param     mixed $updatedAt The value to use as filter.
 861:      *              Values can be integers (unix timestamps), DateTime objects, or strings.
 862:      *              Empty strings are treated as NULL.
 863:      *              Use scalar values for equality.
 864:      *              Use array values for in_array() equivalent.
 865:      *              Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
 866:      * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
 867:      *
 868:      * @return ProductQuery The current query, for fluid interface
 869:      */
 870:     public function filterByUpdatedAt($updatedAt = null, $comparison = null)
 871:     {
 872:         if (is_array($updatedAt)) {
 873:             $useMinMax = false;
 874:             if (isset($updatedAt['min'])) {
 875:                 $this->addUsingAlias(ProductPeer::UPDATED_AT, $updatedAt['min'], Criteria::GREATER_EQUAL);
 876:                 $useMinMax = true;
 877:             }
 878:             if (isset($updatedAt['max'])) {
 879:                 $this->addUsingAlias(ProductPeer::UPDATED_AT, $updatedAt['max'], Criteria::LESS_EQUAL);
 880:                 $useMinMax = true;
 881:             }
 882:             if ($useMinMax) {
 883:                 return $this;
 884:             }
 885:             if (null === $comparison) {
 886:                 $comparison = Criteria::IN;
 887:             }
 888:         }
 889: 
 890:         return $this->addUsingAlias(ProductPeer::UPDATED_AT, $updatedAt, $comparison);
 891:     }
 892: 
 893:     /**
 894:      * Filter the query on the version column
 895:      *
 896:      * Example usage:
 897:      * <code>
 898:      * $query->filterByVersion(1234); // WHERE version = 1234
 899:      * $query->filterByVersion(array(12, 34)); // WHERE version IN (12, 34)
 900:      * $query->filterByVersion(array('min' => 12)); // WHERE version > 12
 901:      * </code>
 902:      *
 903:      * @param     mixed $version The value to use as filter.
 904:      *              Use scalar values for equality.
 905:      *              Use array values for in_array() equivalent.
 906:      *              Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
 907:      * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
 908:      *
 909:      * @return ProductQuery The current query, for fluid interface
 910:      */
 911:     public function filterByVersion($version = null, $comparison = null)
 912:     {
 913:         if (is_array($version)) {
 914:             $useMinMax = false;
 915:             if (isset($version['min'])) {
 916:                 $this->addUsingAlias(ProductPeer::VERSION, $version['min'], Criteria::GREATER_EQUAL);
 917:                 $useMinMax = true;
 918:             }
 919:             if (isset($version['max'])) {
 920:                 $this->addUsingAlias(ProductPeer::VERSION, $version['max'], Criteria::LESS_EQUAL);
 921:                 $useMinMax = true;
 922:             }
 923:             if ($useMinMax) {
 924:                 return $this;
 925:             }
 926:             if (null === $comparison) {
 927:                 $comparison = Criteria::IN;
 928:             }
 929:         }
 930: 
 931:         return $this->addUsingAlias(ProductPeer::VERSION, $version, $comparison);
 932:     }
 933: 
 934:     /**
 935:      * Filter the query on the version_created_at column
 936:      *
 937:      * Example usage:
 938:      * <code>
 939:      * $query->filterByVersionCreatedAt('2011-03-14'); // WHERE version_created_at = '2011-03-14'
 940:      * $query->filterByVersionCreatedAt('now'); // WHERE version_created_at = '2011-03-14'
 941:      * $query->filterByVersionCreatedAt(array('max' => 'yesterday')); // WHERE version_created_at > '2011-03-13'
 942:      * </code>
 943:      *
 944:      * @param     mixed $versionCreatedAt The value to use as filter.
 945:      *              Values can be integers (unix timestamps), DateTime objects, or strings.
 946:      *              Empty strings are treated as NULL.
 947:      *              Use scalar values for equality.
 948:      *              Use array values for in_array() equivalent.
 949:      *              Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
 950:      * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
 951:      *
 952:      * @return ProductQuery The current query, for fluid interface
 953:      */
 954:     public function filterByVersionCreatedAt($versionCreatedAt = null, $comparison = null)
 955:     {
 956:         if (is_array($versionCreatedAt)) {
 957:             $useMinMax = false;
 958:             if (isset($versionCreatedAt['min'])) {
 959:                 $this->addUsingAlias(ProductPeer::VERSION_CREATED_AT, $versionCreatedAt['min'], Criteria::GREATER_EQUAL);
 960:                 $useMinMax = true;
 961:             }
 962:             if (isset($versionCreatedAt['max'])) {
 963:                 $this->addUsingAlias(ProductPeer::VERSION_CREATED_AT, $versionCreatedAt['max'], Criteria::LESS_EQUAL);
 964:                 $useMinMax = true;
 965:             }
 966:             if ($useMinMax) {
 967:                 return $this;
 968:             }
 969:             if (null === $comparison) {
 970:                 $comparison = Criteria::IN;
 971:             }
 972:         }
 973: 
 974:         return $this->addUsingAlias(ProductPeer::VERSION_CREATED_AT, $versionCreatedAt, $comparison);
 975:     }
 976: 
 977:     /**
 978:      * Filter the query on the version_created_by column
 979:      *
 980:      * Example usage:
 981:      * <code>
 982:      * $query->filterByVersionCreatedBy('fooValue');   // WHERE version_created_by = 'fooValue'
 983:      * $query->filterByVersionCreatedBy('%fooValue%'); // WHERE version_created_by LIKE '%fooValue%'
 984:      * </code>
 985:      *
 986:      * @param     string $versionCreatedBy The value to use as filter.
 987:      *              Accepts wildcards (* and % trigger a LIKE)
 988:      * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
 989:      *
 990:      * @return ProductQuery The current query, for fluid interface
 991:      */
 992:     public function filterByVersionCreatedBy($versionCreatedBy = null, $comparison = null)
 993:     {
 994:         if (null === $comparison) {
 995:             if (is_array($versionCreatedBy)) {
 996:                 $comparison = Criteria::IN;
 997:             } elseif (preg_match('/[\%\*]/', $versionCreatedBy)) {
 998:                 $versionCreatedBy = str_replace('*', '%', $versionCreatedBy);
 999:                 $comparison = Criteria::LIKE;
1000:             }
1001:         }
1002: 
1003:         return $this->addUsingAlias(ProductPeer::VERSION_CREATED_BY, $versionCreatedBy, $comparison);
1004:     }
1005: 
1006:     /**
1007:      * Filter the query by a related TaxRule object
1008:      *
1009:      * @param   TaxRule|PropelObjectCollection $taxRule The related object(s) to use as filter
1010:      * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
1011:      *
1012:      * @return   ProductQuery The current query, for fluid interface
1013:      * @throws   PropelException - if the provided filter is invalid.
1014:      */
1015:     public function filterByTaxRule($taxRule, $comparison = null)
1016:     {
1017:         if ($taxRule instanceof TaxRule) {
1018:             return $this
1019:                 ->addUsingAlias(ProductPeer::TAX_RULE_ID, $taxRule->getId(), $comparison);
1020:         } elseif ($taxRule instanceof PropelObjectCollection) {
1021:             if (null === $comparison) {
1022:                 $comparison = Criteria::IN;
1023:             }
1024: 
1025:             return $this
1026:                 ->addUsingAlias(ProductPeer::TAX_RULE_ID, $taxRule->toKeyValue('PrimaryKey', 'Id'), $comparison);
1027:         } else {
1028:             throw new PropelException('filterByTaxRule() only accepts arguments of type TaxRule or PropelCollection');
1029:         }
1030:     }
1031: 
1032:     /**
1033:      * Adds a JOIN clause to the query using the TaxRule relation
1034:      *
1035:      * @param     string $relationAlias optional alias for the relation
1036:      * @param     string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
1037:      *
1038:      * @return ProductQuery The current query, for fluid interface
1039:      */
1040:     public function joinTaxRule($relationAlias = null, $joinType = Criteria::LEFT_JOIN)
1041:     {
1042:         $tableMap = $this->getTableMap();
1043:         $relationMap = $tableMap->getRelation('TaxRule');
1044: 
1045:         // create a ModelJoin object for this join
1046:         $join = new ModelJoin();
1047:         $join->setJoinType($joinType);
1048:         $join->setRelationMap($relationMap, $this->useAliasInSQL ? $this->getModelAlias() : null, $relationAlias);
1049:         if ($previousJoin = $this->getPreviousJoin()) {
1050:             $join->setPreviousJoin($previousJoin);
1051:         }
1052: 
1053:         // add the ModelJoin to the current object
1054:         if ($relationAlias) {
1055:             $this->addAlias($relationAlias, $relationMap->getRightTable()->getName());
1056:             $this->addJoinObject($join, $relationAlias);
1057:         } else {
1058:             $this->addJoinObject($join, 'TaxRule');
1059:         }
1060: 
1061:         return $this;
1062:     }
1063: 
1064:     /**
1065:      * Use the TaxRule relation TaxRule object
1066:      *
1067:      * @see       useQuery()
1068:      *
1069:      * @param     string $relationAlias optional alias for the relation,
1070:      *                                   to be used as main alias in the secondary query
1071:      * @param     string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
1072:      *
1073:      * @return   \Thelia\Model\TaxRuleQuery A secondary query class using the current class as primary query
1074:      */
1075:     public function useTaxRuleQuery($relationAlias = null, $joinType = Criteria::LEFT_JOIN)
1076:     {
1077:         return $this
1078:             ->joinTaxRule($relationAlias, $joinType)
1079:             ->useQuery($relationAlias ? $relationAlias : 'TaxRule', '\Thelia\Model\TaxRuleQuery');
1080:     }
1081: 
1082:     /**
1083:      * Filter the query by a related ProductCategory object
1084:      *
1085:      * @param   ProductCategory|PropelObjectCollection $productCategory  the related object to use as filter
1086:      * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
1087:      *
1088:      * @return   ProductQuery The current query, for fluid interface
1089:      * @throws   PropelException - if the provided filter is invalid.
1090:      */
1091:     public function filterByProductCategory($productCategory, $comparison = null)
1092:     {
1093:         if ($productCategory instanceof ProductCategory) {
1094:             return $this
1095:                 ->addUsingAlias(ProductPeer::ID, $productCategory->getProductId(), $comparison);
1096:         } elseif ($productCategory instanceof PropelObjectCollection) {
1097:             return $this
1098:                 ->useProductCategoryQuery()
1099:                 ->filterByPrimaryKeys($productCategory->getPrimaryKeys())
1100:                 ->endUse();
1101:         } else {
1102:             throw new PropelException('filterByProductCategory() only accepts arguments of type ProductCategory or PropelCollection');
1103:         }
1104:     }
1105: 
1106:     /**
1107:      * Adds a JOIN clause to the query using the ProductCategory relation
1108:      *
1109:      * @param     string $relationAlias optional alias for the relation
1110:      * @param     string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
1111:      *
1112:      * @return ProductQuery The current query, for fluid interface
1113:      */
1114:     public function joinProductCategory($relationAlias = null, $joinType = Criteria::INNER_JOIN)
1115:     {
1116:         $tableMap = $this->getTableMap();
1117:         $relationMap = $tableMap->getRelation('ProductCategory');
1118: 
1119:         // create a ModelJoin object for this join
1120:         $join = new ModelJoin();
1121:         $join->setJoinType($joinType);
1122:         $join->setRelationMap($relationMap, $this->useAliasInSQL ? $this->getModelAlias() : null, $relationAlias);
1123:         if ($previousJoin = $this->getPreviousJoin()) {
1124:             $join->setPreviousJoin($previousJoin);
1125:         }
1126: 
1127:         // add the ModelJoin to the current object
1128:         if ($relationAlias) {
1129:             $this->addAlias($relationAlias, $relationMap->getRightTable()->getName());
1130:             $this->addJoinObject($join, $relationAlias);
1131:         } else {
1132:             $this->addJoinObject($join, 'ProductCategory');
1133:         }
1134: 
1135:         return $this;
1136:     }
1137: 
1138:     /**
1139:      * Use the ProductCategory relation ProductCategory object
1140:      *
1141:      * @see       useQuery()
1142:      *
1143:      * @param     string $relationAlias optional alias for the relation,
1144:      *                                   to be used as main alias in the secondary query
1145:      * @param     string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
1146:      *
1147:      * @return   \Thelia\Model\ProductCategoryQuery A secondary query class using the current class as primary query
1148:      */
1149:     public function useProductCategoryQuery($relationAlias = null, $joinType = Criteria::INNER_JOIN)
1150:     {
1151:         return $this
1152:             ->joinProductCategory($relationAlias, $joinType)
1153:             ->useQuery($relationAlias ? $relationAlias : 'ProductCategory', '\Thelia\Model\ProductCategoryQuery');
1154:     }
1155: 
1156:     /**
1157:      * Filter the query by a related FeatureProd object
1158:      *
1159:      * @param   FeatureProd|PropelObjectCollection $featureProd  the related object to use as filter
1160:      * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
1161:      *
1162:      * @return   ProductQuery The current query, for fluid interface
1163:      * @throws   PropelException - if the provided filter is invalid.
1164:      */
1165:     public function filterByFeatureProd($featureProd, $comparison = null)
1166:     {
1167:         if ($featureProd instanceof FeatureProd) {
1168:             return $this
1169:                 ->addUsingAlias(ProductPeer::ID, $featureProd->getProductId(), $comparison);
1170:         } elseif ($featureProd instanceof PropelObjectCollection) {
1171:             return $this
1172:                 ->useFeatureProdQuery()
1173:                 ->filterByPrimaryKeys($featureProd->getPrimaryKeys())
1174:                 ->endUse();
1175:         } else {
1176:             throw new PropelException('filterByFeatureProd() only accepts arguments of type FeatureProd or PropelCollection');
1177:         }
1178:     }
1179: 
1180:     /**
1181:      * Adds a JOIN clause to the query using the FeatureProd relation
1182:      *
1183:      * @param     string $relationAlias optional alias for the relation
1184:      * @param     string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
1185:      *
1186:      * @return ProductQuery The current query, for fluid interface
1187:      */
1188:     public function joinFeatureProd($relationAlias = null, $joinType = Criteria::INNER_JOIN)
1189:     {
1190:         $tableMap = $this->getTableMap();
1191:         $relationMap = $tableMap->getRelation('FeatureProd');
1192: 
1193:         // create a ModelJoin object for this join
1194:         $join = new ModelJoin();
1195:         $join->setJoinType($joinType);
1196:         $join->setRelationMap($relationMap, $this->useAliasInSQL ? $this->getModelAlias() : null, $relationAlias);
1197:         if ($previousJoin = $this->getPreviousJoin()) {
1198:             $join->setPreviousJoin($previousJoin);
1199:         }
1200: 
1201:         // add the ModelJoin to the current object
1202:         if ($relationAlias) {
1203:             $this->addAlias($relationAlias, $relationMap->getRightTable()->getName());
1204:             $this->addJoinObject($join, $relationAlias);
1205:         } else {
1206:             $this->addJoinObject($join, 'FeatureProd');
1207:         }
1208: 
1209:         return $this;
1210:     }
1211: 
1212:     /**
1213:      * Use the FeatureProd relation FeatureProd object
1214:      *
1215:      * @see       useQuery()
1216:      *
1217:      * @param     string $relationAlias optional alias for the relation,
1218:      *                                   to be used as main alias in the secondary query
1219:      * @param     string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
1220:      *
1221:      * @return   \Thelia\Model\FeatureProdQuery A secondary query class using the current class as primary query
1222:      */
1223:     public function useFeatureProdQuery($relationAlias = null, $joinType = Criteria::INNER_JOIN)
1224:     {
1225:         return $this
1226:             ->joinFeatureProd($relationAlias, $joinType)
1227:             ->useQuery($relationAlias ? $relationAlias : 'FeatureProd', '\Thelia\Model\FeatureProdQuery');
1228:     }
1229: 
1230:     /**
1231:      * Filter the query by a related Stock object
1232:      *
1233:      * @param   Stock|PropelObjectCollection $stock  the related object to use as filter
1234:      * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
1235:      *
1236:      * @return   ProductQuery The current query, for fluid interface
1237:      * @throws   PropelException - if the provided filter is invalid.
1238:      */
1239:     public function filterByStock($stock, $comparison = null)
1240:     {
1241:         if ($stock instanceof Stock) {
1242:             return $this
1243:                 ->addUsingAlias(ProductPeer::ID, $stock->getProductId(), $comparison);
1244:         } elseif ($stock instanceof PropelObjectCollection) {
1245:             return $this
1246:                 ->useStockQuery()
1247:                 ->filterByPrimaryKeys($stock->getPrimaryKeys())
1248:                 ->endUse();
1249:         } else {
1250:             throw new PropelException('filterByStock() only accepts arguments of type Stock or PropelCollection');
1251:         }
1252:     }
1253: 
1254:     /**
1255:      * Adds a JOIN clause to the query using the Stock relation
1256:      *
1257:      * @param     string $relationAlias optional alias for the relation
1258:      * @param     string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
1259:      *
1260:      * @return ProductQuery The current query, for fluid interface
1261:      */
1262:     public function joinStock($relationAlias = null, $joinType = Criteria::INNER_JOIN)
1263:     {
1264:         $tableMap = $this->getTableMap();
1265:         $relationMap = $tableMap->getRelation('Stock');
1266: 
1267:         // create a ModelJoin object for this join
1268:         $join = new ModelJoin();
1269:         $join->setJoinType($joinType);
1270:         $join->setRelationMap($relationMap, $this->useAliasInSQL ? $this->getModelAlias() : null, $relationAlias);
1271:         if ($previousJoin = $this->getPreviousJoin()) {
1272:             $join->setPreviousJoin($previousJoin);
1273:         }
1274: 
1275:         // add the ModelJoin to the current object
1276:         if ($relationAlias) {
1277:             $this->addAlias($relationAlias, $relationMap->getRightTable()->getName());
1278:             $this->addJoinObject($join, $relationAlias);
1279:         } else {
1280:             $this->addJoinObject($join, 'Stock');
1281:         }
1282: 
1283:         return $this;
1284:     }
1285: 
1286:     /**
1287:      * Use the Stock relation Stock object
1288:      *
1289:      * @see       useQuery()
1290:      *
1291:      * @param     string $relationAlias optional alias for the relation,
1292:      *                                   to be used as main alias in the secondary query
1293:      * @param     string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
1294:      *
1295:      * @return   \Thelia\Model\StockQuery A secondary query class using the current class as primary query
1296:      */
1297:     public function useStockQuery($relationAlias = null, $joinType = Criteria::INNER_JOIN)
1298:     {
1299:         return $this
1300:             ->joinStock($relationAlias, $joinType)
1301:             ->useQuery($relationAlias ? $relationAlias : 'Stock', '\Thelia\Model\StockQuery');
1302:     }
1303: 
1304:     /**
1305:      * Filter the query by a related ContentAssoc object
1306:      *
1307:      * @param   ContentAssoc|PropelObjectCollection $contentAssoc  the related object to use as filter
1308:      * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
1309:      *
1310:      * @return   ProductQuery The current query, for fluid interface
1311:      * @throws   PropelException - if the provided filter is invalid.
1312:      */
1313:     public function filterByContentAssoc($contentAssoc, $comparison = null)
1314:     {
1315:         if ($contentAssoc instanceof ContentAssoc) {
1316:             return $this
1317:                 ->addUsingAlias(ProductPeer::ID, $contentAssoc->getProductId(), $comparison);
1318:         } elseif ($contentAssoc instanceof PropelObjectCollection) {
1319:             return $this
1320:                 ->useContentAssocQuery()
1321:                 ->filterByPrimaryKeys($contentAssoc->getPrimaryKeys())
1322:                 ->endUse();
1323:         } else {
1324:             throw new PropelException('filterByContentAssoc() only accepts arguments of type ContentAssoc or PropelCollection');
1325:         }
1326:     }
1327: 
1328:     /**
1329:      * Adds a JOIN clause to the query using the ContentAssoc relation
1330:      *
1331:      * @param     string $relationAlias optional alias for the relation
1332:      * @param     string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
1333:      *
1334:      * @return ProductQuery The current query, for fluid interface
1335:      */
1336:     public function joinContentAssoc($relationAlias = null, $joinType = Criteria::LEFT_JOIN)
1337:     {
1338:         $tableMap = $this->getTableMap();
1339:         $relationMap = $tableMap->getRelation('ContentAssoc');
1340: 
1341:         // create a ModelJoin object for this join
1342:         $join = new ModelJoin();
1343:         $join->setJoinType($joinType);
1344:         $join->setRelationMap($relationMap, $this->useAliasInSQL ? $this->getModelAlias() : null, $relationAlias);
1345:         if ($previousJoin = $this->getPreviousJoin()) {
1346:             $join->setPreviousJoin($previousJoin);
1347:         }
1348: 
1349:         // add the ModelJoin to the current object
1350:         if ($relationAlias) {
1351:             $this->addAlias($relationAlias, $relationMap->getRightTable()->getName());
1352:             $this->addJoinObject($join, $relationAlias);
1353:         } else {
1354:             $this->addJoinObject($join, 'ContentAssoc');
1355:         }
1356: 
1357:         return $this;
1358:     }
1359: 
1360:     /**
1361:      * Use the ContentAssoc relation ContentAssoc object
1362:      *
1363:      * @see       useQuery()
1364:      *
1365:      * @param     string $relationAlias optional alias for the relation,
1366:      *                                   to be used as main alias in the secondary query
1367:      * @param     string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
1368:      *
1369:      * @return   \Thelia\Model\ContentAssocQuery A secondary query class using the current class as primary query
1370:      */
1371:     public function useContentAssocQuery($relationAlias = null, $joinType = Criteria::LEFT_JOIN)
1372:     {
1373:         return $this
1374:             ->joinContentAssoc($relationAlias, $joinType)
1375:             ->useQuery($relationAlias ? $relationAlias : 'ContentAssoc', '\Thelia\Model\ContentAssocQuery');
1376:     }
1377: 
1378:     /**
1379:      * Filter the query by a related Image object
1380:      *
1381:      * @param   Image|PropelObjectCollection $image  the related object to use as filter
1382:      * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
1383:      *
1384:      * @return   ProductQuery The current query, for fluid interface
1385:      * @throws   PropelException - if the provided filter is invalid.
1386:      */
1387:     public function filterByImage($image, $comparison = null)
1388:     {
1389:         if ($image instanceof Image) {
1390:             return $this
1391:                 ->addUsingAlias(ProductPeer::ID, $image->getProductId(), $comparison);
1392:         } elseif ($image instanceof PropelObjectCollection) {
1393:             return $this
1394:                 ->useImageQuery()
1395:                 ->filterByPrimaryKeys($image->getPrimaryKeys())
1396:                 ->endUse();
1397:         } else {
1398:             throw new PropelException('filterByImage() only accepts arguments of type Image or PropelCollection');
1399:         }
1400:     }
1401: 
1402:     /**
1403:      * Adds a JOIN clause to the query using the Image relation
1404:      *
1405:      * @param     string $relationAlias optional alias for the relation
1406:      * @param     string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
1407:      *
1408:      * @return ProductQuery The current query, for fluid interface
1409:      */
1410:     public function joinImage($relationAlias = null, $joinType = Criteria::LEFT_JOIN)
1411:     {
1412:         $tableMap = $this->getTableMap();
1413:         $relationMap = $tableMap->getRelation('Image');
1414: 
1415:         // create a ModelJoin object for this join
1416:         $join = new ModelJoin();
1417:         $join->setJoinType($joinType);
1418:         $join->setRelationMap($relationMap, $this->useAliasInSQL ? $this->getModelAlias() : null, $relationAlias);
1419:         if ($previousJoin = $this->getPreviousJoin()) {
1420:             $join->setPreviousJoin($previousJoin);
1421:         }
1422: 
1423:         // add the ModelJoin to the current object
1424:         if ($relationAlias) {
1425:             $this->addAlias($relationAlias, $relationMap->getRightTable()->getName());
1426:             $this->addJoinObject($join, $relationAlias);
1427:         } else {
1428:             $this->addJoinObject($join, 'Image');
1429:         }
1430: 
1431:         return $this;
1432:     }
1433: 
1434:     /**
1435:      * Use the Image relation Image object
1436:      *
1437:      * @see       useQuery()
1438:      *
1439:      * @param     string $relationAlias optional alias for the relation,
1440:      *                                   to be used as main alias in the secondary query
1441:      * @param     string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
1442:      *
1443:      * @return   \Thelia\Model\ImageQuery A secondary query class using the current class as primary query
1444:      */
1445:     public function useImageQuery($relationAlias = null, $joinType = Criteria::LEFT_JOIN)
1446:     {
1447:         return $this
1448:             ->joinImage($relationAlias, $joinType)
1449:             ->useQuery($relationAlias ? $relationAlias : 'Image', '\Thelia\Model\ImageQuery');
1450:     }
1451: 
1452:     /**
1453:      * Filter the query by a related Document object
1454:      *
1455:      * @param   Document|PropelObjectCollection $document  the related object to use as filter
1456:      * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
1457:      *
1458:      * @return   ProductQuery The current query, for fluid interface
1459:      * @throws   PropelException - if the provided filter is invalid.
1460:      */
1461:     public function filterByDocument($document, $comparison = null)
1462:     {
1463:         if ($document instanceof Document) {
1464:             return $this
1465:                 ->addUsingAlias(ProductPeer::ID, $document->getProductId(), $comparison);
1466:         } elseif ($document instanceof PropelObjectCollection) {
1467:             return $this
1468:                 ->useDocumentQuery()
1469:                 ->filterByPrimaryKeys($document->getPrimaryKeys())
1470:                 ->endUse();
1471:         } else {
1472:             throw new PropelException('filterByDocument() only accepts arguments of type Document or PropelCollection');
1473:         }
1474:     }
1475: 
1476:     /**
1477:      * Adds a JOIN clause to the query using the Document relation
1478:      *
1479:      * @param     string $relationAlias optional alias for the relation
1480:      * @param     string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
1481:      *
1482:      * @return ProductQuery The current query, for fluid interface
1483:      */
1484:     public function joinDocument($relationAlias = null, $joinType = Criteria::LEFT_JOIN)
1485:     {
1486:         $tableMap = $this->getTableMap();
1487:         $relationMap = $tableMap->getRelation('Document');
1488: 
1489:         // create a ModelJoin object for this join
1490:         $join = new ModelJoin();
1491:         $join->setJoinType($joinType);
1492:         $join->setRelationMap($relationMap, $this->useAliasInSQL ? $this->getModelAlias() : null, $relationAlias);
1493:         if ($previousJoin = $this->getPreviousJoin()) {
1494:             $join->setPreviousJoin($previousJoin);
1495:         }
1496: 
1497:         // add the ModelJoin to the current object
1498:         if ($relationAlias) {
1499:             $this->addAlias($relationAlias, $relationMap->getRightTable()->getName());
1500:             $this->addJoinObject($join, $relationAlias);
1501:         } else {
1502:             $this->addJoinObject($join, 'Document');
1503:         }
1504: 
1505:         return $this;
1506:     }
1507: 
1508:     /**
1509:      * Use the Document relation Document object
1510:      *
1511:      * @see       useQuery()
1512:      *
1513:      * @param     string $relationAlias optional alias for the relation,
1514:      *                                   to be used as main alias in the secondary query
1515:      * @param     string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
1516:      *
1517:      * @return   \Thelia\Model\DocumentQuery A secondary query class using the current class as primary query
1518:      */
1519:     public function useDocumentQuery($relationAlias = null, $joinType = Criteria::LEFT_JOIN)
1520:     {
1521:         return $this
1522:             ->joinDocument($relationAlias, $joinType)
1523:             ->useQuery($relationAlias ? $relationAlias : 'Document', '\Thelia\Model\DocumentQuery');
1524:     }
1525: 
1526:     /**
1527:      * Filter the query by a related Accessory object
1528:      *
1529:      * @param   Accessory|PropelObjectCollection $accessory  the related object to use as filter
1530:      * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
1531:      *
1532:      * @return   ProductQuery The current query, for fluid interface
1533:      * @throws   PropelException - if the provided filter is invalid.
1534:      */
1535:     public function filterByAccessoryRelatedByProductId($accessory, $comparison = null)
1536:     {
1537:         if ($accessory instanceof Accessory) {
1538:             return $this
1539:                 ->addUsingAlias(ProductPeer::ID, $accessory->getProductId(), $comparison);
1540:         } elseif ($accessory instanceof PropelObjectCollection) {
1541:             return $this
1542:                 ->useAccessoryRelatedByProductIdQuery()
1543:                 ->filterByPrimaryKeys($accessory->getPrimaryKeys())
1544:                 ->endUse();
1545:         } else {
1546:             throw new PropelException('filterByAccessoryRelatedByProductId() only accepts arguments of type Accessory or PropelCollection');
1547:         }
1548:     }
1549: 
1550:     /**
1551:      * Adds a JOIN clause to the query using the AccessoryRelatedByProductId relation
1552:      *
1553:      * @param     string $relationAlias optional alias for the relation
1554:      * @param     string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
1555:      *
1556:      * @return ProductQuery The current query, for fluid interface
1557:      */
1558:     public function joinAccessoryRelatedByProductId($relationAlias = null, $joinType = Criteria::INNER_JOIN)
1559:     {
1560:         $tableMap = $this->getTableMap();
1561:         $relationMap = $tableMap->getRelation('AccessoryRelatedByProductId');
1562: 
1563:         // create a ModelJoin object for this join
1564:         $join = new ModelJoin();
1565:         $join->setJoinType($joinType);
1566:         $join->setRelationMap($relationMap, $this->useAliasInSQL ? $this->getModelAlias() : null, $relationAlias);
1567:         if ($previousJoin = $this->getPreviousJoin()) {
1568:             $join->setPreviousJoin($previousJoin);
1569:         }
1570: 
1571:         // add the ModelJoin to the current object
1572:         if ($relationAlias) {
1573:             $this->addAlias($relationAlias, $relationMap->getRightTable()->getName());
1574:             $this->addJoinObject($join, $relationAlias);
1575:         } else {
1576:             $this->addJoinObject($join, 'AccessoryRelatedByProductId');
1577:         }
1578: 
1579:         return $this;
1580:     }
1581: 
1582:     /**
1583:      * Use the AccessoryRelatedByProductId relation Accessory object
1584:      *
1585:      * @see       useQuery()
1586:      *
1587:      * @param     string $relationAlias optional alias for the relation,
1588:      *                                   to be used as main alias in the secondary query
1589:      * @param     string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
1590:      *
1591:      * @return   \Thelia\Model\AccessoryQuery A secondary query class using the current class as primary query
1592:      */
1593:     public function useAccessoryRelatedByProductIdQuery($relationAlias = null, $joinType = Criteria::INNER_JOIN)
1594:     {
1595:         return $this
1596:             ->joinAccessoryRelatedByProductId($relationAlias, $joinType)
1597:             ->useQuery($relationAlias ? $relationAlias : 'AccessoryRelatedByProductId', '\Thelia\Model\AccessoryQuery');
1598:     }
1599: 
1600:     /**
1601:      * Filter the query by a related Accessory object
1602:      *
1603:      * @param   Accessory|PropelObjectCollection $accessory  the related object to use as filter
1604:      * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
1605:      *
1606:      * @return   ProductQuery The current query, for fluid interface
1607:      * @throws   PropelException - if the provided filter is invalid.
1608:      */
1609:     public function filterByAccessoryRelatedByAccessory($accessory, $comparison = null)
1610:     {
1611:         if ($accessory instanceof Accessory) {
1612:             return $this
1613:                 ->addUsingAlias(ProductPeer::ID, $accessory->getAccessory(), $comparison);
1614:         } elseif ($accessory instanceof PropelObjectCollection) {
1615:             return $this
1616:                 ->useAccessoryRelatedByAccessoryQuery()
1617:                 ->filterByPrimaryKeys($accessory->getPrimaryKeys())
1618:                 ->endUse();
1619:         } else {
1620:             throw new PropelException('filterByAccessoryRelatedByAccessory() only accepts arguments of type Accessory or PropelCollection');
1621:         }
1622:     }
1623: 
1624:     /**
1625:      * Adds a JOIN clause to the query using the AccessoryRelatedByAccessory relation
1626:      *
1627:      * @param     string $relationAlias optional alias for the relation
1628:      * @param     string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
1629:      *
1630:      * @return ProductQuery The current query, for fluid interface
1631:      */
1632:     public function joinAccessoryRelatedByAccessory($relationAlias = null, $joinType = Criteria::INNER_JOIN)
1633:     {
1634:         $tableMap = $this->getTableMap();
1635:         $relationMap = $tableMap->getRelation('AccessoryRelatedByAccessory');
1636: 
1637:         // create a ModelJoin object for this join
1638:         $join = new ModelJoin();
1639:         $join->setJoinType($joinType);
1640:         $join->setRelationMap($relationMap, $this->useAliasInSQL ? $this->getModelAlias() : null, $relationAlias);
1641:         if ($previousJoin = $this->getPreviousJoin()) {
1642:             $join->setPreviousJoin($previousJoin);
1643:         }
1644: 
1645:         // add the ModelJoin to the current object
1646:         if ($relationAlias) {
1647:             $this->addAlias($relationAlias, $relationMap->getRightTable()->getName());
1648:             $this->addJoinObject($join, $relationAlias);
1649:         } else {
1650:             $this->addJoinObject($join, 'AccessoryRelatedByAccessory');
1651:         }
1652: 
1653:         return $this;
1654:     }
1655: 
1656:     /**
1657:      * Use the AccessoryRelatedByAccessory relation Accessory object
1658:      *
1659:      * @see       useQuery()
1660:      *
1661:      * @param     string $relationAlias optional alias for the relation,
1662:      *                                   to be used as main alias in the secondary query
1663:      * @param     string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
1664:      *
1665:      * @return   \Thelia\Model\AccessoryQuery A secondary query class using the current class as primary query
1666:      */
1667:     public function useAccessoryRelatedByAccessoryQuery($relationAlias = null, $joinType = Criteria::INNER_JOIN)
1668:     {
1669:         return $this
1670:             ->joinAccessoryRelatedByAccessory($relationAlias, $joinType)
1671:             ->useQuery($relationAlias ? $relationAlias : 'AccessoryRelatedByAccessory', '\Thelia\Model\AccessoryQuery');
1672:     }
1673: 
1674:     /**
1675:      * Filter the query by a related Rewriting object
1676:      *
1677:      * @param   Rewriting|PropelObjectCollection $rewriting  the related object to use as filter
1678:      * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
1679:      *
1680:      * @return   ProductQuery The current query, for fluid interface
1681:      * @throws   PropelException - if the provided filter is invalid.
1682:      */
1683:     public function filterByRewriting($rewriting, $comparison = null)
1684:     {
1685:         if ($rewriting instanceof Rewriting) {
1686:             return $this
1687:                 ->addUsingAlias(ProductPeer::ID, $rewriting->getProductId(), $comparison);
1688:         } elseif ($rewriting instanceof PropelObjectCollection) {
1689:             return $this
1690:                 ->useRewritingQuery()
1691:                 ->filterByPrimaryKeys($rewriting->getPrimaryKeys())
1692:                 ->endUse();
1693:         } else {
1694:             throw new PropelException('filterByRewriting() only accepts arguments of type Rewriting or PropelCollection');
1695:         }
1696:     }
1697: 
1698:     /**
1699:      * Adds a JOIN clause to the query using the Rewriting relation
1700:      *
1701:      * @param     string $relationAlias optional alias for the relation
1702:      * @param     string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
1703:      *
1704:      * @return ProductQuery The current query, for fluid interface
1705:      */
1706:     public function joinRewriting($relationAlias = null, $joinType = Criteria::LEFT_JOIN)
1707:     {
1708:         $tableMap = $this->getTableMap();
1709:         $relationMap = $tableMap->getRelation('Rewriting');
1710: 
1711:         // create a ModelJoin object for this join
1712:         $join = new ModelJoin();
1713:         $join->setJoinType($joinType);
1714:         $join->setRelationMap($relationMap, $this->useAliasInSQL ? $this->getModelAlias() : null, $relationAlias);
1715:         if ($previousJoin = $this->getPreviousJoin()) {
1716:             $join->setPreviousJoin($previousJoin);
1717:         }
1718: 
1719:         // add the ModelJoin to the current object
1720:         if ($relationAlias) {
1721:             $this->addAlias($relationAlias, $relationMap->getRightTable()->getName());
1722:             $this->addJoinObject($join, $relationAlias);
1723:         } else {
1724:             $this->addJoinObject($join, 'Rewriting');
1725:         }
1726: 
1727:         return $this;
1728:     }
1729: 
1730:     /**
1731:      * Use the Rewriting relation Rewriting object
1732:      *
1733:      * @see       useQuery()
1734:      *
1735:      * @param     string $relationAlias optional alias for the relation,
1736:      *                                   to be used as main alias in the secondary query
1737:      * @param     string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
1738:      *
1739:      * @return   \Thelia\Model\RewritingQuery A secondary query class using the current class as primary query
1740:      */
1741:     public function useRewritingQuery($relationAlias = null, $joinType = Criteria::LEFT_JOIN)
1742:     {
1743:         return $this
1744:             ->joinRewriting($relationAlias, $joinType)
1745:             ->useQuery($relationAlias ? $relationAlias : 'Rewriting', '\Thelia\Model\RewritingQuery');
1746:     }
1747: 
1748:     /**
1749:      * Filter the query by a related ProductI18n object
1750:      *
1751:      * @param   ProductI18n|PropelObjectCollection $productI18n  the related object to use as filter
1752:      * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
1753:      *
1754:      * @return   ProductQuery The current query, for fluid interface
1755:      * @throws   PropelException - if the provided filter is invalid.
1756:      */
1757:     public function filterByProductI18n($productI18n, $comparison = null)
1758:     {
1759:         if ($productI18n instanceof ProductI18n) {
1760:             return $this
1761:                 ->addUsingAlias(ProductPeer::ID, $productI18n->getId(), $comparison);
1762:         } elseif ($productI18n instanceof PropelObjectCollection) {
1763:             return $this
1764:                 ->useProductI18nQuery()
1765:                 ->filterByPrimaryKeys($productI18n->getPrimaryKeys())
1766:                 ->endUse();
1767:         } else {
1768:             throw new PropelException('filterByProductI18n() only accepts arguments of type ProductI18n or PropelCollection');
1769:         }
1770:     }
1771: 
1772:     /**
1773:      * Adds a JOIN clause to the query using the ProductI18n relation
1774:      *
1775:      * @param     string $relationAlias optional alias for the relation
1776:      * @param     string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
1777:      *
1778:      * @return ProductQuery The current query, for fluid interface
1779:      */
1780:     public function joinProductI18n($relationAlias = null, $joinType = 'LEFT JOIN')
1781:     {
1782:         $tableMap = $this->getTableMap();
1783:         $relationMap = $tableMap->getRelation('ProductI18n');
1784: 
1785:         // create a ModelJoin object for this join
1786:         $join = new ModelJoin();
1787:         $join->setJoinType($joinType);
1788:         $join->setRelationMap($relationMap, $this->useAliasInSQL ? $this->getModelAlias() : null, $relationAlias);
1789:         if ($previousJoin = $this->getPreviousJoin()) {
1790:             $join->setPreviousJoin($previousJoin);
1791:         }
1792: 
1793:         // add the ModelJoin to the current object
1794:         if ($relationAlias) {
1795:             $this->addAlias($relationAlias, $relationMap->getRightTable()->getName());
1796:             $this->addJoinObject($join, $relationAlias);
1797:         } else {
1798:             $this->addJoinObject($join, 'ProductI18n');
1799:         }
1800: 
1801:         return $this;
1802:     }
1803: 
1804:     /**
1805:      * Use the ProductI18n relation ProductI18n object
1806:      *
1807:      * @see       useQuery()
1808:      *
1809:      * @param     string $relationAlias optional alias for the relation,
1810:      *                                   to be used as main alias in the secondary query
1811:      * @param     string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
1812:      *
1813:      * @return   \Thelia\Model\ProductI18nQuery A secondary query class using the current class as primary query
1814:      */
1815:     public function useProductI18nQuery($relationAlias = null, $joinType = 'LEFT JOIN')
1816:     {
1817:         return $this
1818:             ->joinProductI18n($relationAlias, $joinType)
1819:             ->useQuery($relationAlias ? $relationAlias : 'ProductI18n', '\Thelia\Model\ProductI18nQuery');
1820:     }
1821: 
1822:     /**
1823:      * Filter the query by a related ProductVersion object
1824:      *
1825:      * @param   ProductVersion|PropelObjectCollection $productVersion  the related object to use as filter
1826:      * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
1827:      *
1828:      * @return   ProductQuery The current query, for fluid interface
1829:      * @throws   PropelException - if the provided filter is invalid.
1830:      */
1831:     public function filterByProductVersion($productVersion, $comparison = null)
1832:     {
1833:         if ($productVersion instanceof ProductVersion) {
1834:             return $this
1835:                 ->addUsingAlias(ProductPeer::ID, $productVersion->getId(), $comparison);
1836:         } elseif ($productVersion instanceof PropelObjectCollection) {
1837:             return $this
1838:                 ->useProductVersionQuery()
1839:                 ->filterByPrimaryKeys($productVersion->getPrimaryKeys())
1840:                 ->endUse();
1841:         } else {
1842:             throw new PropelException('filterByProductVersion() only accepts arguments of type ProductVersion or PropelCollection');
1843:         }
1844:     }
1845: 
1846:     /**
1847:      * Adds a JOIN clause to the query using the ProductVersion relation
1848:      *
1849:      * @param     string $relationAlias optional alias for the relation
1850:      * @param     string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
1851:      *
1852:      * @return ProductQuery The current query, for fluid interface
1853:      */
1854:     public function joinProductVersion($relationAlias = null, $joinType = Criteria::INNER_JOIN)
1855:     {
1856:         $tableMap = $this->getTableMap();
1857:         $relationMap = $tableMap->getRelation('ProductVersion');
1858: 
1859:         // create a ModelJoin object for this join
1860:         $join = new ModelJoin();
1861:         $join->setJoinType($joinType);
1862:         $join->setRelationMap($relationMap, $this->useAliasInSQL ? $this->getModelAlias() : null, $relationAlias);
1863:         if ($previousJoin = $this->getPreviousJoin()) {
1864:             $join->setPreviousJoin($previousJoin);
1865:         }
1866: 
1867:         // add the ModelJoin to the current object
1868:         if ($relationAlias) {
1869:             $this->addAlias($relationAlias, $relationMap->getRightTable()->getName());
1870:             $this->addJoinObject($join, $relationAlias);
1871:         } else {
1872:             $this->addJoinObject($join, 'ProductVersion');
1873:         }
1874: 
1875:         return $this;
1876:     }
1877: 
1878:     /**
1879:      * Use the ProductVersion relation ProductVersion object
1880:      *
1881:      * @see       useQuery()
1882:      *
1883:      * @param     string $relationAlias optional alias for the relation,
1884:      *                                   to be used as main alias in the secondary query
1885:      * @param     string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
1886:      *
1887:      * @return   \Thelia\Model\ProductVersionQuery A secondary query class using the current class as primary query
1888:      */
1889:     public function useProductVersionQuery($relationAlias = null, $joinType = Criteria::INNER_JOIN)
1890:     {
1891:         return $this
1892:             ->joinProductVersion($relationAlias, $joinType)
1893:             ->useQuery($relationAlias ? $relationAlias : 'ProductVersion', '\Thelia\Model\ProductVersionQuery');
1894:     }
1895: 
1896:     /**
1897:      * Exclude object from result
1898:      *
1899:      * @param   Product $product Object to remove from the list of results
1900:      *
1901:      * @return ProductQuery The current query, for fluid interface
1902:      */
1903:     public function prune($product = null)
1904:     {
1905:         if ($product) {
1906:             $this->addUsingAlias(ProductPeer::ID, $product->getId(), Criteria::NOT_EQUAL);
1907:         }
1908: 
1909:         return $this;
1910:     }
1911: 
1912:     // timestampable behavior
1913: 
1914:     /**
1915:      * Filter by the latest updated
1916:      *
1917:      * @param      int $nbDays Maximum age of the latest update in days
1918:      *
1919:      * @return     ProductQuery The current query, for fluid interface
1920:      */
1921:     public function recentlyUpdated($nbDays = 7)
1922:     {
1923:         return $this->addUsingAlias(ProductPeer::UPDATED_AT, time() - $nbDays * 24 * 60 * 60, Criteria::GREATER_EQUAL);
1924:     }
1925: 
1926:     /**
1927:      * Order by update date desc
1928:      *
1929:      * @return     ProductQuery The current query, for fluid interface
1930:      */
1931:     public function lastUpdatedFirst()
1932:     {
1933:         return $this->addDescendingOrderByColumn(ProductPeer::UPDATED_AT);
1934:     }
1935: 
1936:     /**
1937:      * Order by update date asc
1938:      *
1939:      * @return     ProductQuery The current query, for fluid interface
1940:      */
1941:     public function firstUpdatedFirst()
1942:     {
1943:         return $this->addAscendingOrderByColumn(ProductPeer::UPDATED_AT);
1944:     }
1945: 
1946:     /**
1947:      * Filter by the latest created
1948:      *
1949:      * @param      int $nbDays Maximum age of in days
1950:      *
1951:      * @return     ProductQuery The current query, for fluid interface
1952:      */
1953:     public function recentlyCreated($nbDays = 7)
1954:     {
1955:         return $this->addUsingAlias(ProductPeer::CREATED_AT, time() - $nbDays * 24 * 60 * 60, Criteria::GREATER_EQUAL);
1956:     }
1957: 
1958:     /**
1959:      * Order by create date desc
1960:      *
1961:      * @return     ProductQuery The current query, for fluid interface
1962:      */
1963:     public function lastCreatedFirst()
1964:     {
1965:         return $this->addDescendingOrderByColumn(ProductPeer::CREATED_AT);
1966:     }
1967: 
1968:     /**
1969:      * Order by create date asc
1970:      *
1971:      * @return     ProductQuery The current query, for fluid interface
1972:      */
1973:     public function firstCreatedFirst()
1974:     {
1975:         return $this->addAscendingOrderByColumn(ProductPeer::CREATED_AT);
1976:     }
1977:     // i18n behavior
1978: 
1979:     /**
1980:      * Adds a JOIN clause to the query using the i18n relation
1981:      *
1982:      * @param     string $locale Locale to use for the join condition, e.g. 'fr_FR'
1983:      * @param     string $relationAlias optional alias for the relation
1984:      * @param     string $joinType Accepted values are null, 'left join', 'right join', 'inner join'. Defaults to left join.
1985:      *
1986:      * @return    ProductQuery The current query, for fluid interface
1987:      */
1988:     public function joinI18n($locale = 'en_EN', $relationAlias = null, $joinType = Criteria::LEFT_JOIN)
1989:     {
1990:         $relationName = $relationAlias ? $relationAlias : 'ProductI18n';
1991: 
1992:         return $this
1993:             ->joinProductI18n($relationAlias, $joinType)
1994:             ->addJoinCondition($relationName, $relationName . '.Locale = ?', $locale);
1995:     }
1996: 
1997:     /**
1998:      * Adds a JOIN clause to the query and hydrates the related I18n object.
1999:      * Shortcut for $c->joinI18n($locale)->with()
2000:      *
2001:      * @param     string $locale Locale to use for the join condition, e.g. 'fr_FR'
2002:      * @param     string $joinType Accepted values are null, 'left join', 'right join', 'inner join'. Defaults to left join.
2003:      *
2004:      * @return    ProductQuery The current query, for fluid interface
2005:      */
2006:     public function joinWithI18n($locale = 'en_EN', $joinType = Criteria::LEFT_JOIN)
2007:     {
2008:         $this
2009:             ->joinI18n($locale, null, $joinType)
2010:             ->with('ProductI18n');
2011:         $this->with['ProductI18n']->setIsWithOneToMany(false);
2012: 
2013:         return $this;
2014:     }
2015: 
2016:     /**
2017:      * Use the I18n relation query object
2018:      *
2019:      * @see       useQuery()
2020:      *
2021:      * @param     string $locale Locale to use for the join condition, e.g. 'fr_FR'
2022:      * @param     string $relationAlias optional alias for the relation
2023:      * @param     string $joinType Accepted values are null, 'left join', 'right join', 'inner join'. Defaults to left join.
2024:      *
2025:      * @return    ProductI18nQuery A secondary query class using the current class as primary query
2026:      */
2027:     public function useI18nQuery($locale = 'en_EN', $relationAlias = null, $joinType = Criteria::LEFT_JOIN)
2028:     {
2029:         return $this
2030:             ->joinI18n($locale, $relationAlias, $joinType)
2031:             ->useQuery($relationAlias ? $relationAlias : 'ProductI18n', 'Thelia\Model\ProductI18nQuery');
2032:     }
2033: 
2034: }
2035: