TheCoreDev/sterivein
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

rename feature_prod feature_product

Browse Source
This commit is contained in:
Etienne Roudeix
2013-07-30 11:32:04 +02:00
parent 96239e4af4
commit 799e4ad5df
19 changed files with 3656 additions and 443 deletions
Download Patch File Download Diff File Expand all files Collapse all files

226
core/lib/Thelia/Model/Base/Feature.php
View File

@@ -26,8 +26,8 @@ use Thelia\Model\FeatureCategory as ChildFeatureCategory;
use Thelia\Model\FeatureCategoryQuery as ChildFeatureCategoryQuery;
use Thelia\Model\FeatureI18n as ChildFeatureI18n;
use Thelia\Model\FeatureI18nQuery as ChildFeatureI18nQuery;
use Thelia\Model\FeatureProd as ChildFeatureProd;
use Thelia\Model\FeatureProdQuery as ChildFeatureProdQuery;
use Thelia\Model\FeatureProduct as ChildFeatureProduct;
use Thelia\Model\FeatureProductQuery as ChildFeatureProductQuery;
use Thelia\Model\FeatureQuery as ChildFeatureQuery;
use Thelia\Model\Map\FeatureTableMap;
@@ -103,10 +103,10 @@ abstract class Feature implements ActiveRecordInterface
protected $collFeatureAvsPartial;
/**
* @var ObjectCollection|ChildFeatureProd[] Collection to store aggregation of ChildFeatureProd objects.
* @var ObjectCollection|ChildFeatureProduct[] Collection to store aggregation of ChildFeatureProduct objects.
*/
protected $collFeatureProds;
protected $collFeatureProdsPartial;
protected $collFeatureProducts;
protected $collFeatureProductsPartial;
/**
* @var ObjectCollection|ChildFeatureCategory[] Collection to store aggregation of ChildFeatureCategory objects.
@@ -163,7 +163,7 @@ abstract class Feature implements ActiveRecordInterface
* An array of objects scheduled for deletion.
* @var ObjectCollection
*/
protected $featureProdsScheduledForDeletion = null;
protected $featureProductsScheduledForDeletion = null;
/**
* An array of objects scheduled for deletion.
@@ -754,7 +754,7 @@ abstract class Feature implements ActiveRecordInterface
$this->collFeatureAvs = null;
$this->collFeatureProds = null;
$this->collFeatureProducts = null;
$this->collFeatureCategories = null;
@@ -938,17 +938,17 @@ abstract class Feature implements ActiveRecordInterface
}
}
if ($this->featureProdsScheduledForDeletion !== null) {
if (!$this->featureProdsScheduledForDeletion->isEmpty()) {
\Thelia\Model\FeatureProdQuery::create()
->filterByPrimaryKeys($this->featureProdsScheduledForDeletion->getPrimaryKeys(false))
if ($this->featureProductsScheduledForDeletion !== null) {
if (!$this->featureProductsScheduledForDeletion->isEmpty()) {
\Thelia\Model\FeatureProductQuery::create()
->filterByPrimaryKeys($this->featureProductsScheduledForDeletion->getPrimaryKeys(false))
->delete($con);
$this->featureProdsScheduledForDeletion = null;
$this->featureProductsScheduledForDeletion = null;
}
}
if ($this->collFeatureProds !== null) {
foreach ($this->collFeatureProds as $referrerFK) {
if ($this->collFeatureProducts !== null) {
foreach ($this->collFeatureProducts as $referrerFK) {
if (!$referrerFK->isDeleted() && ($referrerFK->isNew() || $referrerFK->isModified())) {
$affectedRows += $referrerFK->save($con);
}
@@ -1178,8 +1178,8 @@ abstract class Feature implements ActiveRecordInterface
if (null !== $this->collFeatureAvs) {
$result['FeatureAvs'] = $this->collFeatureAvs->toArray(null, true, $keyType, $includeLazyLoadColumns, $alreadyDumpedObjects);
}
if (null !== $this->collFeatureProds) {
$result['FeatureProds'] = $this->collFeatureProds->toArray(null, true, $keyType, $includeLazyLoadColumns, $alreadyDumpedObjects);
if (null !== $this->collFeatureProducts) {
$result['FeatureProducts'] = $this->collFeatureProducts->toArray(null, true, $keyType, $includeLazyLoadColumns, $alreadyDumpedObjects);
}
if (null !== $this->collFeatureCategories) {
$result['FeatureCategories'] = $this->collFeatureCategories->toArray(null, true, $keyType, $includeLazyLoadColumns, $alreadyDumpedObjects);
@@ -1360,9 +1360,9 @@ abstract class Feature implements ActiveRecordInterface
}
}
foreach ($this->getFeatureProds() as $relObj) {
foreach ($this->getFeatureProducts() as $relObj) {
if ($relObj !== $this) { // ensure that we don't try to copy a reference to ourselves
$copyObj->addFeatureProd($relObj->copy($deepCopy));
$copyObj->addFeatureProduct($relObj->copy($deepCopy));
}
}
@@ -1422,8 +1422,8 @@ abstract class Feature implements ActiveRecordInterface
if ('FeatureAv' == $relationName) {
return $this->initFeatureAvs();
}
if ('FeatureProd' == $relationName) {
return $this->initFeatureProds();
if ('FeatureProduct' == $relationName) {
return $this->initFeatureProducts();
}
if ('FeatureCategory' == $relationName) {
return $this->initFeatureCategories();
@@ -1652,31 +1652,31 @@ abstract class Feature implements ActiveRecordInterface
}
/**
* Clears out the collFeatureProds collection
* Clears out the collFeatureProducts collection
*
* This does not modify the database; however, it will remove any associated objects, causing
* them to be refetched by subsequent calls to accessor method.
*
* @return void
* @see addFeatureProds()
* @see addFeatureProducts()
*/
public function clearFeatureProds()
public function clearFeatureProducts()
{
$this->collFeatureProds = null; // important to set this to NULL since that means it is uninitialized
$this->collFeatureProducts = null; // important to set this to NULL since that means it is uninitialized
}
/**
* Reset is the collFeatureProds collection loaded partially.
* Reset is the collFeatureProducts collection loaded partially.
*/
public function resetPartialFeatureProds($v = true)
public function resetPartialFeatureProducts($v = true)
{
$this->collFeatureProdsPartial = $v;
$this->collFeatureProductsPartial = $v;
}
/**
* Initializes the collFeatureProds collection.
* Initializes the collFeatureProducts collection.
*
* By default this just sets the collFeatureProds collection to an empty array (like clearcollFeatureProds());
* By default this just sets the collFeatureProducts collection to an empty array (like clearcollFeatureProducts());
* however, you may wish to override this method in your stub class to provide setting appropriate
* to your application -- for example, setting the initial array to the values stored in database.
*
@@ -1685,17 +1685,17 @@ abstract class Feature implements ActiveRecordInterface
*
* @return void
*/
public function initFeatureProds($overrideExisting = true)
public function initFeatureProducts($overrideExisting = true)
{
if (null !== $this->collFeatureProds && !$overrideExisting) {
if (null !== $this->collFeatureProducts && !$overrideExisting) {
return;
}
$this->collFeatureProds = new ObjectCollection();
$this->collFeatureProds->setModel('\Thelia\Model\FeatureProd');
$this->collFeatureProducts = new ObjectCollection();
$this->collFeatureProducts->setModel('\Thelia\Model\FeatureProduct');
}
/**
* Gets an array of ChildFeatureProd objects which contain a foreign key that references this object.
* Gets an array of ChildFeatureProduct objects which contain a foreign key that references this object.
*
* If the $criteria is not null, it is used to always fetch the results from the database.
* Otherwise the results are fetched from the database the first time, then cached.
@@ -1705,109 +1705,109 @@ abstract class Feature implements ActiveRecordInterface
*
* @param Criteria $criteria optional Criteria object to narrow the query
* @param ConnectionInterface $con optional connection object
* @return Collection|ChildFeatureProd[] List of ChildFeatureProd objects
* @return Collection|ChildFeatureProduct[] List of ChildFeatureProduct objects
* @throws PropelException
*/
public function getFeatureProds($criteria = null, ConnectionInterface $con = null)
public function getFeatureProducts($criteria = null, ConnectionInterface $con = null)
{
$partial = $this->collFeatureProdsPartial && !$this->isNew();
if (null === $this->collFeatureProds || null !== $criteria || $partial) {
if ($this->isNew() && null === $this->collFeatureProds) {
$partial = $this->collFeatureProductsPartial && !$this->isNew();
if (null === $this->collFeatureProducts || null !== $criteria || $partial) {
if ($this->isNew() && null === $this->collFeatureProducts) {
// return empty collection
$this->initFeatureProds();
$this->initFeatureProducts();
} else {
$collFeatureProds = ChildFeatureProdQuery::create(null, $criteria)
$collFeatureProducts = ChildFeatureProductQuery::create(null, $criteria)
->filterByFeature($this)
->find($con);
if (null !== $criteria) {
if (false !== $this->collFeatureProdsPartial && count($collFeatureProds)) {
$this->initFeatureProds(false);
if (false !== $this->collFeatureProductsPartial && count($collFeatureProducts)) {
$this->initFeatureProducts(false);
foreach ($collFeatureProds as $obj) {
if (false == $this->collFeatureProds->contains($obj)) {
$this->collFeatureProds->append($obj);
foreach ($collFeatureProducts as $obj) {
if (false == $this->collFeatureProducts->contains($obj)) {
$this->collFeatureProducts->append($obj);
}
}
$this->collFeatureProdsPartial = true;
$this->collFeatureProductsPartial = true;
}
$collFeatureProds->getInternalIterator()->rewind();
$collFeatureProducts->getInternalIterator()->rewind();
return $collFeatureProds;
return $collFeatureProducts;
}
if ($partial && $this->collFeatureProds) {
foreach ($this->collFeatureProds as $obj) {
if ($partial && $this->collFeatureProducts) {
foreach ($this->collFeatureProducts as $obj) {
if ($obj->isNew()) {
$collFeatureProds[] = $obj;
$collFeatureProducts[] = $obj;
}
}
}
$this->collFeatureProds = $collFeatureProds;
$this->collFeatureProdsPartial = false;
$this->collFeatureProducts = $collFeatureProducts;
$this->collFeatureProductsPartial = false;
}
}
return $this->collFeatureProds;
return $this->collFeatureProducts;
}
/**
* Sets a collection of FeatureProd objects related by a one-to-many relationship
* Sets a collection of FeatureProduct objects related by a one-to-many relationship
* to the current object.
* It will also schedule objects for deletion based on a diff between old objects (aka persisted)
* and new objects from the given Propel collection.
*
* @param Collection $featureProds A Propel collection.
* @param Collection $featureProducts A Propel collection.
* @param ConnectionInterface $con Optional connection object
* @return ChildFeature The current object (for fluent API support)
*/
public function setFeatureProds(Collection $featureProds, ConnectionInterface $con = null)
public function setFeatureProducts(Collection $featureProducts, ConnectionInterface $con = null)
{
$featureProdsToDelete = $this->getFeatureProds(new Criteria(), $con)->diff($featureProds);
$featureProductsToDelete = $this->getFeatureProducts(new Criteria(), $con)->diff($featureProducts);
$this->featureProdsScheduledForDeletion = $featureProdsToDelete;
$this->featureProductsScheduledForDeletion = $featureProductsToDelete;
foreach ($featureProdsToDelete as $featureProdRemoved) {
$featureProdRemoved->setFeature(null);
foreach ($featureProductsToDelete as $featureProductRemoved) {
$featureProductRemoved->setFeature(null);
}
$this->collFeatureProds = null;
foreach ($featureProds as $featureProd) {
$this->addFeatureProd($featureProd);
$this->collFeatureProducts = null;
foreach ($featureProducts as $featureProduct) {
$this->addFeatureProduct($featureProduct);
}
$this->collFeatureProds = $featureProds;
$this->collFeatureProdsPartial = false;
$this->collFeatureProducts = $featureProducts;
$this->collFeatureProductsPartial = false;
return $this;
}
/**
* Returns the number of related FeatureProd objects.
* Returns the number of related FeatureProduct objects.
*
* @param Criteria $criteria
* @param boolean $distinct
* @param ConnectionInterface $con
* @return int Count of related FeatureProd objects.
* @return int Count of related FeatureProduct objects.
* @throws PropelException
*/
public function countFeatureProds(Criteria $criteria = null, $distinct = false, ConnectionInterface $con = null)
public function countFeatureProducts(Criteria $criteria = null, $distinct = false, ConnectionInterface $con = null)
{
$partial = $this->collFeatureProdsPartial && !$this->isNew();
if (null === $this->collFeatureProds || null !== $criteria || $partial) {
if ($this->isNew() && null === $this->collFeatureProds) {
$partial = $this->collFeatureProductsPartial && !$this->isNew();
if (null === $this->collFeatureProducts || null !== $criteria || $partial) {
if ($this->isNew() && null === $this->collFeatureProducts) {
return 0;
}
if ($partial && !$criteria) {
return count($this->getFeatureProds());
return count($this->getFeatureProducts());
}
$query = ChildFeatureProdQuery::create(null, $criteria);
$query = ChildFeatureProductQuery::create(null, $criteria);
if ($distinct) {
$query->distinct();
}
@@ -1817,53 +1817,53 @@ abstract class Feature implements ActiveRecordInterface
->count($con);
}
return count($this->collFeatureProds);
return count($this->collFeatureProducts);
}
/**
* Method called to associate a ChildFeatureProd object to this object
* through the ChildFeatureProd foreign key attribute.
* Method called to associate a ChildFeatureProduct object to this object
* through the ChildFeatureProduct foreign key attribute.
*
* @param ChildFeatureProd $l ChildFeatureProd
* @param ChildFeatureProduct $l ChildFeatureProduct
* @return \Thelia\Model\Feature The current object (for fluent API support)
*/
public function addFeatureProd(ChildFeatureProd $l)
public function addFeatureProduct(ChildFeatureProduct $l)
{
if ($this->collFeatureProds === null) {
$this->initFeatureProds();
$this->collFeatureProdsPartial = true;
if ($this->collFeatureProducts === null) {
$this->initFeatureProducts();
$this->collFeatureProductsPartial = true;
}
if (!in_array($l, $this->collFeatureProds->getArrayCopy(), true)) { // only add it if the **same** object is not already associated
$this->doAddFeatureProd($l);
if (!in_array($l, $this->collFeatureProducts->getArrayCopy(), true)) { // only add it if the **same** object is not already associated
$this->doAddFeatureProduct($l);
}
return $this;
}
/**
* @param FeatureProd $featureProd The featureProd object to add.
* @param FeatureProduct $featureProduct The featureProduct object to add.
*/
protected function doAddFeatureProd($featureProd)
protected function doAddFeatureProduct($featureProduct)
{
$this->collFeatureProds[]= $featureProd;
$featureProd->setFeature($this);
$this->collFeatureProducts[]= $featureProduct;
$featureProduct->setFeature($this);
}
/**
* @param FeatureProd $featureProd The featureProd object to remove.
* @param FeatureProduct $featureProduct The featureProduct object to remove.
* @return ChildFeature The current object (for fluent API support)
*/
public function removeFeatureProd($featureProd)
public function removeFeatureProduct($featureProduct)
{
if ($this->getFeatureProds()->contains($featureProd)) {
$this->collFeatureProds->remove($this->collFeatureProds->search($featureProd));
if (null === $this->featureProdsScheduledForDeletion) {
$this->featureProdsScheduledForDeletion = clone $this->collFeatureProds;
$this->featureProdsScheduledForDeletion->clear();
if ($this->getFeatureProducts()->contains($featureProduct)) {
$this->collFeatureProducts->remove($this->collFeatureProducts->search($featureProduct));
if (null === $this->featureProductsScheduledForDeletion) {
$this->featureProductsScheduledForDeletion = clone $this->collFeatureProducts;
$this->featureProductsScheduledForDeletion->clear();
}
$this->featureProdsScheduledForDeletion[]= clone $featureProd;
$featureProd->setFeature(null);
$this->featureProductsScheduledForDeletion[]= clone $featureProduct;
$featureProduct->setFeature(null);
}
return $this;
@@ -1875,7 +1875,7 @@ abstract class Feature implements ActiveRecordInterface
* an identical criteria, it returns the collection.
* Otherwise if this Feature is new, it will return
* an empty collection; or if this Feature has previously
* been saved, it will retrieve related FeatureProds from storage.
* been saved, it will retrieve related FeatureProducts from storage.
*
* This method is protected by default in order to keep the public
* api reasonable. You can provide public methods for those you
@@ -1884,14 +1884,14 @@ abstract class Feature implements ActiveRecordInterface
* @param Criteria $criteria optional Criteria object to narrow the query
* @param ConnectionInterface $con optional connection object
* @param string $joinBehavior optional join type to use (defaults to Criteria::LEFT_JOIN)
* @return Collection|ChildFeatureProd[] List of ChildFeatureProd objects
* @return Collection|ChildFeatureProduct[] List of ChildFeatureProduct objects
*/
public function getFeatureProdsJoinProduct($criteria = null, $con = null, $joinBehavior = Criteria::LEFT_JOIN)
public function getFeatureProductsJoinProduct($criteria = null, $con = null, $joinBehavior = Criteria::LEFT_JOIN)
{
$query = ChildFeatureProdQuery::create(null, $criteria);
$query = ChildFeatureProductQuery::create(null, $criteria);
$query->joinWith('Product', $joinBehavior);
return $this->getFeatureProds($query, $con);
return $this->getFeatureProducts($query, $con);
}
@@ -1900,7 +1900,7 @@ abstract class Feature implements ActiveRecordInterface
* an identical criteria, it returns the collection.
* Otherwise if this Feature is new, it will return
* an empty collection; or if this Feature has previously
* been saved, it will retrieve related FeatureProds from storage.
* been saved, it will retrieve related FeatureProducts from storage.
*
* This method is protected by default in order to keep the public
* api reasonable. You can provide public methods for those you
@@ -1909,14 +1909,14 @@ abstract class Feature implements ActiveRecordInterface
* @param Criteria $criteria optional Criteria object to narrow the query
* @param ConnectionInterface $con optional connection object
* @param string $joinBehavior optional join type to use (defaults to Criteria::LEFT_JOIN)
* @return Collection|ChildFeatureProd[] List of ChildFeatureProd objects
* @return Collection|ChildFeatureProduct[] List of ChildFeatureProduct objects
*/
public function getFeatureProdsJoinFeatureAv($criteria = null, $con = null, $joinBehavior = Criteria::LEFT_JOIN)
public function getFeatureProductsJoinFeatureAv($criteria = null, $con = null, $joinBehavior = Criteria::LEFT_JOIN)
{
$query = ChildFeatureProdQuery::create(null, $criteria);
$query = ChildFeatureProductQuery::create(null, $criteria);
$query->joinWith('FeatureAv', $joinBehavior);
return $this->getFeatureProds($query, $con);
return $this->getFeatureProducts($query, $con);
}
/**
@@ -2605,8 +2605,8 @@ abstract class Feature implements ActiveRecordInterface
$o->clearAllReferences($deep);
}
}
if ($this->collFeatureProds) {
foreach ($this->collFeatureProds as $o) {
if ($this->collFeatureProducts) {
foreach ($this->collFeatureProducts as $o) {
$o->clearAllReferences($deep);
}
}
@@ -2635,10 +2635,10 @@ abstract class Feature implements ActiveRecordInterface
$this->collFeatureAvs->clearIterator();
}
$this->collFeatureAvs = null;
if ($this->collFeatureProds instanceof Collection) {
$this->collFeatureProds->clearIterator();
if ($this->collFeatureProducts instanceof Collection) {
$this->collFeatureProducts->clearIterator();
}
$this->collFeatureProds = null;
$this->collFeatureProducts = null;
if ($this->collFeatureCategories instanceof Collection) {
$this->collFeatureCategories->clearIterator();
}

226
core/lib/Thelia/Model/Base/FeatureAv.php
View File

@@ -22,8 +22,8 @@ use Thelia\Model\FeatureAv as ChildFeatureAv;
use Thelia\Model\FeatureAvI18n as ChildFeatureAvI18n;
use Thelia\Model\FeatureAvI18nQuery as ChildFeatureAvI18nQuery;
use Thelia\Model\FeatureAvQuery as ChildFeatureAvQuery;
use Thelia\Model\FeatureProd as ChildFeatureProd;
use Thelia\Model\FeatureProdQuery as ChildFeatureProdQuery;
use Thelia\Model\FeatureProduct as ChildFeatureProduct;
use Thelia\Model\FeatureProductQuery as ChildFeatureProductQuery;
use Thelia\Model\FeatureQuery as ChildFeatureQuery;
use Thelia\Model\Map\FeatureAvTableMap;
@@ -97,10 +97,10 @@ abstract class FeatureAv implements ActiveRecordInterface
protected $aFeature;
/**
* @var ObjectCollection|ChildFeatureProd[] Collection to store aggregation of ChildFeatureProd objects.
* @var ObjectCollection|ChildFeatureProduct[] Collection to store aggregation of ChildFeatureProduct objects.
*/
protected $collFeatureProds;
protected $collFeatureProdsPartial;
protected $collFeatureProducts;
protected $collFeatureProductsPartial;
/**
* @var ObjectCollection|ChildFeatureAvI18n[] Collection to store aggregation of ChildFeatureAvI18n objects.
@@ -134,7 +134,7 @@ abstract class FeatureAv implements ActiveRecordInterface
* An array of objects scheduled for deletion.
* @var ObjectCollection
*/
protected $featureProdsScheduledForDeletion = null;
protected $featureProductsScheduledForDeletion = null;
/**
* An array of objects scheduled for deletion.
@@ -708,7 +708,7 @@ abstract class FeatureAv implements ActiveRecordInterface
if ($deep) { // also de-associate any related objects?
$this->aFeature = null;
$this->collFeatureProds = null;
$this->collFeatureProducts = null;
$this->collFeatureAvI18ns = null;
@@ -857,17 +857,17 @@ abstract class FeatureAv implements ActiveRecordInterface
$this->resetModified();
}
if ($this->featureProdsScheduledForDeletion !== null) {
if (!$this->featureProdsScheduledForDeletion->isEmpty()) {
\Thelia\Model\FeatureProdQuery::create()
->filterByPrimaryKeys($this->featureProdsScheduledForDeletion->getPrimaryKeys(false))
if ($this->featureProductsScheduledForDeletion !== null) {
if (!$this->featureProductsScheduledForDeletion->isEmpty()) {
\Thelia\Model\FeatureProductQuery::create()
->filterByPrimaryKeys($this->featureProductsScheduledForDeletion->getPrimaryKeys(false))
->delete($con);
$this->featureProdsScheduledForDeletion = null;
$this->featureProductsScheduledForDeletion = null;
}
}
if ($this->collFeatureProds !== null) {
foreach ($this->collFeatureProds as $referrerFK) {
if ($this->collFeatureProducts !== null) {
foreach ($this->collFeatureProducts as $referrerFK) {
if (!$referrerFK->isDeleted() && ($referrerFK->isNew() || $referrerFK->isModified())) {
$affectedRows += $referrerFK->save($con);
}
@@ -1080,8 +1080,8 @@ abstract class FeatureAv implements ActiveRecordInterface
if (null !== $this->aFeature) {
$result['Feature'] = $this->aFeature->toArray($keyType, $includeLazyLoadColumns, $alreadyDumpedObjects, true);
}
if (null !== $this->collFeatureProds) {
$result['FeatureProds'] = $this->collFeatureProds->toArray(null, true, $keyType, $includeLazyLoadColumns, $alreadyDumpedObjects);
if (null !== $this->collFeatureProducts) {
$result['FeatureProducts'] = $this->collFeatureProducts->toArray(null, true, $keyType, $includeLazyLoadColumns, $alreadyDumpedObjects);
}
if (null !== $this->collFeatureAvI18ns) {
$result['FeatureAvI18ns'] = $this->collFeatureAvI18ns->toArray(null, true, $keyType, $includeLazyLoadColumns, $alreadyDumpedObjects);
@@ -1253,9 +1253,9 @@ abstract class FeatureAv implements ActiveRecordInterface
// the getter/setter methods for fkey referrer objects.
$copyObj->setNew(false);
foreach ($this->getFeatureProds() as $relObj) {
foreach ($this->getFeatureProducts() as $relObj) {
if ($relObj !== $this) { // ensure that we don't try to copy a reference to ourselves
$copyObj->addFeatureProd($relObj->copy($deepCopy));
$copyObj->addFeatureProduct($relObj->copy($deepCopy));
}
}
@@ -1357,8 +1357,8 @@ abstract class FeatureAv implements ActiveRecordInterface
*/
public function initRelation($relationName)
{
if ('FeatureProd' == $relationName) {
return $this->initFeatureProds();
if ('FeatureProduct' == $relationName) {
return $this->initFeatureProducts();
}
if ('FeatureAvI18n' == $relationName) {
return $this->initFeatureAvI18ns();
@@ -1366,31 +1366,31 @@ abstract class FeatureAv implements ActiveRecordInterface
}
/**
* Clears out the collFeatureProds collection
* Clears out the collFeatureProducts collection
*
* This does not modify the database; however, it will remove any associated objects, causing
* them to be refetched by subsequent calls to accessor method.
*
* @return void
* @see addFeatureProds()
* @see addFeatureProducts()
*/
public function clearFeatureProds()
public function clearFeatureProducts()
{
$this->collFeatureProds = null; // important to set this to NULL since that means it is uninitialized
$this->collFeatureProducts = null; // important to set this to NULL since that means it is uninitialized
}
/**
* Reset is the collFeatureProds collection loaded partially.
* Reset is the collFeatureProducts collection loaded partially.
*/
public function resetPartialFeatureProds($v = true)
public function resetPartialFeatureProducts($v = true)
{
$this->collFeatureProdsPartial = $v;
$this->collFeatureProductsPartial = $v;
}
/**
* Initializes the collFeatureProds collection.
* Initializes the collFeatureProducts collection.
*
* By default this just sets the collFeatureProds collection to an empty array (like clearcollFeatureProds());
* By default this just sets the collFeatureProducts collection to an empty array (like clearcollFeatureProducts());
* however, you may wish to override this method in your stub class to provide setting appropriate
* to your application -- for example, setting the initial array to the values stored in database.
*
@@ -1399,17 +1399,17 @@ abstract class FeatureAv implements ActiveRecordInterface
*
* @return void
*/
public function initFeatureProds($overrideExisting = true)
public function initFeatureProducts($overrideExisting = true)
{
if (null !== $this->collFeatureProds && !$overrideExisting) {
if (null !== $this->collFeatureProducts && !$overrideExisting) {
return;
}
$this->collFeatureProds = new ObjectCollection();
$this->collFeatureProds->setModel('\Thelia\Model\FeatureProd');
$this->collFeatureProducts = new ObjectCollection();
$this->collFeatureProducts->setModel('\Thelia\Model\FeatureProduct');
}
/**
* Gets an array of ChildFeatureProd objects which contain a foreign key that references this object.
* Gets an array of ChildFeatureProduct objects which contain a foreign key that references this object.
*
* If the $criteria is not null, it is used to always fetch the results from the database.
* Otherwise the results are fetched from the database the first time, then cached.
@@ -1419,109 +1419,109 @@ abstract class FeatureAv implements ActiveRecordInterface
*
* @param Criteria $criteria optional Criteria object to narrow the query
* @param ConnectionInterface $con optional connection object
* @return Collection|ChildFeatureProd[] List of ChildFeatureProd objects
* @return Collection|ChildFeatureProduct[] List of ChildFeatureProduct objects
* @throws PropelException
*/
public function getFeatureProds($criteria = null, ConnectionInterface $con = null)
public function getFeatureProducts($criteria = null, ConnectionInterface $con = null)
{
$partial = $this->collFeatureProdsPartial && !$this->isNew();
if (null === $this->collFeatureProds || null !== $criteria || $partial) {
if ($this->isNew() && null === $this->collFeatureProds) {
$partial = $this->collFeatureProductsPartial && !$this->isNew();
if (null === $this->collFeatureProducts || null !== $criteria || $partial) {
if ($this->isNew() && null === $this->collFeatureProducts) {
// return empty collection
$this->initFeatureProds();
$this->initFeatureProducts();
} else {
$collFeatureProds = ChildFeatureProdQuery::create(null, $criteria)
$collFeatureProducts = ChildFeatureProductQuery::create(null, $criteria)
->filterByFeatureAv($this)
->find($con);
if (null !== $criteria) {
if (false !== $this->collFeatureProdsPartial && count($collFeatureProds)) {
$this->initFeatureProds(false);
if (false !== $this->collFeatureProductsPartial && count($collFeatureProducts)) {
$this->initFeatureProducts(false);
foreach ($collFeatureProds as $obj) {
if (false == $this->collFeatureProds->contains($obj)) {
$this->collFeatureProds->append($obj);
foreach ($collFeatureProducts as $obj) {
if (false == $this->collFeatureProducts->contains($obj)) {
$this->collFeatureProducts->append($obj);
}
}
$this->collFeatureProdsPartial = true;
$this->collFeatureProductsPartial = true;
}
$collFeatureProds->getInternalIterator()->rewind();
$collFeatureProducts->getInternalIterator()->rewind();
return $collFeatureProds;
return $collFeatureProducts;
}
if ($partial && $this->collFeatureProds) {
foreach ($this->collFeatureProds as $obj) {
if ($partial && $this->collFeatureProducts) {
foreach ($this->collFeatureProducts as $obj) {
if ($obj->isNew()) {
$collFeatureProds[] = $obj;
$collFeatureProducts[] = $obj;
}
}
}
$this->collFeatureProds = $collFeatureProds;
$this->collFeatureProdsPartial = false;
$this->collFeatureProducts = $collFeatureProducts;
$this->collFeatureProductsPartial = false;
}
}
return $this->collFeatureProds;
return $this->collFeatureProducts;
}
/**
* Sets a collection of FeatureProd objects related by a one-to-many relationship
* Sets a collection of FeatureProduct objects related by a one-to-many relationship
* to the current object.
* It will also schedule objects for deletion based on a diff between old objects (aka persisted)
* and new objects from the given Propel collection.
*
* @param Collection $featureProds A Propel collection.
* @param Collection $featureProducts A Propel collection.
* @param ConnectionInterface $con Optional connection object
* @return ChildFeatureAv The current object (for fluent API support)
*/
public function setFeatureProds(Collection $featureProds, ConnectionInterface $con = null)
public function setFeatureProducts(Collection $featureProducts, ConnectionInterface $con = null)
{
$featureProdsToDelete = $this->getFeatureProds(new Criteria(), $con)->diff($featureProds);
$featureProductsToDelete = $this->getFeatureProducts(new Criteria(), $con)->diff($featureProducts);
$this->featureProdsScheduledForDeletion = $featureProdsToDelete;
$this->featureProductsScheduledForDeletion = $featureProductsToDelete;
foreach ($featureProdsToDelete as $featureProdRemoved) {
$featureProdRemoved->setFeatureAv(null);
foreach ($featureProductsToDelete as $featureProductRemoved) {
$featureProductRemoved->setFeatureAv(null);
}
$this->collFeatureProds = null;
foreach ($featureProds as $featureProd) {
$this->addFeatureProd($featureProd);
$this->collFeatureProducts = null;
foreach ($featureProducts as $featureProduct) {
$this->addFeatureProduct($featureProduct);
}
$this->collFeatureProds = $featureProds;
$this->collFeatureProdsPartial = false;
$this->collFeatureProducts = $featureProducts;
$this->collFeatureProductsPartial = false;
return $this;
}
/**
* Returns the number of related FeatureProd objects.
* Returns the number of related FeatureProduct objects.
*
* @param Criteria $criteria
* @param boolean $distinct
* @param ConnectionInterface $con
* @return int Count of related FeatureProd objects.
* @return int Count of related FeatureProduct objects.
* @throws PropelException
*/
public function countFeatureProds(Criteria $criteria = null, $distinct = false, ConnectionInterface $con = null)
public function countFeatureProducts(Criteria $criteria = null, $distinct = false, ConnectionInterface $con = null)
{
$partial = $this->collFeatureProdsPartial && !$this->isNew();
if (null === $this->collFeatureProds || null !== $criteria || $partial) {
if ($this->isNew() && null === $this->collFeatureProds) {
$partial = $this->collFeatureProductsPartial && !$this->isNew();
if (null === $this->collFeatureProducts || null !== $criteria || $partial) {
if ($this->isNew() && null === $this->collFeatureProducts) {
return 0;
}
if ($partial && !$criteria) {
return count($this->getFeatureProds());
return count($this->getFeatureProducts());
}
$query = ChildFeatureProdQuery::create(null, $criteria);
$query = ChildFeatureProductQuery::create(null, $criteria);
if ($distinct) {
$query->distinct();
}
@@ -1531,53 +1531,53 @@ abstract class FeatureAv implements ActiveRecordInterface
->count($con);
}
return count($this->collFeatureProds);
return count($this->collFeatureProducts);
}
/**
* Method called to associate a ChildFeatureProd object to this object
* through the ChildFeatureProd foreign key attribute.
* Method called to associate a ChildFeatureProduct object to this object
* through the ChildFeatureProduct foreign key attribute.
*
* @param ChildFeatureProd $l ChildFeatureProd
* @param ChildFeatureProduct $l ChildFeatureProduct
* @return \Thelia\Model\FeatureAv The current object (for fluent API support)
*/
public function addFeatureProd(ChildFeatureProd $l)
public function addFeatureProduct(ChildFeatureProduct $l)
{
if ($this->collFeatureProds === null) {
$this->initFeatureProds();
$this->collFeatureProdsPartial = true;
if ($this->collFeatureProducts === null) {
$this->initFeatureProducts();
$this->collFeatureProductsPartial = true;
}
if (!in_array($l, $this->collFeatureProds->getArrayCopy(), true)) { // only add it if the **same** object is not already associated
$this->doAddFeatureProd($l);
if (!in_array($l, $this->collFeatureProducts->getArrayCopy(), true)) { // only add it if the **same** object is not already associated
$this->doAddFeatureProduct($l);
}
return $this;
}
/**
* @param FeatureProd $featureProd The featureProd object to add.
* @param FeatureProduct $featureProduct The featureProduct object to add.
*/
protected function doAddFeatureProd($featureProd)
protected function doAddFeatureProduct($featureProduct)
{
$this->collFeatureProds[]= $featureProd;
$featureProd->setFeatureAv($this);
$this->collFeatureProducts[]= $featureProduct;
$featureProduct->setFeatureAv($this);
}
/**
* @param FeatureProd $featureProd The featureProd object to remove.
* @param FeatureProduct $featureProduct The featureProduct object to remove.
* @return ChildFeatureAv The current object (for fluent API support)
*/
public function removeFeatureProd($featureProd)
public function removeFeatureProduct($featureProduct)
{
if ($this->getFeatureProds()->contains($featureProd)) {
$this->collFeatureProds->remove($this->collFeatureProds->search($featureProd));
if (null === $this->featureProdsScheduledForDeletion) {
$this->featureProdsScheduledForDeletion = clone $this->collFeatureProds;
$this->featureProdsScheduledForDeletion->clear();
if ($this->getFeatureProducts()->contains($featureProduct)) {
$this->collFeatureProducts->remove($this->collFeatureProducts->search($featureProduct));
if (null === $this->featureProductsScheduledForDeletion) {
$this->featureProductsScheduledForDeletion = clone $this->collFeatureProducts;
$this->featureProductsScheduledForDeletion->clear();
}
$this->featureProdsScheduledForDeletion[]= $featureProd;
$featureProd->setFeatureAv(null);
$this->featureProductsScheduledForDeletion[]= $featureProduct;
$featureProduct->setFeatureAv(null);
}
return $this;
@@ -1589,7 +1589,7 @@ abstract class FeatureAv implements ActiveRecordInterface
* an identical criteria, it returns the collection.
* Otherwise if this FeatureAv is new, it will return
* an empty collection; or if this FeatureAv has previously
* been saved, it will retrieve related FeatureProds from storage.
* been saved, it will retrieve related FeatureProducts from storage.
*
* This method is protected by default in order to keep the public
* api reasonable. You can provide public methods for those you
@@ -1598,14 +1598,14 @@ abstract class FeatureAv implements ActiveRecordInterface
* @param Criteria $criteria optional Criteria object to narrow the query
* @param ConnectionInterface $con optional connection object
* @param string $joinBehavior optional join type to use (defaults to Criteria::LEFT_JOIN)
* @return Collection|ChildFeatureProd[] List of ChildFeatureProd objects
* @return Collection|ChildFeatureProduct[] List of ChildFeatureProduct objects
*/
public function getFeatureProdsJoinProduct($criteria = null, $con = null, $joinBehavior = Criteria::LEFT_JOIN)
public function getFeatureProductsJoinProduct($criteria = null, $con = null, $joinBehavior = Criteria::LEFT_JOIN)
{
$query = ChildFeatureProdQuery::create(null, $criteria);
$query = ChildFeatureProductQuery::create(null, $criteria);
$query->joinWith('Product', $joinBehavior);
return $this->getFeatureProds($query, $con);
return $this->getFeatureProducts($query, $con);
}
@@ -1614,7 +1614,7 @@ abstract class FeatureAv implements ActiveRecordInterface
* an identical criteria, it returns the collection.
* Otherwise if this FeatureAv is new, it will return
* an empty collection; or if this FeatureAv has previously
* been saved, it will retrieve related FeatureProds from storage.
* been saved, it will retrieve related FeatureProducts from storage.
*
* This method is protected by default in order to keep the public
* api reasonable. You can provide public methods for those you
@@ -1623,14 +1623,14 @@ abstract class FeatureAv implements ActiveRecordInterface
* @param Criteria $criteria optional Criteria object to narrow the query
* @param ConnectionInterface $con optional connection object
* @param string $joinBehavior optional join type to use (defaults to Criteria::LEFT_JOIN)
* @return Collection|ChildFeatureProd[] List of ChildFeatureProd objects
* @return Collection|ChildFeatureProduct[] List of ChildFeatureProduct objects
*/
public function getFeatureProdsJoinFeature($criteria = null, $con = null, $joinBehavior = Criteria::LEFT_JOIN)
public function getFeatureProductsJoinFeature($criteria = null, $con = null, $joinBehavior = Criteria::LEFT_JOIN)
{
$query = ChildFeatureProdQuery::create(null, $criteria);
$query = ChildFeatureProductQuery::create(null, $criteria);
$query->joinWith('Feature', $joinBehavior);
return $this->getFeatureProds($query, $con);
return $this->getFeatureProducts($query, $con);
}
/**
@@ -1887,8 +1887,8 @@ abstract class FeatureAv implements ActiveRecordInterface
public function clearAllReferences($deep = false)
{
if ($deep) {
if ($this->collFeatureProds) {
foreach ($this->collFeatureProds as $o) {
if ($this->collFeatureProducts) {
foreach ($this->collFeatureProducts as $o) {
$o->clearAllReferences($deep);
}
}
@@ -1903,10 +1903,10 @@ abstract class FeatureAv implements ActiveRecordInterface
$this->currentLocale = 'en_US';
$this->currentTranslations = null;
if ($this->collFeatureProds instanceof Collection) {
$this->collFeatureProds->clearIterator();
if ($this->collFeatureProducts instanceof Collection) {
$this->collFeatureProducts->clearIterator();
}
$this->collFeatureProds = null;
$this->collFeatureProducts = null;
if ($this->collFeatureAvI18ns instanceof Collection) {
$this->collFeatureAvI18ns->clearIterator();
}

42
core/lib/Thelia/Model/Base/FeatureAvQuery.php
View File

@@ -42,9 +42,9 @@ use Thelia\Model\Map\FeatureAvTableMap;
* @method ChildFeatureAvQuery rightJoinFeature($relationAlias = null) Adds a RIGHT JOIN clause to the query using the Feature relation
* @method ChildFeatureAvQuery innerJoinFeature($relationAlias = null) Adds a INNER JOIN clause to the query using the Feature relation
*
* @method ChildFeatureAvQuery leftJoinFeatureProd($relationAlias = null) Adds a LEFT JOIN clause to the query using the FeatureProd relation
* @method ChildFeatureAvQuery rightJoinFeatureProd($relationAlias = null) Adds a RIGHT JOIN clause to the query using the FeatureProd relation
* @method ChildFeatureAvQuery innerJoinFeatureProd($relationAlias = null) Adds a INNER JOIN clause to the query using the FeatureProd relation
* @method ChildFeatureAvQuery leftJoinFeatureProduct($relationAlias = null) Adds a LEFT JOIN clause to the query using the FeatureProduct relation
* @method ChildFeatureAvQuery rightJoinFeatureProduct($relationAlias = null) Adds a RIGHT JOIN clause to the query using the FeatureProduct relation
* @method ChildFeatureAvQuery innerJoinFeatureProduct($relationAlias = null) Adds a INNER JOIN clause to the query using the FeatureProduct relation
*
* @method ChildFeatureAvQuery leftJoinFeatureAvI18n($relationAlias = null) Adds a LEFT JOIN clause to the query using the FeatureAvI18n relation
* @method ChildFeatureAvQuery rightJoinFeatureAvI18n($relationAlias = null) Adds a RIGHT JOIN clause to the query using the FeatureAvI18n relation
@@ -528,40 +528,40 @@ abstract class FeatureAvQuery extends ModelCriteria
}
/**
* Filter the query by a related \Thelia\Model\FeatureProd object
* Filter the query by a related \Thelia\Model\FeatureProduct object
*
* @param \Thelia\Model\FeatureProd|ObjectCollection $featureProd the related object to use as filter
* @param \Thelia\Model\FeatureProduct|ObjectCollection $featureProduct the related object to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return ChildFeatureAvQuery The current query, for fluid interface
*/
public function filterByFeatureProd($featureProd, $comparison = null)
public function filterByFeatureProduct($featureProduct, $comparison = null)
{
if ($featureProd instanceof \Thelia\Model\FeatureProd) {
if ($featureProduct instanceof \Thelia\Model\FeatureProduct) {
return $this
->addUsingAlias(FeatureAvTableMap::ID, $featureProd->getFeatureAvId(), $comparison);
} elseif ($featureProd instanceof ObjectCollection) {
->addUsingAlias(FeatureAvTableMap::ID, $featureProduct->getFeatureAvId(), $comparison);
} elseif ($featureProduct instanceof ObjectCollection) {
return $this
->useFeatureProdQuery()
->filterByPrimaryKeys($featureProd->getPrimaryKeys())
->useFeatureProductQuery()
->filterByPrimaryKeys($featureProduct->getPrimaryKeys())
->endUse();
} else {
throw new PropelException('filterByFeatureProd() only accepts arguments of type \Thelia\Model\FeatureProd or Collection');
throw new PropelException('filterByFeatureProduct() only accepts arguments of type \Thelia\Model\FeatureProduct or Collection');
}
}
/**
* Adds a JOIN clause to the query using the FeatureProd relation
* Adds a JOIN clause to the query using the FeatureProduct relation
*
* @param string $relationAlias optional alias for the relation
* @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
*
* @return ChildFeatureAvQuery The current query, for fluid interface
*/
public function joinFeatureProd($relationAlias = null, $joinType = Criteria::LEFT_JOIN)
public function joinFeatureProduct($relationAlias = null, $joinType = Criteria::LEFT_JOIN)
{
$tableMap = $this->getTableMap();
$relationMap = $tableMap->getRelation('FeatureProd');
$relationMap = $tableMap->getRelation('FeatureProduct');
// create a ModelJoin object for this join
$join = new ModelJoin();
@@ -576,14 +576,14 @@ abstract class FeatureAvQuery extends ModelCriteria
$this->addAlias($relationAlias, $relationMap->getRightTable()->getName());
$this->addJoinObject($join, $relationAlias);
} else {
$this->addJoinObject($join, 'FeatureProd');
$this->addJoinObject($join, 'FeatureProduct');
}
return $this;
}
/**
* Use the FeatureProd relation FeatureProd object
* Use the FeatureProduct relation FeatureProduct object
*
* @see useQuery()
*
@@ -591,13 +591,13 @@ abstract class FeatureAvQuery extends ModelCriteria
* to be used as main alias in the secondary query
* @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
*
* @return \Thelia\Model\FeatureProdQuery A secondary query class using the current class as primary query
* @return \Thelia\Model\FeatureProductQuery A secondary query class using the current class as primary query
*/
public function useFeatureProdQuery($relationAlias = null, $joinType = Criteria::LEFT_JOIN)
public function useFeatureProductQuery($relationAlias = null, $joinType = Criteria::LEFT_JOIN)
{
return $this
->joinFeatureProd($relationAlias, $joinType)
->useQuery($relationAlias ? $relationAlias : 'FeatureProd', '\Thelia\Model\FeatureProdQuery');
->joinFeatureProduct($relationAlias, $joinType)
->useQuery($relationAlias ? $relationAlias : 'FeatureProduct', '\Thelia\Model\FeatureProductQuery');
}
/**

1746
core/lib/Thelia/Model/Base/FeatureProduct.php Normal file
View File

File diff suppressed because it is too large Load Diff

963
core/lib/Thelia/Model/Base/FeatureProductQuery.php Normal file
View File

@@ -0,0 +1,963 @@
<?php
namespace Thelia\Model\Base;
use \Exception;
use \PDO;
use Propel\Runtime\Propel;
use Propel\Runtime\ActiveQuery\Criteria;
use Propel\Runtime\ActiveQuery\ModelCriteria;
use Propel\Runtime\ActiveQuery\ModelJoin;
use Propel\Runtime\Collection\Collection;
use Propel\Runtime\Collection\ObjectCollection;
use Propel\Runtime\Connection\ConnectionInterface;
use Propel\Runtime\Exception\PropelException;
use Thelia\Model\FeatureProduct as ChildFeatureProduct;
use Thelia\Model\FeatureProductQuery as ChildFeatureProductQuery;
use Thelia\Model\Map\FeatureProductTableMap;
/**
* Base class that represents a query for the 'feature_product' table.
*
*
*
* @method ChildFeatureProductQuery orderById($order = Criteria::ASC) Order by the id column
* @method ChildFeatureProductQuery orderByProductId($order = Criteria::ASC) Order by the product_id column
* @method ChildFeatureProductQuery orderByFeatureId($order = Criteria::ASC) Order by the feature_id column
* @method ChildFeatureProductQuery orderByFeatureAvId($order = Criteria::ASC) Order by the feature_av_id column
* @method ChildFeatureProductQuery orderByByDefault($order = Criteria::ASC) Order by the by_default column
* @method ChildFeatureProductQuery orderByPosition($order = Criteria::ASC) Order by the position column
* @method ChildFeatureProductQuery orderByCreatedAt($order = Criteria::ASC) Order by the created_at column
* @method ChildFeatureProductQuery orderByUpdatedAt($order = Criteria::ASC) Order by the updated_at column
*
* @method ChildFeatureProductQuery groupById() Group by the id column
* @method ChildFeatureProductQuery groupByProductId() Group by the product_id column
* @method ChildFeatureProductQuery groupByFeatureId() Group by the feature_id column
* @method ChildFeatureProductQuery groupByFeatureAvId() Group by the feature_av_id column
* @method ChildFeatureProductQuery groupByByDefault() Group by the by_default column
* @method ChildFeatureProductQuery groupByPosition() Group by the position column
* @method ChildFeatureProductQuery groupByCreatedAt() Group by the created_at column
* @method ChildFeatureProductQuery groupByUpdatedAt() Group by the updated_at column
*
* @method ChildFeatureProductQuery leftJoin($relation) Adds a LEFT JOIN clause to the query
* @method ChildFeatureProductQuery rightJoin($relation) Adds a RIGHT JOIN clause to the query
* @method ChildFeatureProductQuery innerJoin($relation) Adds a INNER JOIN clause to the query
*
* @method ChildFeatureProductQuery leftJoinProduct($relationAlias = null) Adds a LEFT JOIN clause to the query using the Product relation
* @method ChildFeatureProductQuery rightJoinProduct($relationAlias = null) Adds a RIGHT JOIN clause to the query using the Product relation
* @method ChildFeatureProductQuery innerJoinProduct($relationAlias = null) Adds a INNER JOIN clause to the query using the Product relation
*
* @method ChildFeatureProductQuery leftJoinFeature($relationAlias = null) Adds a LEFT JOIN clause to the query using the Feature relation
* @method ChildFeatureProductQuery rightJoinFeature($relationAlias = null) Adds a RIGHT JOIN clause to the query using the Feature relation
* @method ChildFeatureProductQuery innerJoinFeature($relationAlias = null) Adds a INNER JOIN clause to the query using the Feature relation
*
* @method ChildFeatureProductQuery leftJoinFeatureAv($relationAlias = null) Adds a LEFT JOIN clause to the query using the FeatureAv relation
* @method ChildFeatureProductQuery rightJoinFeatureAv($relationAlias = null) Adds a RIGHT JOIN clause to the query using the FeatureAv relation
* @method ChildFeatureProductQuery innerJoinFeatureAv($relationAlias = null) Adds a INNER JOIN clause to the query using the FeatureAv relation
*
* @method ChildFeatureProduct findOne(ConnectionInterface $con = null) Return the first ChildFeatureProduct matching the query
* @method ChildFeatureProduct findOneOrCreate(ConnectionInterface $con = null) Return the first ChildFeatureProduct matching the query, or a new ChildFeatureProduct object populated from the query conditions when no match is found
*
* @method ChildFeatureProduct findOneById(int $id) Return the first ChildFeatureProduct filtered by the id column
* @method ChildFeatureProduct findOneByProductId(int $product_id) Return the first ChildFeatureProduct filtered by the product_id column
* @method ChildFeatureProduct findOneByFeatureId(int $feature_id) Return the first ChildFeatureProduct filtered by the feature_id column
* @method ChildFeatureProduct findOneByFeatureAvId(int $feature_av_id) Return the first ChildFeatureProduct filtered by the feature_av_id column
* @method ChildFeatureProduct findOneByByDefault(string $by_default) Return the first ChildFeatureProduct filtered by the by_default column
* @method ChildFeatureProduct findOneByPosition(int $position) Return the first ChildFeatureProduct filtered by the position column
* @method ChildFeatureProduct findOneByCreatedAt(string $created_at) Return the first ChildFeatureProduct filtered by the created_at column
* @method ChildFeatureProduct findOneByUpdatedAt(string $updated_at) Return the first ChildFeatureProduct filtered by the updated_at column
*
* @method array findById(int $id) Return ChildFeatureProduct objects filtered by the id column
* @method array findByProductId(int $product_id) Return ChildFeatureProduct objects filtered by the product_id column
* @method array findByFeatureId(int $feature_id) Return ChildFeatureProduct objects filtered by the feature_id column
* @method array findByFeatureAvId(int $feature_av_id) Return ChildFeatureProduct objects filtered by the feature_av_id column
* @method array findByByDefault(string $by_default) Return ChildFeatureProduct objects filtered by the by_default column
* @method array findByPosition(int $position) Return ChildFeatureProduct objects filtered by the position column
* @method array findByCreatedAt(string $created_at) Return ChildFeatureProduct objects filtered by the created_at column
* @method array findByUpdatedAt(string $updated_at) Return ChildFeatureProduct objects filtered by the updated_at column
*
*/
abstract class FeatureProductQuery extends ModelCriteria
{
/**
* Initializes internal state of \Thelia\Model\Base\FeatureProductQuery object.
*
* @param string $dbName The database name
* @param string $modelName The phpName of a model, e.g. 'Book'
* @param string $modelAlias The alias for the model in this query, e.g. 'b'
*/
public function __construct($dbName = 'thelia', $modelName = '\\Thelia\\Model\\FeatureProduct', $modelAlias = null)
{
parent::__construct($dbName, $modelName, $modelAlias);
}
/**
* Returns a new ChildFeatureProductQuery object.
*
* @param string $modelAlias The alias of a model in the query
* @param Criteria $criteria Optional Criteria to build the query from
*
* @return ChildFeatureProductQuery
*/
public static function create($modelAlias = null, $criteria = null)
{
if ($criteria instanceof \Thelia\Model\FeatureProductQuery) {
return $criteria;
}
$query = new \Thelia\Model\FeatureProductQuery();
if (null !== $modelAlias) {
$query->setModelAlias($modelAlias);
}
if ($criteria instanceof Criteria) {
$query->mergeWith($criteria);
}
return $query;
}
/**
* Find object by primary key.
* Propel uses the instance pool to skip the database if the object exists.
* Go fast if the query is untouched.
*
* <code>
* $obj = $c->findPk(12, $con);
* </code>
*
* @param mixed $key Primary key to use for the query
* @param ConnectionInterface $con an optional connection object
*
* @return ChildFeatureProduct|array|mixed the result, formatted by the current formatter
*/
public function findPk($key, $con = null)
{
if ($key === null) {
return null;
}
if ((null !== ($obj = FeatureProductTableMap::getInstanceFromPool((string) $key))) && !$this->formatter) {
// the object is already in the instance pool
return $obj;
}
if ($con === null) {
$con = Propel::getServiceContainer()->getReadConnection(FeatureProductTableMap::DATABASE_NAME);
}
$this->basePreSelect($con);
if ($this->formatter || $this->modelAlias || $this->with || $this->select
|| $this->selectColumns || $this->asColumns || $this->selectModifiers
|| $this->map || $this->having || $this->joins) {
return $this->findPkComplex($key, $con);
} else {
return $this->findPkSimple($key, $con);
}
}
/**
* Find object by primary key using raw SQL to go fast.
* Bypass doSelect() and the object formatter by using generated code.
*
* @param mixed $key Primary key to use for the query
* @param ConnectionInterface $con A connection object
*
* @return ChildFeatureProduct A model object, or null if the key is not found
*/
protected function findPkSimple($key, $con)
{
$sql = 'SELECT ID, PRODUCT_ID, FEATURE_ID, FEATURE_AV_ID, BY_DEFAULT, POSITION, CREATED_AT, UPDATED_AT FROM feature_product WHERE ID = :p0';
try {
$stmt = $con->prepare($sql);
$stmt->bindValue(':p0', $key, PDO::PARAM_INT);
$stmt->execute();
} catch (Exception $e) {
Propel::log($e->getMessage(), Propel::LOG_ERR);
throw new PropelException(sprintf('Unable to execute SELECT statement [%s]', $sql), 0, $e);
}
$obj = null;
if ($row = $stmt->fetch(\PDO::FETCH_NUM)) {
$obj = new ChildFeatureProduct();
$obj->hydrate($row);
FeatureProductTableMap::addInstanceToPool($obj, (string) $key);
}
$stmt->closeCursor();
return $obj;
}
/**
* Find object by primary key.
*
* @param mixed $key Primary key to use for the query
* @param ConnectionInterface $con A connection object
*
* @return ChildFeatureProduct|array|mixed the result, formatted by the current formatter
*/
protected function findPkComplex($key, $con)
{
// As the query uses a PK condition, no limit(1) is necessary.
$criteria = $this->isKeepQuery() ? clone $this : $this;
$dataFetcher = $criteria
->filterByPrimaryKey($key)
->doSelect($con);
return $criteria->getFormatter()->init($criteria)->formatOne($dataFetcher);
}
/**
* Find objects by primary key
* <code>
* $objs = $c->findPks(array(12, 56, 832), $con);
* </code>
* @param array $keys Primary keys to use for the query
* @param ConnectionInterface $con an optional connection object
*
* @return ObjectCollection|array|mixed the list of results, formatted by the current formatter
*/
public function findPks($keys, $con = null)
{
if (null === $con) {
$con = Propel::getServiceContainer()->getReadConnection($this->getDbName());
}
$this->basePreSelect($con);
$criteria = $this->isKeepQuery() ? clone $this : $this;
$dataFetcher = $criteria
->filterByPrimaryKeys($keys)
->doSelect($con);
return $criteria->getFormatter()->init($criteria)->format($dataFetcher);
}
/**
* Filter the query by primary key
*
* @param mixed $key Primary key to use for the query
*
* @return ChildFeatureProductQuery The current query, for fluid interface
*/
public function filterByPrimaryKey($key)
{
return $this->addUsingAlias(FeatureProductTableMap::ID, $key, Criteria::EQUAL);
}
/**
* Filter the query by a list of primary keys
*
* @param array $keys The list of primary key to use for the query
*
* @return ChildFeatureProductQuery The current query, for fluid interface
*/
public function filterByPrimaryKeys($keys)
{
return $this->addUsingAlias(FeatureProductTableMap::ID, $keys, Criteria::IN);
}
/**
* Filter the query on the id column
*
* Example usage:
* <code>
* $query->filterById(1234); // WHERE id = 1234
* $query->filterById(array(12, 34)); // WHERE id IN (12, 34)
* $query->filterById(array('min' => 12)); // WHERE id > 12
* </code>
*
* @param mixed $id The value to use as filter.
* Use scalar values for equality.
* Use array values for in_array() equivalent.
* Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return ChildFeatureProductQuery The current query, for fluid interface
*/
public function filterById($id = null, $comparison = null)
{
if (is_array($id)) {
$useMinMax = false;
if (isset($id['min'])) {
$this->addUsingAlias(FeatureProductTableMap::ID, $id['min'], Criteria::GREATER_EQUAL);
$useMinMax = true;
}
if (isset($id['max'])) {
$this->addUsingAlias(FeatureProductTableMap::ID, $id['max'], Criteria::LESS_EQUAL);
$useMinMax = true;
}
if ($useMinMax) {
return $this;
}
if (null === $comparison) {
$comparison = Criteria::IN;
}
}
return $this->addUsingAlias(FeatureProductTableMap::ID, $id, $comparison);
}
/**
* Filter the query on the product_id column
*
* Example usage:
* <code>
* $query->filterByProductId(1234); // WHERE product_id = 1234
* $query->filterByProductId(array(12, 34)); // WHERE product_id IN (12, 34)
* $query->filterByProductId(array('min' => 12)); // WHERE product_id > 12
* </code>
*
* @see filterByProduct()
*
* @param mixed $productId The value to use as filter.
* Use scalar values for equality.
* Use array values for in_array() equivalent.
* Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return ChildFeatureProductQuery The current query, for fluid interface
*/
public function filterByProductId($productId = null, $comparison = null)
{
if (is_array($productId)) {
$useMinMax = false;
if (isset($productId['min'])) {
$this->addUsingAlias(FeatureProductTableMap::PRODUCT_ID, $productId['min'], Criteria::GREATER_EQUAL);
$useMinMax = true;
}
if (isset($productId['max'])) {
$this->addUsingAlias(FeatureProductTableMap::PRODUCT_ID, $productId['max'], Criteria::LESS_EQUAL);
$useMinMax = true;
}
if ($useMinMax) {
return $this;
}
if (null === $comparison) {
$comparison = Criteria::IN;
}
}
return $this->addUsingAlias(FeatureProductTableMap::PRODUCT_ID, $productId, $comparison);
}
/**
* Filter the query on the feature_id column
*
* Example usage:
* <code>
* $query->filterByFeatureId(1234); // WHERE feature_id = 1234
* $query->filterByFeatureId(array(12, 34)); // WHERE feature_id IN (12, 34)
* $query->filterByFeatureId(array('min' => 12)); // WHERE feature_id > 12
* </code>
*
* @see filterByFeature()
*
* @param mixed $featureId The value to use as filter.
* Use scalar values for equality.
* Use array values for in_array() equivalent.
* Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return ChildFeatureProductQuery The current query, for fluid interface
*/
public function filterByFeatureId($featureId = null, $comparison = null)
{
if (is_array($featureId)) {
$useMinMax = false;
if (isset($featureId['min'])) {
$this->addUsingAlias(FeatureProductTableMap::FEATURE_ID, $featureId['min'], Criteria::GREATER_EQUAL);
$useMinMax = true;
}
if (isset($featureId['max'])) {
$this->addUsingAlias(FeatureProductTableMap::FEATURE_ID, $featureId['max'], Criteria::LESS_EQUAL);
$useMinMax = true;
}
if ($useMinMax) {
return $this;
}
if (null === $comparison) {
$comparison = Criteria::IN;
}
}
return $this->addUsingAlias(FeatureProductTableMap::FEATURE_ID, $featureId, $comparison);
}
/**
* Filter the query on the feature_av_id column
*
* Example usage:
* <code>
* $query->filterByFeatureAvId(1234); // WHERE feature_av_id = 1234
* $query->filterByFeatureAvId(array(12, 34)); // WHERE feature_av_id IN (12, 34)
* $query->filterByFeatureAvId(array('min' => 12)); // WHERE feature_av_id > 12
* </code>
*
* @see filterByFeatureAv()
*
* @param mixed $featureAvId The value to use as filter.
* Use scalar values for equality.
* Use array values for in_array() equivalent.
* Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return ChildFeatureProductQuery The current query, for fluid interface
*/
public function filterByFeatureAvId($featureAvId = null, $comparison = null)
{
if (is_array($featureAvId)) {
$useMinMax = false;
if (isset($featureAvId['min'])) {
$this->addUsingAlias(FeatureProductTableMap::FEATURE_AV_ID, $featureAvId['min'], Criteria::GREATER_EQUAL);
$useMinMax = true;
}
if (isset($featureAvId['max'])) {
$this->addUsingAlias(FeatureProductTableMap::FEATURE_AV_ID, $featureAvId['max'], Criteria::LESS_EQUAL);
$useMinMax = true;
}
if ($useMinMax) {
return $this;
}
if (null === $comparison) {
$comparison = Criteria::IN;
}
}
return $this->addUsingAlias(FeatureProductTableMap::FEATURE_AV_ID, $featureAvId, $comparison);
}
/**
* Filter the query on the by_default column
*
* Example usage:
* <code>
* $query->filterByByDefault('fooValue'); // WHERE by_default = 'fooValue'
* $query->filterByByDefault('%fooValue%'); // WHERE by_default LIKE '%fooValue%'
* </code>
*
* @param string $byDefault The value to use as filter.
* Accepts wildcards (* and % trigger a LIKE)
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return ChildFeatureProductQuery The current query, for fluid interface
*/
public function filterByByDefault($byDefault = null, $comparison = null)
{
if (null === $comparison) {
if (is_array($byDefault)) {
$comparison = Criteria::IN;
} elseif (preg_match('/[\%\*]/', $byDefault)) {
$byDefault = str_replace('*', '%', $byDefault);
$comparison = Criteria::LIKE;
}
}
return $this->addUsingAlias(FeatureProductTableMap::BY_DEFAULT, $byDefault, $comparison);
}
/**
* Filter the query on the position column
*
* Example usage:
* <code>
* $query->filterByPosition(1234); // WHERE position = 1234
* $query->filterByPosition(array(12, 34)); // WHERE position IN (12, 34)
* $query->filterByPosition(array('min' => 12)); // WHERE position > 12
* </code>
*
* @param mixed $position The value to use as filter.
* Use scalar values for equality.
* Use array values for in_array() equivalent.
* Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return ChildFeatureProductQuery The current query, for fluid interface
*/
public function filterByPosition($position = null, $comparison = null)
{
if (is_array($position)) {
$useMinMax = false;
if (isset($position['min'])) {
$this->addUsingAlias(FeatureProductTableMap::POSITION, $position['min'], Criteria::GREATER_EQUAL);
$useMinMax = true;
}
if (isset($position['max'])) {
$this->addUsingAlias(FeatureProductTableMap::POSITION, $position['max'], Criteria::LESS_EQUAL);
$useMinMax = true;
}
if ($useMinMax) {
return $this;
}
if (null === $comparison) {
$comparison = Criteria::IN;
}
}
return $this->addUsingAlias(FeatureProductTableMap::POSITION, $position, $comparison);
}
/**
* Filter the query on the created_at column
*
* Example usage:
* <code>
* $query->filterByCreatedAt('2011-03-14'); // WHERE created_at = '2011-03-14'
* $query->filterByCreatedAt('now'); // WHERE created_at = '2011-03-14'
* $query->filterByCreatedAt(array('max' => 'yesterday')); // WHERE created_at > '2011-03-13'
* </code>
*
* @param mixed $createdAt The value to use as filter.
* Values can be integers (unix timestamps), DateTime objects, or strings.
* Empty strings are treated as NULL.
* Use scalar values for equality.
* Use array values for in_array() equivalent.
* Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return ChildFeatureProductQuery The current query, for fluid interface
*/
public function filterByCreatedAt($createdAt = null, $comparison = null)
{
if (is_array($createdAt)) {
$useMinMax = false;
if (isset($createdAt['min'])) {
$this->addUsingAlias(FeatureProductTableMap::CREATED_AT, $createdAt['min'], Criteria::GREATER_EQUAL);
$useMinMax = true;
}
if (isset($createdAt['max'])) {
$this->addUsingAlias(FeatureProductTableMap::CREATED_AT, $createdAt['max'], Criteria::LESS_EQUAL);
$useMinMax = true;
}
if ($useMinMax) {
return $this;
}
if (null === $comparison) {
$comparison = Criteria::IN;
}
}
return $this->addUsingAlias(FeatureProductTableMap::CREATED_AT, $createdAt, $comparison);
}
/**
* Filter the query on the updated_at column
*
* Example usage:
* <code>
* $query->filterByUpdatedAt('2011-03-14'); // WHERE updated_at = '2011-03-14'
* $query->filterByUpdatedAt('now'); // WHERE updated_at = '2011-03-14'
* $query->filterByUpdatedAt(array('max' => 'yesterday')); // WHERE updated_at > '2011-03-13'
* </code>
*
* @param mixed $updatedAt The value to use as filter.
* Values can be integers (unix timestamps), DateTime objects, or strings.
* Empty strings are treated as NULL.
* Use scalar values for equality.
* Use array values for in_array() equivalent.
* Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return ChildFeatureProductQuery The current query, for fluid interface
*/
public function filterByUpdatedAt($updatedAt = null, $comparison = null)
{
if (is_array($updatedAt)) {
$useMinMax = false;
if (isset($updatedAt['min'])) {
$this->addUsingAlias(FeatureProductTableMap::UPDATED_AT, $updatedAt['min'], Criteria::GREATER_EQUAL);
$useMinMax = true;
}
if (isset($updatedAt['max'])) {
$this->addUsingAlias(FeatureProductTableMap::UPDATED_AT, $updatedAt['max'], Criteria::LESS_EQUAL);
$useMinMax = true;
}
if ($useMinMax) {
return $this;
}
if (null === $comparison) {
$comparison = Criteria::IN;
}
}
return $this->addUsingAlias(FeatureProductTableMap::UPDATED_AT, $updatedAt, $comparison);
}
/**
* Filter the query by a related \Thelia\Model\Product object
*
* @param \Thelia\Model\Product|ObjectCollection $product The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return ChildFeatureProductQuery The current query, for fluid interface
*/
public function filterByProduct($product, $comparison = null)
{
if ($product instanceof \Thelia\Model\Product) {
return $this
->addUsingAlias(FeatureProductTableMap::PRODUCT_ID, $product->getId(), $comparison);
} elseif ($product instanceof ObjectCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this
->addUsingAlias(FeatureProductTableMap::PRODUCT_ID, $product->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByProduct() only accepts arguments of type \Thelia\Model\Product or Collection');
}
}
/**
* Adds a JOIN clause to the query using the Product relation
*
* @param string $relationAlias optional alias for the relation
* @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
*
* @return ChildFeatureProductQuery The current query, for fluid interface
*/
public function joinProduct($relationAlias = null, $joinType = Criteria::INNER_JOIN)
{
$tableMap = $this->getTableMap();
$relationMap = $tableMap->getRelation('Product');
// create a ModelJoin object for this join
$join = new ModelJoin();
$join->setJoinType($joinType);
$join->setRelationMap($relationMap, $this->useAliasInSQL ? $this->getModelAlias() : null, $relationAlias);
if ($previousJoin = $this->getPreviousJoin()) {
$join->setPreviousJoin($previousJoin);
}
// add the ModelJoin to the current object
if ($relationAlias) {
$this->addAlias($relationAlias, $relationMap->getRightTable()->getName());
$this->addJoinObject($join, $relationAlias);
} else {
$this->addJoinObject($join, 'Product');
}
return $this;
}
/**
* Use the Product relation Product object
*
* @see useQuery()
*
* @param string $relationAlias optional alias for the relation,
* to be used as main alias in the secondary query
* @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
*
* @return \Thelia\Model\ProductQuery A secondary query class using the current class as primary query
*/
public function useProductQuery($relationAlias = null, $joinType = Criteria::INNER_JOIN)
{
return $this
->joinProduct($relationAlias, $joinType)
->useQuery($relationAlias ? $relationAlias : 'Product', '\Thelia\Model\ProductQuery');
}
/**
* Filter the query by a related \Thelia\Model\Feature object
*
* @param \Thelia\Model\Feature|ObjectCollection $feature The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return ChildFeatureProductQuery The current query, for fluid interface
*/
public function filterByFeature($feature, $comparison = null)
{
if ($feature instanceof \Thelia\Model\Feature) {
return $this
->addUsingAlias(FeatureProductTableMap::FEATURE_ID, $feature->getId(), $comparison);
} elseif ($feature instanceof ObjectCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this
->addUsingAlias(FeatureProductTableMap::FEATURE_ID, $feature->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByFeature() only accepts arguments of type \Thelia\Model\Feature or Collection');
}
}
/**
* Adds a JOIN clause to the query using the Feature relation
*
* @param string $relationAlias optional alias for the relation
* @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
*
* @return ChildFeatureProductQuery The current query, for fluid interface
*/
public function joinFeature($relationAlias = null, $joinType = Criteria::INNER_JOIN)
{
$tableMap = $this->getTableMap();
$relationMap = $tableMap->getRelation('Feature');
// create a ModelJoin object for this join
$join = new ModelJoin();
$join->setJoinType($joinType);
$join->setRelationMap($relationMap, $this->useAliasInSQL ? $this->getModelAlias() : null, $relationAlias);
if ($previousJoin = $this->getPreviousJoin()) {
$join->setPreviousJoin($previousJoin);
}
// add the ModelJoin to the current object
if ($relationAlias) {
$this->addAlias($relationAlias, $relationMap->getRightTable()->getName());
$this->addJoinObject($join, $relationAlias);
} else {
$this->addJoinObject($join, 'Feature');
}
return $this;
}
/**
* Use the Feature relation Feature object
*
* @see useQuery()
*
* @param string $relationAlias optional alias for the relation,
* to be used as main alias in the secondary query
* @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
*
* @return \Thelia\Model\FeatureQuery A secondary query class using the current class as primary query
*/
public function useFeatureQuery($relationAlias = null, $joinType = Criteria::INNER_JOIN)
{
return $this
->joinFeature($relationAlias, $joinType)
->useQuery($relationAlias ? $relationAlias : 'Feature', '\Thelia\Model\FeatureQuery');
}
/**
* Filter the query by a related \Thelia\Model\FeatureAv object
*
* @param \Thelia\Model\FeatureAv|ObjectCollection $featureAv The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return ChildFeatureProductQuery The current query, for fluid interface
*/
public function filterByFeatureAv($featureAv, $comparison = null)
{
if ($featureAv instanceof \Thelia\Model\FeatureAv) {
return $this
->addUsingAlias(FeatureProductTableMap::FEATURE_AV_ID, $featureAv->getId(), $comparison);
} elseif ($featureAv instanceof ObjectCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this
->addUsingAlias(FeatureProductTableMap::FEATURE_AV_ID, $featureAv->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByFeatureAv() only accepts arguments of type \Thelia\Model\FeatureAv or Collection');
}
}
/**
* Adds a JOIN clause to the query using the FeatureAv relation
*
* @param string $relationAlias optional alias for the relation
* @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
*
* @return ChildFeatureProductQuery The current query, for fluid interface
*/
public function joinFeatureAv($relationAlias = null, $joinType = Criteria::LEFT_JOIN)
{
$tableMap = $this->getTableMap();
$relationMap = $tableMap->getRelation('FeatureAv');
// create a ModelJoin object for this join
$join = new ModelJoin();
$join->setJoinType($joinType);
$join->setRelationMap($relationMap, $this->useAliasInSQL ? $this->getModelAlias() : null, $relationAlias);
if ($previousJoin = $this->getPreviousJoin()) {
$join->setPreviousJoin($previousJoin);
}
// add the ModelJoin to the current object
if ($relationAlias) {
$this->addAlias($relationAlias, $relationMap->getRightTable()->getName());
$this->addJoinObject($join, $relationAlias);
} else {
$this->addJoinObject($join, 'FeatureAv');
}
return $this;
}
/**
* Use the FeatureAv relation FeatureAv object
*
* @see useQuery()
*
* @param string $relationAlias optional alias for the relation,
* to be used as main alias in the secondary query
* @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
*
* @return \Thelia\Model\FeatureAvQuery A secondary query class using the current class as primary query
*/
public function useFeatureAvQuery($relationAlias = null, $joinType = Criteria::LEFT_JOIN)
{
return $this
->joinFeatureAv($relationAlias, $joinType)
->useQuery($relationAlias ? $relationAlias : 'FeatureAv', '\Thelia\Model\FeatureAvQuery');
}
/**
* Exclude object from result
*
* @param ChildFeatureProduct $featureProduct Object to remove from the list of results
*
* @return ChildFeatureProductQuery The current query, for fluid interface
*/
public function prune($featureProduct = null)
{
if ($featureProduct) {
$this->addUsingAlias(FeatureProductTableMap::ID, $featureProduct->getId(), Criteria::NOT_EQUAL);
}
return $this;
}
/**
* Deletes all rows from the feature_product table.
*
* @param ConnectionInterface $con the connection to use
* @return int The number of affected rows (if supported by underlying database driver).
*/
public function doDeleteAll(ConnectionInterface $con = null)
{
if (null === $con) {
$con = Propel::getServiceContainer()->getWriteConnection(FeatureProductTableMap::DATABASE_NAME);
}
$affectedRows = 0; // initialize var to track total num of affected rows
try {
// use transaction because $criteria could contain info
// for more than one table or we could emulating ON DELETE CASCADE, etc.
$con->beginTransaction();
$affectedRows += parent::doDeleteAll($con);
// Because this db requires some delete cascade/set null emulation, we have to
// clear the cached instance *after* the emulation has happened (since
// instances get re-added by the select statement contained therein).
FeatureProductTableMap::clearInstancePool();
FeatureProductTableMap::clearRelatedInstancePool();
$con->commit();
} catch (PropelException $e) {
$con->rollBack();
throw $e;
}
return $affectedRows;
}
/**
* Performs a DELETE on the database, given a ChildFeatureProduct or Criteria object OR a primary key value.
*
* @param mixed $values Criteria or ChildFeatureProduct object or primary key or array of primary keys
* which is used to create the DELETE statement
* @param ConnectionInterface $con the connection to use
* @return int The number of affected rows (if supported by underlying database driver). This includes CASCADE-related rows
* if supported by native driver or if emulated using Propel.
* @throws PropelException Any exceptions caught during processing will be
* rethrown wrapped into a PropelException.
*/
public function delete(ConnectionInterface $con = null)
{
if (null === $con) {
$con = Propel::getServiceContainer()->getWriteConnection(FeatureProductTableMap::DATABASE_NAME);
}
$criteria = $this;
// Set the correct dbName
$criteria->setDbName(FeatureProductTableMap::DATABASE_NAME);
$affectedRows = 0; // initialize var to track total num of affected rows
try {
// use transaction because $criteria could contain info
// for more than one table or we could emulating ON DELETE CASCADE, etc.
$con->beginTransaction();
FeatureProductTableMap::removeInstanceFromPool($criteria);
$affectedRows += ModelCriteria::delete($con);
FeatureProductTableMap::clearRelatedInstancePool();
$con->commit();
return $affectedRows;
} catch (PropelException $e) {
$con->rollBack();
throw $e;
}
}
// timestampable behavior
/**
* Filter by the latest updated
*
* @param int $nbDays Maximum age of the latest update in days
*
* @return ChildFeatureProductQuery The current query, for fluid interface
*/
public function recentlyUpdated($nbDays = 7)
{
return $this->addUsingAlias(FeatureProductTableMap::UPDATED_AT, time() - $nbDays * 24 * 60 * 60, Criteria::GREATER_EQUAL);
}
/**
* Filter by the latest created
*
* @param int $nbDays Maximum age of in days
*
* @return ChildFeatureProductQuery The current query, for fluid interface
*/
public function recentlyCreated($nbDays = 7)
{
return $this->addUsingAlias(FeatureProductTableMap::CREATED_AT, time() - $nbDays * 24 * 60 * 60, Criteria::GREATER_EQUAL);
}
/**
* Order by update date desc
*
* @return ChildFeatureProductQuery The current query, for fluid interface
*/
public function lastUpdatedFirst()
{
return $this->addDescendingOrderByColumn(FeatureProductTableMap::UPDATED_AT);
}
/**
* Order by update date asc
*
* @return ChildFeatureProductQuery The current query, for fluid interface
*/
public function firstUpdatedFirst()
{
return $this->addAscendingOrderByColumn(FeatureProductTableMap::UPDATED_AT);
}
/**
* Order by create date desc
*
* @return ChildFeatureProductQuery The current query, for fluid interface
*/
public function lastCreatedFirst()
{
return $this->addDescendingOrderByColumn(FeatureProductTableMap::CREATED_AT);
}
/**
* Order by create date asc
*
* @return ChildFeatureProductQuery The current query, for fluid interface
*/
public function firstCreatedFirst()
{
return $this->addAscendingOrderByColumn(FeatureProductTableMap::CREATED_AT);
}
} // FeatureProductQuery

42
core/lib/Thelia/Model/Base/FeatureQuery.php
View File

@@ -42,9 +42,9 @@ use Thelia\Model\Map\FeatureTableMap;
* @method ChildFeatureQuery rightJoinFeatureAv($relationAlias = null) Adds a RIGHT JOIN clause to the query using the FeatureAv relation
* @method ChildFeatureQuery innerJoinFeatureAv($relationAlias = null) Adds a INNER JOIN clause to the query using the FeatureAv relation
*
* @method ChildFeatureQuery leftJoinFeatureProd($relationAlias = null) Adds a LEFT JOIN clause to the query using the FeatureProd relation
* @method ChildFeatureQuery rightJoinFeatureProd($relationAlias = null) Adds a RIGHT JOIN clause to the query using the FeatureProd relation
* @method ChildFeatureQuery innerJoinFeatureProd($relationAlias = null) Adds a INNER JOIN clause to the query using the FeatureProd relation
* @method ChildFeatureQuery leftJoinFeatureProduct($relationAlias = null) Adds a LEFT JOIN clause to the query using the FeatureProduct relation
* @method ChildFeatureQuery rightJoinFeatureProduct($relationAlias = null) Adds a RIGHT JOIN clause to the query using the FeatureProduct relation
* @method ChildFeatureQuery innerJoinFeatureProduct($relationAlias = null) Adds a INNER JOIN clause to the query using the FeatureProduct relation
*
* @method ChildFeatureQuery leftJoinFeatureCategory($relationAlias = null) Adds a LEFT JOIN clause to the query using the FeatureCategory relation
* @method ChildFeatureQuery rightJoinFeatureCategory($relationAlias = null) Adds a RIGHT JOIN clause to the query using the FeatureCategory relation
@@ -528,40 +528,40 @@ abstract class FeatureQuery extends ModelCriteria
}
/**
* Filter the query by a related \Thelia\Model\FeatureProd object
* Filter the query by a related \Thelia\Model\FeatureProduct object
*
* @param \Thelia\Model\FeatureProd|ObjectCollection $featureProd the related object to use as filter
* @param \Thelia\Model\FeatureProduct|ObjectCollection $featureProduct the related object to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return ChildFeatureQuery The current query, for fluid interface
*/
public function filterByFeatureProd($featureProd, $comparison = null)
public function filterByFeatureProduct($featureProduct, $comparison = null)
{
if ($featureProd instanceof \Thelia\Model\FeatureProd) {
if ($featureProduct instanceof \Thelia\Model\FeatureProduct) {
return $this
->addUsingAlias(FeatureTableMap::ID, $featureProd->getFeatureId(), $comparison);
} elseif ($featureProd instanceof ObjectCollection) {
->addUsingAlias(FeatureTableMap::ID, $featureProduct->getFeatureId(), $comparison);
} elseif ($featureProduct instanceof ObjectCollection) {
return $this
->useFeatureProdQuery()
->filterByPrimaryKeys($featureProd->getPrimaryKeys())
->useFeatureProductQuery()
->filterByPrimaryKeys($featureProduct->getPrimaryKeys())
->endUse();
} else {
throw new PropelException('filterByFeatureProd() only accepts arguments of type \Thelia\Model\FeatureProd or Collection');
throw new PropelException('filterByFeatureProduct() only accepts arguments of type \Thelia\Model\FeatureProduct or Collection');
}
}
/**
* Adds a JOIN clause to the query using the FeatureProd relation
* Adds a JOIN clause to the query using the FeatureProduct relation
*
* @param string $relationAlias optional alias for the relation
* @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
*
* @return ChildFeatureQuery The current query, for fluid interface
*/
public function joinFeatureProd($relationAlias = null, $joinType = Criteria::INNER_JOIN)
public function joinFeatureProduct($relationAlias = null, $joinType = Criteria::INNER_JOIN)
{
$tableMap = $this->getTableMap();
$relationMap = $tableMap->getRelation('FeatureProd');
$relationMap = $tableMap->getRelation('FeatureProduct');
// create a ModelJoin object for this join
$join = new ModelJoin();
@@ -576,14 +576,14 @@ abstract class FeatureQuery extends ModelCriteria
$this->addAlias($relationAlias, $relationMap->getRightTable()->getName());
$this->addJoinObject($join, $relationAlias);
} else {
$this->addJoinObject($join, 'FeatureProd');
$this->addJoinObject($join, 'FeatureProduct');
}
return $this;
}
/**
* Use the FeatureProd relation FeatureProd object
* Use the FeatureProduct relation FeatureProduct object
*
* @see useQuery()
*
@@ -591,13 +591,13 @@ abstract class FeatureQuery extends ModelCriteria
* to be used as main alias in the secondary query
* @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
*
* @return \Thelia\Model\FeatureProdQuery A secondary query class using the current class as primary query
* @return \Thelia\Model\FeatureProductQuery A secondary query class using the current class as primary query
*/
public function useFeatureProdQuery($relationAlias = null, $joinType = Criteria::INNER_JOIN)
public function useFeatureProductQuery($relationAlias = null, $joinType = Criteria::INNER_JOIN)
{
return $this
->joinFeatureProd($relationAlias, $joinType)
->useQuery($relationAlias ? $relationAlias : 'FeatureProd', '\Thelia\Model\FeatureProdQuery');
->joinFeatureProduct($relationAlias, $joinType)
->useQuery($relationAlias ? $relationAlias : 'FeatureProduct', '\Thelia\Model\FeatureProductQuery');
}
/**

226
core/lib/Thelia/Model/Base/Product.php
View File

@@ -27,8 +27,8 @@ use Thelia\Model\ContentAssoc as ChildContentAssoc;
use Thelia\Model\ContentAssocQuery as ChildContentAssocQuery;
use Thelia\Model\Document as ChildDocument;
use Thelia\Model\DocumentQuery as ChildDocumentQuery;
use Thelia\Model\FeatureProd as ChildFeatureProd;
use Thelia\Model\FeatureProdQuery as ChildFeatureProdQuery;
use Thelia\Model\FeatureProduct as ChildFeatureProduct;
use Thelia\Model\FeatureProductQuery as ChildFeatureProductQuery;
use Thelia\Model\Image as ChildImage;
use Thelia\Model\ImageQuery as ChildImageQuery;
use Thelia\Model\Product as ChildProduct;
@@ -156,10 +156,10 @@ abstract class Product implements ActiveRecordInterface
protected $collProductCategoriesPartial;
/**
* @var ObjectCollection|ChildFeatureProd[] Collection to store aggregation of ChildFeatureProd objects.
* @var ObjectCollection|ChildFeatureProduct[] Collection to store aggregation of ChildFeatureProduct objects.
*/
protected $collFeatureProds;
protected $collFeatureProdsPartial;
protected $collFeatureProducts;
protected $collFeatureProductsPartial;
/**
* @var ObjectCollection|ChildStock[] Collection to store aggregation of ChildStock objects.
@@ -294,7 +294,7 @@ abstract class Product implements ActiveRecordInterface
* An array of objects scheduled for deletion.
* @var ObjectCollection
*/
protected $featureProdsScheduledForDeletion = null;
protected $featureProductsScheduledForDeletion = null;
/**
* An array of objects scheduled for deletion.
@@ -1133,7 +1133,7 @@ abstract class Product implements ActiveRecordInterface
$this->aTaxRule = null;
$this->collProductCategories = null;
$this->collFeatureProds = null;
$this->collFeatureProducts = null;
$this->collStocks = null;
@@ -1413,17 +1413,17 @@ abstract class Product implements ActiveRecordInterface
}
}
if ($this->featureProdsScheduledForDeletion !== null) {
if (!$this->featureProdsScheduledForDeletion->isEmpty()) {
\Thelia\Model\FeatureProdQuery::create()
->filterByPrimaryKeys($this->featureProdsScheduledForDeletion->getPrimaryKeys(false))
if ($this->featureProductsScheduledForDeletion !== null) {
if (!$this->featureProductsScheduledForDeletion->isEmpty()) {
\Thelia\Model\FeatureProductQuery::create()
->filterByPrimaryKeys($this->featureProductsScheduledForDeletion->getPrimaryKeys(false))
->delete($con);
$this->featureProdsScheduledForDeletion = null;
$this->featureProductsScheduledForDeletion = null;
}
}
if ($this->collFeatureProds !== null) {
foreach ($this->collFeatureProds as $referrerFK) {
if ($this->collFeatureProducts !== null) {
foreach ($this->collFeatureProducts as $referrerFK) {
if (!$referrerFK->isDeleted() && ($referrerFK->isNew() || $referrerFK->isModified())) {
$affectedRows += $referrerFK->save($con);
}
@@ -1842,8 +1842,8 @@ abstract class Product implements ActiveRecordInterface
if (null !== $this->collProductCategories) {
$result['ProductCategories'] = $this->collProductCategories->toArray(null, true, $keyType, $includeLazyLoadColumns, $alreadyDumpedObjects);
}
if (null !== $this->collFeatureProds) {
$result['FeatureProds'] = $this->collFeatureProds->toArray(null, true, $keyType, $includeLazyLoadColumns, $alreadyDumpedObjects);
if (null !== $this->collFeatureProducts) {
$result['FeatureProducts'] = $this->collFeatureProducts->toArray(null, true, $keyType, $includeLazyLoadColumns, $alreadyDumpedObjects);
}
if (null !== $this->collStocks) {
$result['Stocks'] = $this->collStocks->toArray(null, true, $keyType, $includeLazyLoadColumns, $alreadyDumpedObjects);
@@ -2078,9 +2078,9 @@ abstract class Product implements ActiveRecordInterface
}
}
foreach ($this->getFeatureProds() as $relObj) {
foreach ($this->getFeatureProducts() as $relObj) {
if ($relObj !== $this) { // ensure that we don't try to copy a reference to ourselves
$copyObj->addFeatureProd($relObj->copy($deepCopy));
$copyObj->addFeatureProduct($relObj->copy($deepCopy));
}
}
@@ -2239,8 +2239,8 @@ abstract class Product implements ActiveRecordInterface
if ('ProductCategory' == $relationName) {
return $this->initProductCategories();
}
if ('FeatureProd' == $relationName) {
return $this->initFeatureProds();
if ('FeatureProduct' == $relationName) {
return $this->initFeatureProducts();
}
if ('Stock' == $relationName) {
return $this->initStocks();
@@ -2521,31 +2521,31 @@ abstract class Product implements ActiveRecordInterface
}
/**
* Clears out the collFeatureProds collection
* Clears out the collFeatureProducts collection
*
* This does not modify the database; however, it will remove any associated objects, causing
* them to be refetched by subsequent calls to accessor method.
*
* @return void
* @see addFeatureProds()
* @see addFeatureProducts()
*/
public function clearFeatureProds()
public function clearFeatureProducts()
{
$this->collFeatureProds = null; // important to set this to NULL since that means it is uninitialized
$this->collFeatureProducts = null; // important to set this to NULL since that means it is uninitialized
}
/**
* Reset is the collFeatureProds collection loaded partially.
* Reset is the collFeatureProducts collection loaded partially.
*/
public function resetPartialFeatureProds($v = true)
public function resetPartialFeatureProducts($v = true)
{
$this->collFeatureProdsPartial = $v;
$this->collFeatureProductsPartial = $v;
}
/**
* Initializes the collFeatureProds collection.
* Initializes the collFeatureProducts collection.
*
* By default this just sets the collFeatureProds collection to an empty array (like clearcollFeatureProds());
* By default this just sets the collFeatureProducts collection to an empty array (like clearcollFeatureProducts());
* however, you may wish to override this method in your stub class to provide setting appropriate
* to your application -- for example, setting the initial array to the values stored in database.
*
@@ -2554,17 +2554,17 @@ abstract class Product implements ActiveRecordInterface
*
* @return void
*/
public function initFeatureProds($overrideExisting = true)
public function initFeatureProducts($overrideExisting = true)
{
if (null !== $this->collFeatureProds && !$overrideExisting) {
if (null !== $this->collFeatureProducts && !$overrideExisting) {
return;
}
$this->collFeatureProds = new ObjectCollection();
$this->collFeatureProds->setModel('\Thelia\Model\FeatureProd');
$this->collFeatureProducts = new ObjectCollection();
$this->collFeatureProducts->setModel('\Thelia\Model\FeatureProduct');
}
/**
* Gets an array of ChildFeatureProd objects which contain a foreign key that references this object.
* Gets an array of ChildFeatureProduct objects which contain a foreign key that references this object.
*
* If the $criteria is not null, it is used to always fetch the results from the database.
* Otherwise the results are fetched from the database the first time, then cached.
@@ -2574,109 +2574,109 @@ abstract class Product implements ActiveRecordInterface
*
* @param Criteria $criteria optional Criteria object to narrow the query
* @param ConnectionInterface $con optional connection object
* @return Collection|ChildFeatureProd[] List of ChildFeatureProd objects
* @return Collection|ChildFeatureProduct[] List of ChildFeatureProduct objects
* @throws PropelException
*/
public function getFeatureProds($criteria = null, ConnectionInterface $con = null)
public function getFeatureProducts($criteria = null, ConnectionInterface $con = null)
{
$partial = $this->collFeatureProdsPartial && !$this->isNew();
if (null === $this->collFeatureProds || null !== $criteria || $partial) {
if ($this->isNew() && null === $this->collFeatureProds) {
$partial = $this->collFeatureProductsPartial && !$this->isNew();
if (null === $this->collFeatureProducts || null !== $criteria || $partial) {
if ($this->isNew() && null === $this->collFeatureProducts) {
// return empty collection
$this->initFeatureProds();
$this->initFeatureProducts();
} else {
$collFeatureProds = ChildFeatureProdQuery::create(null, $criteria)
$collFeatureProducts = ChildFeatureProductQuery::create(null, $criteria)
->filterByProduct($this)
->find($con);
if (null !== $criteria) {
if (false !== $this->collFeatureProdsPartial && count($collFeatureProds)) {
$this->initFeatureProds(false);
if (false !== $this->collFeatureProductsPartial && count($collFeatureProducts)) {
$this->initFeatureProducts(false);
foreach ($collFeatureProds as $obj) {
if (false == $this->collFeatureProds->contains($obj)) {
$this->collFeatureProds->append($obj);
foreach ($collFeatureProducts as $obj) {
if (false == $this->collFeatureProducts->contains($obj)) {
$this->collFeatureProducts->append($obj);
}
}
$this->collFeatureProdsPartial = true;
$this->collFeatureProductsPartial = true;
}
$collFeatureProds->getInternalIterator()->rewind();
$collFeatureProducts->getInternalIterator()->rewind();
return $collFeatureProds;
return $collFeatureProducts;
}
if ($partial && $this->collFeatureProds) {
foreach ($this->collFeatureProds as $obj) {
if ($partial && $this->collFeatureProducts) {
foreach ($this->collFeatureProducts as $obj) {
if ($obj->isNew()) {
$collFeatureProds[] = $obj;
$collFeatureProducts[] = $obj;
}
}
}
$this->collFeatureProds = $collFeatureProds;
$this->collFeatureProdsPartial = false;
$this->collFeatureProducts = $collFeatureProducts;
$this->collFeatureProductsPartial = false;
}
}
return $this->collFeatureProds;
return $this->collFeatureProducts;
}
/**
* Sets a collection of FeatureProd objects related by a one-to-many relationship
* Sets a collection of FeatureProduct objects related by a one-to-many relationship
* to the current object.
* It will also schedule objects for deletion based on a diff between old objects (aka persisted)
* and new objects from the given Propel collection.
*
* @param Collection $featureProds A Propel collection.
* @param Collection $featureProducts A Propel collection.
* @param ConnectionInterface $con Optional connection object
* @return ChildProduct The current object (for fluent API support)
*/
public function setFeatureProds(Collection $featureProds, ConnectionInterface $con = null)
public function setFeatureProducts(Collection $featureProducts, ConnectionInterface $con = null)
{
$featureProdsToDelete = $this->getFeatureProds(new Criteria(), $con)->diff($featureProds);
$featureProductsToDelete = $this->getFeatureProducts(new Criteria(), $con)->diff($featureProducts);
$this->featureProdsScheduledForDeletion = $featureProdsToDelete;
$this->featureProductsScheduledForDeletion = $featureProductsToDelete;
foreach ($featureProdsToDelete as $featureProdRemoved) {
$featureProdRemoved->setProduct(null);
foreach ($featureProductsToDelete as $featureProductRemoved) {
$featureProductRemoved->setProduct(null);
}
$this->collFeatureProds = null;
foreach ($featureProds as $featureProd) {
$this->addFeatureProd($featureProd);
$this->collFeatureProducts = null;
foreach ($featureProducts as $featureProduct) {
$this->addFeatureProduct($featureProduct);
}
$this->collFeatureProds = $featureProds;
$this->collFeatureProdsPartial = false;
$this->collFeatureProducts = $featureProducts;
$this->collFeatureProductsPartial = false;
return $this;
}
/**
* Returns the number of related FeatureProd objects.
* Returns the number of related FeatureProduct objects.
*
* @param Criteria $criteria
* @param boolean $distinct
* @param ConnectionInterface $con
* @return int Count of related FeatureProd objects.
* @return int Count of related FeatureProduct objects.
* @throws PropelException
*/
public function countFeatureProds(Criteria $criteria = null, $distinct = false, ConnectionInterface $con = null)
public function countFeatureProducts(Criteria $criteria = null, $distinct = false, ConnectionInterface $con = null)
{
$partial = $this->collFeatureProdsPartial && !$this->isNew();
if (null === $this->collFeatureProds || null !== $criteria || $partial) {
if ($this->isNew() && null === $this->collFeatureProds) {
$partial = $this->collFeatureProductsPartial && !$this->isNew();
if (null === $this->collFeatureProducts || null !== $criteria || $partial) {
if ($this->isNew() && null === $this->collFeatureProducts) {
return 0;
}
if ($partial && !$criteria) {
return count($this->getFeatureProds());
return count($this->getFeatureProducts());
}
$query = ChildFeatureProdQuery::create(null, $criteria);
$query = ChildFeatureProductQuery::create(null, $criteria);
if ($distinct) {
$query->distinct();
}
@@ -2686,53 +2686,53 @@ abstract class Product implements ActiveRecordInterface
->count($con);
}
return count($this->collFeatureProds);
return count($this->collFeatureProducts);
}
/**
* Method called to associate a ChildFeatureProd object to this object
* through the ChildFeatureProd foreign key attribute.
* Method called to associate a ChildFeatureProduct object to this object
* through the ChildFeatureProduct foreign key attribute.
*
* @param ChildFeatureProd $l ChildFeatureProd
* @param ChildFeatureProduct $l ChildFeatureProduct
* @return \Thelia\Model\Product The current object (for fluent API support)
*/
public function addFeatureProd(ChildFeatureProd $l)
public function addFeatureProduct(ChildFeatureProduct $l)
{
if ($this->collFeatureProds === null) {
$this->initFeatureProds();
$this->collFeatureProdsPartial = true;
if ($this->collFeatureProducts === null) {
$this->initFeatureProducts();
$this->collFeatureProductsPartial = true;
}
if (!in_array($l, $this->collFeatureProds->getArrayCopy(), true)) { // only add it if the **same** object is not already associated
$this->doAddFeatureProd($l);
if (!in_array($l, $this->collFeatureProducts->getArrayCopy(), true)) { // only add it if the **same** object is not already associated
$this->doAddFeatureProduct($l);
}
return $this;
}
/**
* @param FeatureProd $featureProd The featureProd object to add.
* @param FeatureProduct $featureProduct The featureProduct object to add.
*/
protected function doAddFeatureProd($featureProd)
protected function doAddFeatureProduct($featureProduct)
{
$this->collFeatureProds[]= $featureProd;
$featureProd->setProduct($this);
$this->collFeatureProducts[]= $featureProduct;
$featureProduct->setProduct($this);
}
/**
* @param FeatureProd $featureProd The featureProd object to remove.
* @param FeatureProduct $featureProduct The featureProduct object to remove.
* @return ChildProduct The current object (for fluent API support)
*/
public function removeFeatureProd($featureProd)
public function removeFeatureProduct($featureProduct)
{
if ($this->getFeatureProds()->contains($featureProd)) {
$this->collFeatureProds->remove($this->collFeatureProds->search($featureProd));
if (null === $this->featureProdsScheduledForDeletion) {
$this->featureProdsScheduledForDeletion = clone $this->collFeatureProds;
$this->featureProdsScheduledForDeletion->clear();
if ($this->getFeatureProducts()->contains($featureProduct)) {
$this->collFeatureProducts->remove($this->collFeatureProducts->search($featureProduct));
if (null === $this->featureProductsScheduledForDeletion) {
$this->featureProductsScheduledForDeletion = clone $this->collFeatureProducts;
$this->featureProductsScheduledForDeletion->clear();
}
$this->featureProdsScheduledForDeletion[]= clone $featureProd;
$featureProd->setProduct(null);
$this->featureProductsScheduledForDeletion[]= clone $featureProduct;
$featureProduct->setProduct(null);
}
return $this;
@@ -2744,7 +2744,7 @@ abstract class Product implements ActiveRecordInterface
* an identical criteria, it returns the collection.
* Otherwise if this Product is new, it will return
* an empty collection; or if this Product has previously
* been saved, it will retrieve related FeatureProds from storage.
* been saved, it will retrieve related FeatureProducts from storage.
*
* This method is protected by default in order to keep the public
* api reasonable. You can provide public methods for those you
@@ -2753,14 +2753,14 @@ abstract class Product implements ActiveRecordInterface
* @param Criteria $criteria optional Criteria object to narrow the query
* @param ConnectionInterface $con optional connection object
* @param string $joinBehavior optional join type to use (defaults to Criteria::LEFT_JOIN)
* @return Collection|ChildFeatureProd[] List of ChildFeatureProd objects
* @return Collection|ChildFeatureProduct[] List of ChildFeatureProduct objects
*/
public function getFeatureProdsJoinFeature($criteria = null, $con = null, $joinBehavior = Criteria::LEFT_JOIN)
public function getFeatureProductsJoinFeature($criteria = null, $con = null, $joinBehavior = Criteria::LEFT_JOIN)
{
$query = ChildFeatureProdQuery::create(null, $criteria);
$query = ChildFeatureProductQuery::create(null, $criteria);
$query->joinWith('Feature', $joinBehavior);
return $this->getFeatureProds($query, $con);
return $this->getFeatureProducts($query, $con);
}
@@ -2769,7 +2769,7 @@ abstract class Product implements ActiveRecordInterface
* an identical criteria, it returns the collection.
* Otherwise if this Product is new, it will return
* an empty collection; or if this Product has previously
* been saved, it will retrieve related FeatureProds from storage.
* been saved, it will retrieve related FeatureProducts from storage.
*
* This method is protected by default in order to keep the public
* api reasonable. You can provide public methods for those you
@@ -2778,14 +2778,14 @@ abstract class Product implements ActiveRecordInterface
* @param Criteria $criteria optional Criteria object to narrow the query
* @param ConnectionInterface $con optional connection object
* @param string $joinBehavior optional join type to use (defaults to Criteria::LEFT_JOIN)
* @return Collection|ChildFeatureProd[] List of ChildFeatureProd objects
* @return Collection|ChildFeatureProduct[] List of ChildFeatureProduct objects
*/
public function getFeatureProdsJoinFeatureAv($criteria = null, $con = null, $joinBehavior = Criteria::LEFT_JOIN)
public function getFeatureProductsJoinFeatureAv($criteria = null, $con = null, $joinBehavior = Criteria::LEFT_JOIN)
{
$query = ChildFeatureProdQuery::create(null, $criteria);
$query = ChildFeatureProductQuery::create(null, $criteria);
$query->joinWith('FeatureAv', $joinBehavior);
return $this->getFeatureProds($query, $con);
return $this->getFeatureProducts($query, $con);
}
/**
@@ -5892,8 +5892,8 @@ abstract class Product implements ActiveRecordInterface
$o->clearAllReferences($deep);
}
}
if ($this->collFeatureProds) {
foreach ($this->collFeatureProds as $o) {
if ($this->collFeatureProducts) {
foreach ($this->collFeatureProducts as $o) {
$o->clearAllReferences($deep);
}
}
@@ -5972,10 +5972,10 @@ abstract class Product implements ActiveRecordInterface
$this->collProductCategories->clearIterator();
}
$this->collProductCategories = null;
if ($this->collFeatureProds instanceof Collection) {
$this->collFeatureProds->clearIterator();
if ($this->collFeatureProducts instanceof Collection) {
$this->collFeatureProducts->clearIterator();
}
$this->collFeatureProds = null;
$this->collFeatureProducts = null;
if ($this->collStocks instanceof Collection) {
$this->collStocks->clearIterator();
}

42
core/lib/Thelia/Model/Base/ProductQuery.php
View File

@@ -56,9 +56,9 @@ use Thelia\Model\Map\ProductTableMap;
* @method ChildProductQuery rightJoinProductCategory($relationAlias = null) Adds a RIGHT JOIN clause to the query using the ProductCategory relation
* @method ChildProductQuery innerJoinProductCategory($relationAlias = null) Adds a INNER JOIN clause to the query using the ProductCategory relation
*
* @method ChildProductQuery leftJoinFeatureProd($relationAlias = null) Adds a LEFT JOIN clause to the query using the FeatureProd relation
* @method ChildProductQuery rightJoinFeatureProd($relationAlias = null) Adds a RIGHT JOIN clause to the query using the FeatureProd relation
* @method ChildProductQuery innerJoinFeatureProd($relationAlias = null) Adds a INNER JOIN clause to the query using the FeatureProd relation
* @method ChildProductQuery leftJoinFeatureProduct($relationAlias = null) Adds a LEFT JOIN clause to the query using the FeatureProduct relation
* @method ChildProductQuery rightJoinFeatureProduct($relationAlias = null) Adds a RIGHT JOIN clause to the query using the FeatureProduct relation
* @method ChildProductQuery innerJoinFeatureProduct($relationAlias = null) Adds a INNER JOIN clause to the query using the FeatureProduct relation
*
* @method ChildProductQuery leftJoinStock($relationAlias = null) Adds a LEFT JOIN clause to the query using the Stock relation
* @method ChildProductQuery rightJoinStock($relationAlias = null) Adds a RIGHT JOIN clause to the query using the Stock relation
@@ -851,40 +851,40 @@ abstract class ProductQuery extends ModelCriteria
}
/**
* Filter the query by a related \Thelia\Model\FeatureProd object
* Filter the query by a related \Thelia\Model\FeatureProduct object
*
* @param \Thelia\Model\FeatureProd|ObjectCollection $featureProd the related object to use as filter
* @param \Thelia\Model\FeatureProduct|ObjectCollection $featureProduct the related object to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return ChildProductQuery The current query, for fluid interface
*/
public function filterByFeatureProd($featureProd, $comparison = null)
public function filterByFeatureProduct($featureProduct, $comparison = null)
{
if ($featureProd instanceof \Thelia\Model\FeatureProd) {
if ($featureProduct instanceof \Thelia\Model\FeatureProduct) {
return $this
->addUsingAlias(ProductTableMap::ID, $featureProd->getProductId(), $comparison);
} elseif ($featureProd instanceof ObjectCollection) {
->addUsingAlias(ProductTableMap::ID, $featureProduct->getProductId(), $comparison);
} elseif ($featureProduct instanceof ObjectCollection) {
return $this
->useFeatureProdQuery()
->filterByPrimaryKeys($featureProd->getPrimaryKeys())
->useFeatureProductQuery()
->filterByPrimaryKeys($featureProduct->getPrimaryKeys())
->endUse();
} else {
throw new PropelException('filterByFeatureProd() only accepts arguments of type \Thelia\Model\FeatureProd or Collection');
throw new PropelException('filterByFeatureProduct() only accepts arguments of type \Thelia\Model\FeatureProduct or Collection');
}
}
/**
* Adds a JOIN clause to the query using the FeatureProd relation
* Adds a JOIN clause to the query using the FeatureProduct relation
*
* @param string $relationAlias optional alias for the relation
* @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
*
* @return ChildProductQuery The current query, for fluid interface
*/
public function joinFeatureProd($relationAlias = null, $joinType = Criteria::INNER_JOIN)
public function joinFeatureProduct($relationAlias = null, $joinType = Criteria::INNER_JOIN)
{
$tableMap = $this->getTableMap();
$relationMap = $tableMap->getRelation('FeatureProd');
$relationMap = $tableMap->getRelation('FeatureProduct');
// create a ModelJoin object for this join
$join = new ModelJoin();
@@ -899,14 +899,14 @@ abstract class ProductQuery extends ModelCriteria
$this->addAlias($relationAlias, $relationMap->getRightTable()->getName());
$this->addJoinObject($join, $relationAlias);
} else {
$this->addJoinObject($join, 'FeatureProd');
$this->addJoinObject($join, 'FeatureProduct');
}
return $this;
}
/**
* Use the FeatureProd relation FeatureProd object
* Use the FeatureProduct relation FeatureProduct object
*
* @see useQuery()
*
@@ -914,13 +914,13 @@ abstract class ProductQuery extends ModelCriteria
* to be used as main alias in the secondary query
* @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
*
* @return \Thelia\Model\FeatureProdQuery A secondary query class using the current class as primary query
* @return \Thelia\Model\FeatureProductQuery A secondary query class using the current class as primary query
*/
public function useFeatureProdQuery($relationAlias = null, $joinType = Criteria::INNER_JOIN)
public function useFeatureProductQuery($relationAlias = null, $joinType = Criteria::INNER_JOIN)
{
return $this
->joinFeatureProd($relationAlias, $joinType)
->useQuery($relationAlias ? $relationAlias : 'FeatureProd', '\Thelia\Model\FeatureProdQuery');
->joinFeatureProduct($relationAlias, $joinType)
->useQuery($relationAlias ? $relationAlias : 'FeatureProduct', '\Thelia\Model\FeatureProductQuery');
}
/**