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

rewriting tables

Browse Source
This commit is contained in:
Etienne Roudeix
2013-08-28 15:47:47 +02:00
parent 61e13c416c
commit 1de0e9f8a4
24 changed files with 6197 additions and 1739 deletions
Download Patch File Download Diff File Expand all files Collapse all files

347
core/lib/Thelia/Model/Base/Category.php
View File

@@ -41,8 +41,6 @@ use Thelia\Model\Product as ChildProduct;
use Thelia\Model\ProductCategory as ChildProductCategory;
use Thelia\Model\ProductCategoryQuery as ChildProductCategoryQuery;
use Thelia\Model\ProductQuery as ChildProductQuery;
use Thelia\Model\Rewriting as ChildRewriting;
use Thelia\Model\RewritingQuery as ChildRewritingQuery;
use Thelia\Model\Map\CategoryTableMap;
use Thelia\Model\Map\CategoryVersionTableMap;
@@ -153,12 +151,6 @@ abstract class Category implements ActiveRecordInterface
protected $collAttributeCategories;
protected $collAttributeCategoriesPartial;
/**
* @var ObjectCollection|ChildRewriting[] Collection to store aggregation of ChildRewriting objects.
*/
protected $collRewritings;
protected $collRewritingsPartial;
/**
* @var ObjectCollection|ChildCategoryImage[] Collection to store aggregation of ChildCategoryImage objects.
*/
@@ -270,12 +262,6 @@ abstract class Category implements ActiveRecordInterface
*/
protected $attributeCategoriesScheduledForDeletion = null;
/**
* An array of objects scheduled for deletion.
* @var ObjectCollection
*/
protected $rewritingsScheduledForDeletion = null;
/**
* An array of objects scheduled for deletion.
* @var ObjectCollection
@@ -1039,8 +1025,6 @@ abstract class Category implements ActiveRecordInterface
$this->collAttributeCategories = null;
$this->collRewritings = null;
$this->collCategoryImages = null;
$this->collCategoryDocuments = null;
@@ -1331,23 +1315,6 @@ abstract class Category implements ActiveRecordInterface
}
}
if ($this->rewritingsScheduledForDeletion !== null) {
if (!$this->rewritingsScheduledForDeletion->isEmpty()) {
\Thelia\Model\RewritingQuery::create()
->filterByPrimaryKeys($this->rewritingsScheduledForDeletion->getPrimaryKeys(false))
->delete($con);
$this->rewritingsScheduledForDeletion = null;
}
}
if ($this->collRewritings !== null) {
foreach ($this->collRewritings as $referrerFK) {
if (!$referrerFK->isDeleted() && ($referrerFK->isNew() || $referrerFK->isModified())) {
$affectedRows += $referrerFK->save($con);
}
}
}
if ($this->categoryImagesScheduledForDeletion !== null) {
if (!$this->categoryImagesScheduledForDeletion->isEmpty()) {
\Thelia\Model\CategoryImageQuery::create()
@@ -1668,9 +1635,6 @@ abstract class Category implements ActiveRecordInterface
if (null !== $this->collAttributeCategories) {
$result['AttributeCategories'] = $this->collAttributeCategories->toArray(null, true, $keyType, $includeLazyLoadColumns, $alreadyDumpedObjects);
}
if (null !== $this->collRewritings) {
$result['Rewritings'] = $this->collRewritings->toArray(null, true, $keyType, $includeLazyLoadColumns, $alreadyDumpedObjects);
}
if (null !== $this->collCategoryImages) {
$result['CategoryImages'] = $this->collCategoryImages->toArray(null, true, $keyType, $includeLazyLoadColumns, $alreadyDumpedObjects);
}
@@ -1895,12 +1859,6 @@ abstract class Category implements ActiveRecordInterface
}
}
foreach ($this->getRewritings() as $relObj) {
if ($relObj !== $this) { // ensure that we don't try to copy a reference to ourselves
$copyObj->addRewriting($relObj->copy($deepCopy));
}
}
foreach ($this->getCategoryImages() as $relObj) {
if ($relObj !== $this) { // ensure that we don't try to copy a reference to ourselves
$copyObj->addCategoryImage($relObj->copy($deepCopy));
@@ -1981,9 +1939,6 @@ abstract class Category implements ActiveRecordInterface
if ('AttributeCategory' == $relationName) {
return $this->initAttributeCategories();
}
if ('Rewriting' == $relationName) {
return $this->initRewritings();
}
if ('CategoryImage' == $relationName) {
return $this->initCategoryImages();
}
@@ -2733,299 +2688,6 @@ abstract class Category implements ActiveRecordInterface
return $this->getAttributeCategories($query, $con);
}
/**
* Clears out the collRewritings 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 addRewritings()
*/
public function clearRewritings()
{
$this->collRewritings = null; // important to set this to NULL since that means it is uninitialized
}
/**
* Reset is the collRewritings collection loaded partially.
*/
public function resetPartialRewritings($v = true)
{
$this->collRewritingsPartial = $v;
}
/**
* Initializes the collRewritings collection.
*
* By default this just sets the collRewritings collection to an empty array (like clearcollRewritings());
* 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.
*
* @param boolean $overrideExisting If set to true, the method call initializes
* the collection even if it is not empty
*
* @return void
*/
public function initRewritings($overrideExisting = true)
{
if (null !== $this->collRewritings && !$overrideExisting) {
return;
}
$this->collRewritings = new ObjectCollection();
$this->collRewritings->setModel('\Thelia\Model\Rewriting');
}
/**
* Gets an array of ChildRewriting 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.
* Next time the same method is called without $criteria, the cached collection is returned.
* If this ChildCategory is new, it will return
* an empty collection or the current collection; the criteria is ignored on a new object.
*
* @param Criteria $criteria optional Criteria object to narrow the query
* @param ConnectionInterface $con optional connection object
* @return Collection|ChildRewriting[] List of ChildRewriting objects
* @throws PropelException
*/
public function getRewritings($criteria = null, ConnectionInterface $con = null)
{
$partial = $this->collRewritingsPartial && !$this->isNew();
if (null === $this->collRewritings || null !== $criteria || $partial) {
if ($this->isNew() && null === $this->collRewritings) {
// return empty collection
$this->initRewritings();
} else {
$collRewritings = ChildRewritingQuery::create(null, $criteria)
->filterByCategory($this)
->find($con);
if (null !== $criteria) {
if (false !== $this->collRewritingsPartial && count($collRewritings)) {
$this->initRewritings(false);
foreach ($collRewritings as $obj) {
if (false == $this->collRewritings->contains($obj)) {
$this->collRewritings->append($obj);
}
}
$this->collRewritingsPartial = true;
}
$collRewritings->getInternalIterator()->rewind();
return $collRewritings;
}
if ($partial && $this->collRewritings) {
foreach ($this->collRewritings as $obj) {
if ($obj->isNew()) {
$collRewritings[] = $obj;
}
}
}
$this->collRewritings = $collRewritings;
$this->collRewritingsPartial = false;
}
}
return $this->collRewritings;
}
/**
* Sets a collection of Rewriting 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 $rewritings A Propel collection.
* @param ConnectionInterface $con Optional connection object
* @return ChildCategory The current object (for fluent API support)
*/
public function setRewritings(Collection $rewritings, ConnectionInterface $con = null)
{
$rewritingsToDelete = $this->getRewritings(new Criteria(), $con)->diff($rewritings);
$this->rewritingsScheduledForDeletion = $rewritingsToDelete;
foreach ($rewritingsToDelete as $rewritingRemoved) {
$rewritingRemoved->setCategory(null);
}
$this->collRewritings = null;
foreach ($rewritings as $rewriting) {
$this->addRewriting($rewriting);
}
$this->collRewritings = $rewritings;
$this->collRewritingsPartial = false;
return $this;
}
/**
* Returns the number of related Rewriting objects.
*
* @param Criteria $criteria
* @param boolean $distinct
* @param ConnectionInterface $con
* @return int Count of related Rewriting objects.
* @throws PropelException
*/
public function countRewritings(Criteria $criteria = null, $distinct = false, ConnectionInterface $con = null)
{
$partial = $this->collRewritingsPartial && !$this->isNew();
if (null === $this->collRewritings || null !== $criteria || $partial) {
if ($this->isNew() && null === $this->collRewritings) {
return 0;
}
if ($partial && !$criteria) {
return count($this->getRewritings());
}
$query = ChildRewritingQuery::create(null, $criteria);
if ($distinct) {
$query->distinct();
}
return $query
->filterByCategory($this)
->count($con);
}
return count($this->collRewritings);
}
/**
* Method called to associate a ChildRewriting object to this object
* through the ChildRewriting foreign key attribute.
*
* @param ChildRewriting $l ChildRewriting
* @return \Thelia\Model\Category The current object (for fluent API support)
*/
public function addRewriting(ChildRewriting $l)
{
if ($this->collRewritings === null) {
$this->initRewritings();
$this->collRewritingsPartial = true;
}
if (!in_array($l, $this->collRewritings->getArrayCopy(), true)) { // only add it if the **same** object is not already associated
$this->doAddRewriting($l);
}
return $this;
}
/**
* @param Rewriting $rewriting The rewriting object to add.
*/
protected function doAddRewriting($rewriting)
{
$this->collRewritings[]= $rewriting;
$rewriting->setCategory($this);
}
/**
* @param Rewriting $rewriting The rewriting object to remove.
* @return ChildCategory The current object (for fluent API support)
*/
public function removeRewriting($rewriting)
{
if ($this->getRewritings()->contains($rewriting)) {
$this->collRewritings->remove($this->collRewritings->search($rewriting));
if (null === $this->rewritingsScheduledForDeletion) {
$this->rewritingsScheduledForDeletion = clone $this->collRewritings;
$this->rewritingsScheduledForDeletion->clear();
}
$this->rewritingsScheduledForDeletion[]= $rewriting;
$rewriting->setCategory(null);
}
return $this;
}
/**
* If this collection has already been initialized with
* an identical criteria, it returns the collection.
* Otherwise if this Category is new, it will return
* an empty collection; or if this Category has previously
* been saved, it will retrieve related Rewritings from storage.
*
* This method is protected by default in order to keep the public
* api reasonable. You can provide public methods for those you
* actually need in Category.
*
* @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|ChildRewriting[] List of ChildRewriting objects
*/
public function getRewritingsJoinProduct($criteria = null, $con = null, $joinBehavior = Criteria::LEFT_JOIN)
{
$query = ChildRewritingQuery::create(null, $criteria);
$query->joinWith('Product', $joinBehavior);
return $this->getRewritings($query, $con);
}
/**
* If this collection has already been initialized with
* an identical criteria, it returns the collection.
* Otherwise if this Category is new, it will return
* an empty collection; or if this Category has previously
* been saved, it will retrieve related Rewritings from storage.
*
* This method is protected by default in order to keep the public
* api reasonable. You can provide public methods for those you
* actually need in Category.
*
* @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|ChildRewriting[] List of ChildRewriting objects
*/
public function getRewritingsJoinFolder($criteria = null, $con = null, $joinBehavior = Criteria::LEFT_JOIN)
{
$query = ChildRewritingQuery::create(null, $criteria);
$query->joinWith('Folder', $joinBehavior);
return $this->getRewritings($query, $con);
}
/**
* If this collection has already been initialized with
* an identical criteria, it returns the collection.
* Otherwise if this Category is new, it will return
* an empty collection; or if this Category has previously
* been saved, it will retrieve related Rewritings from storage.
*
* This method is protected by default in order to keep the public
* api reasonable. You can provide public methods for those you
* actually need in Category.
*
* @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|ChildRewriting[] List of ChildRewriting objects
*/
public function getRewritingsJoinContent($criteria = null, $con = null, $joinBehavior = Criteria::LEFT_JOIN)
{
$query = ChildRewritingQuery::create(null, $criteria);
$query->joinWith('Content', $joinBehavior);
return $this->getRewritings($query, $con);
}
/**
* Clears out the collCategoryImages collection
*
@@ -4749,11 +4411,6 @@ abstract class Category implements ActiveRecordInterface
$o->clearAllReferences($deep);
}
}
if ($this->collRewritings) {
foreach ($this->collRewritings as $o) {
$o->clearAllReferences($deep);
}
}
if ($this->collCategoryImages) {
foreach ($this->collCategoryImages as $o) {
$o->clearAllReferences($deep);
@@ -4812,10 +4469,6 @@ abstract class Category implements ActiveRecordInterface
$this->collAttributeCategories->clearIterator();
}
$this->collAttributeCategories = null;
if ($this->collRewritings instanceof Collection) {
$this->collRewritings->clearIterator();
}
$this->collRewritings = null;
if ($this->collCategoryImages instanceof Collection) {
$this->collCategoryImages->clearIterator();
}

77
core/lib/Thelia/Model/Base/CategoryQuery.php
View File

@@ -58,10 +58,6 @@ use Thelia\Model\Map\CategoryTableMap;
* @method ChildCategoryQuery rightJoinAttributeCategory($relationAlias = null) Adds a RIGHT JOIN clause to the query using the AttributeCategory relation
* @method ChildCategoryQuery innerJoinAttributeCategory($relationAlias = null) Adds a INNER JOIN clause to the query using the AttributeCategory relation
*
* @method ChildCategoryQuery leftJoinRewriting($relationAlias = null) Adds a LEFT JOIN clause to the query using the Rewriting relation
* @method ChildCategoryQuery rightJoinRewriting($relationAlias = null) Adds a RIGHT JOIN clause to the query using the Rewriting relation
* @method ChildCategoryQuery innerJoinRewriting($relationAlias = null) Adds a INNER JOIN clause to the query using the Rewriting relation
*
* @method ChildCategoryQuery leftJoinCategoryImage($relationAlias = null) Adds a LEFT JOIN clause to the query using the CategoryImage relation
* @method ChildCategoryQuery rightJoinCategoryImage($relationAlias = null) Adds a RIGHT JOIN clause to the query using the CategoryImage relation
* @method ChildCategoryQuery innerJoinCategoryImage($relationAlias = null) Adds a INNER JOIN clause to the query using the CategoryImage relation
@@ -870,79 +866,6 @@ abstract class CategoryQuery extends ModelCriteria
->useQuery($relationAlias ? $relationAlias : 'AttributeCategory', '\Thelia\Model\AttributeCategoryQuery');
}
/**
* Filter the query by a related \Thelia\Model\Rewriting object
*
* @param \Thelia\Model\Rewriting|ObjectCollection $rewriting the related object to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return ChildCategoryQuery The current query, for fluid interface
*/
public function filterByRewriting($rewriting, $comparison = null)
{
if ($rewriting instanceof \Thelia\Model\Rewriting) {
return $this
->addUsingAlias(CategoryTableMap::ID, $rewriting->getCategoryId(), $comparison);
} elseif ($rewriting instanceof ObjectCollection) {
return $this
->useRewritingQuery()
->filterByPrimaryKeys($rewriting->getPrimaryKeys())
->endUse();
} else {
throw new PropelException('filterByRewriting() only accepts arguments of type \Thelia\Model\Rewriting or Collection');
}
}
/**
* Adds a JOIN clause to the query using the Rewriting relation
*
* @param string $relationAlias optional alias for the relation
* @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
*
* @return ChildCategoryQuery The current query, for fluid interface
*/
public function joinRewriting($relationAlias = null, $joinType = Criteria::LEFT_JOIN)
{
$tableMap = $this->getTableMap();
$relationMap = $tableMap->getRelation('Rewriting');
// 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, 'Rewriting');
}
return $this;
}
/**
* Use the Rewriting relation Rewriting 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\RewritingQuery A secondary query class using the current class as primary query
*/
public function useRewritingQuery($relationAlias = null, $joinType = Criteria::LEFT_JOIN)
{
return $this
->joinRewriting($relationAlias, $joinType)
->useQuery($relationAlias ? $relationAlias : 'Rewriting', '\Thelia\Model\RewritingQuery');
}
/**
* Filter the query by a related \Thelia\Model\CategoryImage object
*

347
core/lib/Thelia/Model/Base/Content.php
View File

@@ -35,8 +35,6 @@ use Thelia\Model\Folder as ChildFolder;
use Thelia\Model\FolderQuery as ChildFolderQuery;
use Thelia\Model\ProductAssociatedContent as ChildProductAssociatedContent;
use Thelia\Model\ProductAssociatedContentQuery as ChildProductAssociatedContentQuery;
use Thelia\Model\Rewriting as ChildRewriting;
use Thelia\Model\RewritingQuery as ChildRewritingQuery;
use Thelia\Model\Map\ContentTableMap;
use Thelia\Model\Map\ContentVersionTableMap;
@@ -123,12 +121,6 @@ abstract class Content implements ActiveRecordInterface
*/
protected $version_created_by;
/**
* @var ObjectCollection|ChildRewriting[] Collection to store aggregation of ChildRewriting objects.
*/
protected $collRewritings;
protected $collRewritingsPartial;
/**
* @var ObjectCollection|ChildContentFolder[] Collection to store aggregation of ChildContentFolder objects.
*/
@@ -212,12 +204,6 @@ abstract class Content implements ActiveRecordInterface
*/
protected $foldersScheduledForDeletion = null;
/**
* An array of objects scheduled for deletion.
* @var ObjectCollection
*/
protected $rewritingsScheduledForDeletion = null;
/**
* An array of objects scheduled for deletion.
* @var ObjectCollection
@@ -952,8 +938,6 @@ abstract class Content implements ActiveRecordInterface
if ($deep) { // also de-associate any related objects?
$this->collRewritings = null;
$this->collContentFolders = null;
$this->collContentImages = null;
@@ -1141,23 +1125,6 @@ abstract class Content implements ActiveRecordInterface
}
}
if ($this->rewritingsScheduledForDeletion !== null) {
if (!$this->rewritingsScheduledForDeletion->isEmpty()) {
\Thelia\Model\RewritingQuery::create()
->filterByPrimaryKeys($this->rewritingsScheduledForDeletion->getPrimaryKeys(false))
->delete($con);
$this->rewritingsScheduledForDeletion = null;
}
}
if ($this->collRewritings !== null) {
foreach ($this->collRewritings as $referrerFK) {
if (!$referrerFK->isDeleted() && ($referrerFK->isNew() || $referrerFK->isModified())) {
$affectedRows += $referrerFK->save($con);
}
}
}
if ($this->contentFoldersScheduledForDeletion !== null) {
if (!$this->contentFoldersScheduledForDeletion->isEmpty()) {
\Thelia\Model\ContentFolderQuery::create()
@@ -1493,9 +1460,6 @@ abstract class Content implements ActiveRecordInterface
}
if ($includeForeignObjects) {
if (null !== $this->collRewritings) {
$result['Rewritings'] = $this->collRewritings->toArray(null, true, $keyType, $includeLazyLoadColumns, $alreadyDumpedObjects);
}
if (null !== $this->collContentFolders) {
$result['ContentFolders'] = $this->collContentFolders->toArray(null, true, $keyType, $includeLazyLoadColumns, $alreadyDumpedObjects);
}
@@ -1702,12 +1666,6 @@ abstract class Content implements ActiveRecordInterface
// the getter/setter methods for fkey referrer objects.
$copyObj->setNew(false);
foreach ($this->getRewritings() as $relObj) {
if ($relObj !== $this) { // ensure that we don't try to copy a reference to ourselves
$copyObj->addRewriting($relObj->copy($deepCopy));
}
}
foreach ($this->getContentFolders() as $relObj) {
if ($relObj !== $this) { // ensure that we don't try to copy a reference to ourselves
$copyObj->addContentFolder($relObj->copy($deepCopy));
@@ -1791,9 +1749,6 @@ abstract class Content implements ActiveRecordInterface
*/
public function initRelation($relationName)
{
if ('Rewriting' == $relationName) {
return $this->initRewritings();
}
if ('ContentFolder' == $relationName) {
return $this->initContentFolders();
}
@@ -1817,299 +1772,6 @@ abstract class Content implements ActiveRecordInterface
}
}
/**
* Clears out the collRewritings 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 addRewritings()
*/
public function clearRewritings()
{
$this->collRewritings = null; // important to set this to NULL since that means it is uninitialized
}
/**
* Reset is the collRewritings collection loaded partially.
*/
public function resetPartialRewritings($v = true)
{
$this->collRewritingsPartial = $v;
}
/**
* Initializes the collRewritings collection.
*
* By default this just sets the collRewritings collection to an empty array (like clearcollRewritings());
* 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.
*
* @param boolean $overrideExisting If set to true, the method call initializes
* the collection even if it is not empty
*
* @return void
*/
public function initRewritings($overrideExisting = true)
{
if (null !== $this->collRewritings && !$overrideExisting) {
return;
}
$this->collRewritings = new ObjectCollection();
$this->collRewritings->setModel('\Thelia\Model\Rewriting');
}
/**
* Gets an array of ChildRewriting 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.
* Next time the same method is called without $criteria, the cached collection is returned.
* If this ChildContent is new, it will return
* an empty collection or the current collection; the criteria is ignored on a new object.
*
* @param Criteria $criteria optional Criteria object to narrow the query
* @param ConnectionInterface $con optional connection object
* @return Collection|ChildRewriting[] List of ChildRewriting objects
* @throws PropelException
*/
public function getRewritings($criteria = null, ConnectionInterface $con = null)
{
$partial = $this->collRewritingsPartial && !$this->isNew();
if (null === $this->collRewritings || null !== $criteria || $partial) {
if ($this->isNew() && null === $this->collRewritings) {
// return empty collection
$this->initRewritings();
} else {
$collRewritings = ChildRewritingQuery::create(null, $criteria)
->filterByContent($this)
->find($con);
if (null !== $criteria) {
if (false !== $this->collRewritingsPartial && count($collRewritings)) {
$this->initRewritings(false);
foreach ($collRewritings as $obj) {
if (false == $this->collRewritings->contains($obj)) {
$this->collRewritings->append($obj);
}
}
$this->collRewritingsPartial = true;
}
$collRewritings->getInternalIterator()->rewind();
return $collRewritings;
}
if ($partial && $this->collRewritings) {
foreach ($this->collRewritings as $obj) {
if ($obj->isNew()) {
$collRewritings[] = $obj;
}
}
}
$this->collRewritings = $collRewritings;
$this->collRewritingsPartial = false;
}
}
return $this->collRewritings;
}
/**
* Sets a collection of Rewriting 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 $rewritings A Propel collection.
* @param ConnectionInterface $con Optional connection object
* @return ChildContent The current object (for fluent API support)
*/
public function setRewritings(Collection $rewritings, ConnectionInterface $con = null)
{
$rewritingsToDelete = $this->getRewritings(new Criteria(), $con)->diff($rewritings);
$this->rewritingsScheduledForDeletion = $rewritingsToDelete;
foreach ($rewritingsToDelete as $rewritingRemoved) {
$rewritingRemoved->setContent(null);
}
$this->collRewritings = null;
foreach ($rewritings as $rewriting) {
$this->addRewriting($rewriting);
}
$this->collRewritings = $rewritings;
$this->collRewritingsPartial = false;
return $this;
}
/**
* Returns the number of related Rewriting objects.
*
* @param Criteria $criteria
* @param boolean $distinct
* @param ConnectionInterface $con
* @return int Count of related Rewriting objects.
* @throws PropelException
*/
public function countRewritings(Criteria $criteria = null, $distinct = false, ConnectionInterface $con = null)
{
$partial = $this->collRewritingsPartial && !$this->isNew();
if (null === $this->collRewritings || null !== $criteria || $partial) {
if ($this->isNew() && null === $this->collRewritings) {
return 0;
}
if ($partial && !$criteria) {
return count($this->getRewritings());
}
$query = ChildRewritingQuery::create(null, $criteria);
if ($distinct) {
$query->distinct();
}
return $query
->filterByContent($this)
->count($con);
}
return count($this->collRewritings);
}
/**
* Method called to associate a ChildRewriting object to this object
* through the ChildRewriting foreign key attribute.
*
* @param ChildRewriting $l ChildRewriting
* @return \Thelia\Model\Content The current object (for fluent API support)
*/
public function addRewriting(ChildRewriting $l)
{
if ($this->collRewritings === null) {
$this->initRewritings();
$this->collRewritingsPartial = true;
}
if (!in_array($l, $this->collRewritings->getArrayCopy(), true)) { // only add it if the **same** object is not already associated
$this->doAddRewriting($l);
}
return $this;
}
/**
* @param Rewriting $rewriting The rewriting object to add.
*/
protected function doAddRewriting($rewriting)
{
$this->collRewritings[]= $rewriting;
$rewriting->setContent($this);
}
/**
* @param Rewriting $rewriting The rewriting object to remove.
* @return ChildContent The current object (for fluent API support)
*/
public function removeRewriting($rewriting)
{
if ($this->getRewritings()->contains($rewriting)) {
$this->collRewritings->remove($this->collRewritings->search($rewriting));
if (null === $this->rewritingsScheduledForDeletion) {
$this->rewritingsScheduledForDeletion = clone $this->collRewritings;
$this->rewritingsScheduledForDeletion->clear();
}
$this->rewritingsScheduledForDeletion[]= $rewriting;
$rewriting->setContent(null);
}
return $this;
}
/**
* If this collection has already been initialized with
* an identical criteria, it returns the collection.
* Otherwise if this Content is new, it will return
* an empty collection; or if this Content has previously
* been saved, it will retrieve related Rewritings from storage.
*
* This method is protected by default in order to keep the public
* api reasonable. You can provide public methods for those you
* actually need in Content.
*
* @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|ChildRewriting[] List of ChildRewriting objects
*/
public function getRewritingsJoinProduct($criteria = null, $con = null, $joinBehavior = Criteria::LEFT_JOIN)
{
$query = ChildRewritingQuery::create(null, $criteria);
$query->joinWith('Product', $joinBehavior);
return $this->getRewritings($query, $con);
}
/**
* If this collection has already been initialized with
* an identical criteria, it returns the collection.
* Otherwise if this Content is new, it will return
* an empty collection; or if this Content has previously
* been saved, it will retrieve related Rewritings from storage.
*
* This method is protected by default in order to keep the public
* api reasonable. You can provide public methods for those you
* actually need in Content.
*
* @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|ChildRewriting[] List of ChildRewriting objects
*/
public function getRewritingsJoinCategory($criteria = null, $con = null, $joinBehavior = Criteria::LEFT_JOIN)
{
$query = ChildRewritingQuery::create(null, $criteria);
$query->joinWith('Category', $joinBehavior);
return $this->getRewritings($query, $con);
}
/**
* If this collection has already been initialized with
* an identical criteria, it returns the collection.
* Otherwise if this Content is new, it will return
* an empty collection; or if this Content has previously
* been saved, it will retrieve related Rewritings from storage.
*
* This method is protected by default in order to keep the public
* api reasonable. You can provide public methods for those you
* actually need in Content.
*
* @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|ChildRewriting[] List of ChildRewriting objects
*/
public function getRewritingsJoinFolder($criteria = null, $con = null, $joinBehavior = Criteria::LEFT_JOIN)
{
$query = ChildRewritingQuery::create(null, $criteria);
$query->joinWith('Folder', $joinBehavior);
return $this->getRewritings($query, $con);
}
/**
* Clears out the collContentFolders collection
*
@@ -3940,11 +3602,6 @@ abstract class Content implements ActiveRecordInterface
public function clearAllReferences($deep = false)
{
if ($deep) {
if ($this->collRewritings) {
foreach ($this->collRewritings as $o) {
$o->clearAllReferences($deep);
}
}
if ($this->collContentFolders) {
foreach ($this->collContentFolders as $o) {
$o->clearAllReferences($deep);
@@ -3991,10 +3648,6 @@ abstract class Content implements ActiveRecordInterface
$this->currentLocale = 'en_EN';
$this->currentTranslations = null;
if ($this->collRewritings instanceof Collection) {
$this->collRewritings->clearIterator();
}
$this->collRewritings = null;
if ($this->collContentFolders instanceof Collection) {
$this->collContentFolders->clearIterator();
}

77
core/lib/Thelia/Model/Base/ContentQuery.php
View File

@@ -44,10 +44,6 @@ use Thelia\Model\Map\ContentTableMap;
* @method ChildContentQuery rightJoin($relation) Adds a RIGHT JOIN clause to the query
* @method ChildContentQuery innerJoin($relation) Adds a INNER JOIN clause to the query
*
* @method ChildContentQuery leftJoinRewriting($relationAlias = null) Adds a LEFT JOIN clause to the query using the Rewriting relation
* @method ChildContentQuery rightJoinRewriting($relationAlias = null) Adds a RIGHT JOIN clause to the query using the Rewriting relation
* @method ChildContentQuery innerJoinRewriting($relationAlias = null) Adds a INNER JOIN clause to the query using the Rewriting relation
*
* @method ChildContentQuery leftJoinContentFolder($relationAlias = null) Adds a LEFT JOIN clause to the query using the ContentFolder relation
* @method ChildContentQuery rightJoinContentFolder($relationAlias = null) Adds a RIGHT JOIN clause to the query using the ContentFolder relation
* @method ChildContentQuery innerJoinContentFolder($relationAlias = null) Adds a INNER JOIN clause to the query using the ContentFolder relation
@@ -602,79 +598,6 @@ abstract class ContentQuery extends ModelCriteria
return $this->addUsingAlias(ContentTableMap::VERSION_CREATED_BY, $versionCreatedBy, $comparison);
}
/**
* Filter the query by a related \Thelia\Model\Rewriting object
*
* @param \Thelia\Model\Rewriting|ObjectCollection $rewriting the related object to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return ChildContentQuery The current query, for fluid interface
*/
public function filterByRewriting($rewriting, $comparison = null)
{
if ($rewriting instanceof \Thelia\Model\Rewriting) {
return $this
->addUsingAlias(ContentTableMap::ID, $rewriting->getContentId(), $comparison);
} elseif ($rewriting instanceof ObjectCollection) {
return $this
->useRewritingQuery()
->filterByPrimaryKeys($rewriting->getPrimaryKeys())
->endUse();
} else {
throw new PropelException('filterByRewriting() only accepts arguments of type \Thelia\Model\Rewriting or Collection');
}
}
/**
* Adds a JOIN clause to the query using the Rewriting relation
*
* @param string $relationAlias optional alias for the relation
* @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
*
* @return ChildContentQuery The current query, for fluid interface
*/
public function joinRewriting($relationAlias = null, $joinType = Criteria::LEFT_JOIN)
{
$tableMap = $this->getTableMap();
$relationMap = $tableMap->getRelation('Rewriting');
// 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, 'Rewriting');
}
return $this;
}
/**
* Use the Rewriting relation Rewriting 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\RewritingQuery A secondary query class using the current class as primary query
*/
public function useRewritingQuery($relationAlias = null, $joinType = Criteria::LEFT_JOIN)
{
return $this
->joinRewriting($relationAlias, $joinType)
->useQuery($relationAlias ? $relationAlias : 'Rewriting', '\Thelia\Model\RewritingQuery');
}
/**
* Filter the query by a related \Thelia\Model\ContentFolder object
*

347
core/lib/Thelia/Model/Base/Folder.php
View File

@@ -31,8 +31,6 @@ use Thelia\Model\FolderImageQuery as ChildFolderImageQuery;
use Thelia\Model\FolderQuery as ChildFolderQuery;
use Thelia\Model\FolderVersion as ChildFolderVersion;
use Thelia\Model\FolderVersionQuery as ChildFolderVersionQuery;
use Thelia\Model\Rewriting as ChildRewriting;
use Thelia\Model\RewritingQuery as ChildRewritingQuery;
use Thelia\Model\Map\FolderTableMap;
use Thelia\Model\Map\FolderVersionTableMap;
@@ -125,12 +123,6 @@ abstract class Folder implements ActiveRecordInterface
*/
protected $version_created_by;
/**
* @var ObjectCollection|ChildRewriting[] Collection to store aggregation of ChildRewriting objects.
*/
protected $collRewritings;
protected $collRewritingsPartial;
/**
* @var ObjectCollection|ChildContentFolder[] Collection to store aggregation of ChildContentFolder objects.
*/
@@ -202,12 +194,6 @@ abstract class Folder implements ActiveRecordInterface
*/
protected $contentsScheduledForDeletion = null;
/**
* An array of objects scheduled for deletion.
* @var ObjectCollection
*/
protected $rewritingsScheduledForDeletion = null;
/**
* An array of objects scheduled for deletion.
* @var ObjectCollection
@@ -965,8 +951,6 @@ abstract class Folder implements ActiveRecordInterface
if ($deep) { // also de-associate any related objects?
$this->collRewritings = null;
$this->collContentFolders = null;
$this->collFolderImages = null;
@@ -1150,23 +1134,6 @@ abstract class Folder implements ActiveRecordInterface
}
}
if ($this->rewritingsScheduledForDeletion !== null) {
if (!$this->rewritingsScheduledForDeletion->isEmpty()) {
\Thelia\Model\RewritingQuery::create()
->filterByPrimaryKeys($this->rewritingsScheduledForDeletion->getPrimaryKeys(false))
->delete($con);
$this->rewritingsScheduledForDeletion = null;
}
}
if ($this->collRewritings !== null) {
foreach ($this->collRewritings as $referrerFK) {
if (!$referrerFK->isDeleted() && ($referrerFK->isNew() || $referrerFK->isModified())) {
$affectedRows += $referrerFK->save($con);
}
}
}
if ($this->contentFoldersScheduledForDeletion !== null) {
if (!$this->contentFoldersScheduledForDeletion->isEmpty()) {
\Thelia\Model\ContentFolderQuery::create()
@@ -1478,9 +1445,6 @@ abstract class Folder implements ActiveRecordInterface
}
if ($includeForeignObjects) {
if (null !== $this->collRewritings) {
$result['Rewritings'] = $this->collRewritings->toArray(null, true, $keyType, $includeLazyLoadColumns, $alreadyDumpedObjects);
}
if (null !== $this->collContentFolders) {
$result['ContentFolders'] = $this->collContentFolders->toArray(null, true, $keyType, $includeLazyLoadColumns, $alreadyDumpedObjects);
}
@@ -1687,12 +1651,6 @@ abstract class Folder implements ActiveRecordInterface
// the getter/setter methods for fkey referrer objects.
$copyObj->setNew(false);
foreach ($this->getRewritings() as $relObj) {
if ($relObj !== $this) { // ensure that we don't try to copy a reference to ourselves
$copyObj->addRewriting($relObj->copy($deepCopy));
}
}
foreach ($this->getContentFolders() as $relObj) {
if ($relObj !== $this) { // ensure that we don't try to copy a reference to ourselves
$copyObj->addContentFolder($relObj->copy($deepCopy));
@@ -1764,9 +1722,6 @@ abstract class Folder implements ActiveRecordInterface
*/
public function initRelation($relationName)
{
if ('Rewriting' == $relationName) {
return $this->initRewritings();
}
if ('ContentFolder' == $relationName) {
return $this->initContentFolders();
}
@@ -1784,299 +1739,6 @@ abstract class Folder implements ActiveRecordInterface
}
}
/**
* Clears out the collRewritings 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 addRewritings()
*/
public function clearRewritings()
{
$this->collRewritings = null; // important to set this to NULL since that means it is uninitialized
}
/**
* Reset is the collRewritings collection loaded partially.
*/
public function resetPartialRewritings($v = true)
{
$this->collRewritingsPartial = $v;
}
/**
* Initializes the collRewritings collection.
*
* By default this just sets the collRewritings collection to an empty array (like clearcollRewritings());
* 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.
*
* @param boolean $overrideExisting If set to true, the method call initializes
* the collection even if it is not empty
*
* @return void
*/
public function initRewritings($overrideExisting = true)
{
if (null !== $this->collRewritings && !$overrideExisting) {
return;
}
$this->collRewritings = new ObjectCollection();
$this->collRewritings->setModel('\Thelia\Model\Rewriting');
}
/**
* Gets an array of ChildRewriting 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.
* Next time the same method is called without $criteria, the cached collection is returned.
* If this ChildFolder is new, it will return
* an empty collection or the current collection; the criteria is ignored on a new object.
*
* @param Criteria $criteria optional Criteria object to narrow the query
* @param ConnectionInterface $con optional connection object
* @return Collection|ChildRewriting[] List of ChildRewriting objects
* @throws PropelException
*/
public function getRewritings($criteria = null, ConnectionInterface $con = null)
{
$partial = $this->collRewritingsPartial && !$this->isNew();
if (null === $this->collRewritings || null !== $criteria || $partial) {
if ($this->isNew() && null === $this->collRewritings) {
// return empty collection
$this->initRewritings();
} else {
$collRewritings = ChildRewritingQuery::create(null, $criteria)
->filterByFolder($this)
->find($con);
if (null !== $criteria) {
if (false !== $this->collRewritingsPartial && count($collRewritings)) {
$this->initRewritings(false);
foreach ($collRewritings as $obj) {
if (false == $this->collRewritings->contains($obj)) {
$this->collRewritings->append($obj);
}
}
$this->collRewritingsPartial = true;
}
$collRewritings->getInternalIterator()->rewind();
return $collRewritings;
}
if ($partial && $this->collRewritings) {
foreach ($this->collRewritings as $obj) {
if ($obj->isNew()) {
$collRewritings[] = $obj;
}
}
}
$this->collRewritings = $collRewritings;
$this->collRewritingsPartial = false;
}
}
return $this->collRewritings;
}
/**
* Sets a collection of Rewriting 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 $rewritings A Propel collection.
* @param ConnectionInterface $con Optional connection object
* @return ChildFolder The current object (for fluent API support)
*/
public function setRewritings(Collection $rewritings, ConnectionInterface $con = null)
{
$rewritingsToDelete = $this->getRewritings(new Criteria(), $con)->diff($rewritings);
$this->rewritingsScheduledForDeletion = $rewritingsToDelete;
foreach ($rewritingsToDelete as $rewritingRemoved) {
$rewritingRemoved->setFolder(null);
}
$this->collRewritings = null;
foreach ($rewritings as $rewriting) {
$this->addRewriting($rewriting);
}
$this->collRewritings = $rewritings;
$this->collRewritingsPartial = false;
return $this;
}
/**
* Returns the number of related Rewriting objects.
*
* @param Criteria $criteria
* @param boolean $distinct
* @param ConnectionInterface $con
* @return int Count of related Rewriting objects.
* @throws PropelException
*/
public function countRewritings(Criteria $criteria = null, $distinct = false, ConnectionInterface $con = null)
{
$partial = $this->collRewritingsPartial && !$this->isNew();
if (null === $this->collRewritings || null !== $criteria || $partial) {
if ($this->isNew() && null === $this->collRewritings) {
return 0;
}
if ($partial && !$criteria) {
return count($this->getRewritings());
}
$query = ChildRewritingQuery::create(null, $criteria);
if ($distinct) {
$query->distinct();
}
return $query
->filterByFolder($this)
->count($con);
}
return count($this->collRewritings);
}
/**
* Method called to associate a ChildRewriting object to this object
* through the ChildRewriting foreign key attribute.
*
* @param ChildRewriting $l ChildRewriting
* @return \Thelia\Model\Folder The current object (for fluent API support)
*/
public function addRewriting(ChildRewriting $l)
{
if ($this->collRewritings === null) {
$this->initRewritings();
$this->collRewritingsPartial = true;
}
if (!in_array($l, $this->collRewritings->getArrayCopy(), true)) { // only add it if the **same** object is not already associated
$this->doAddRewriting($l);
}
return $this;
}
/**
* @param Rewriting $rewriting The rewriting object to add.
*/
protected function doAddRewriting($rewriting)
{
$this->collRewritings[]= $rewriting;
$rewriting->setFolder($this);
}
/**
* @param Rewriting $rewriting The rewriting object to remove.
* @return ChildFolder The current object (for fluent API support)
*/
public function removeRewriting($rewriting)
{
if ($this->getRewritings()->contains($rewriting)) {
$this->collRewritings->remove($this->collRewritings->search($rewriting));
if (null === $this->rewritingsScheduledForDeletion) {
$this->rewritingsScheduledForDeletion = clone $this->collRewritings;
$this->rewritingsScheduledForDeletion->clear();
}
$this->rewritingsScheduledForDeletion[]= $rewriting;
$rewriting->setFolder(null);
}
return $this;
}
/**
* If this collection has already been initialized with
* an identical criteria, it returns the collection.
* Otherwise if this Folder is new, it will return
* an empty collection; or if this Folder has previously
* been saved, it will retrieve related Rewritings from storage.
*
* This method is protected by default in order to keep the public
* api reasonable. You can provide public methods for those you
* actually need in Folder.
*
* @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|ChildRewriting[] List of ChildRewriting objects
*/
public function getRewritingsJoinProduct($criteria = null, $con = null, $joinBehavior = Criteria::LEFT_JOIN)
{
$query = ChildRewritingQuery::create(null, $criteria);
$query->joinWith('Product', $joinBehavior);
return $this->getRewritings($query, $con);
}
/**
* If this collection has already been initialized with
* an identical criteria, it returns the collection.
* Otherwise if this Folder is new, it will return
* an empty collection; or if this Folder has previously
* been saved, it will retrieve related Rewritings from storage.
*
* This method is protected by default in order to keep the public
* api reasonable. You can provide public methods for those you
* actually need in Folder.
*
* @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|ChildRewriting[] List of ChildRewriting objects
*/
public function getRewritingsJoinCategory($criteria = null, $con = null, $joinBehavior = Criteria::LEFT_JOIN)
{
$query = ChildRewritingQuery::create(null, $criteria);
$query->joinWith('Category', $joinBehavior);
return $this->getRewritings($query, $con);
}
/**
* If this collection has already been initialized with
* an identical criteria, it returns the collection.
* Otherwise if this Folder is new, it will return
* an empty collection; or if this Folder has previously
* been saved, it will retrieve related Rewritings from storage.
*
* This method is protected by default in order to keep the public
* api reasonable. You can provide public methods for those you
* actually need in Folder.
*
* @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|ChildRewriting[] List of ChildRewriting objects
*/
public function getRewritingsJoinContent($criteria = null, $con = null, $joinBehavior = Criteria::LEFT_JOIN)
{
$query = ChildRewritingQuery::create(null, $criteria);
$query->joinWith('Content', $joinBehavior);
return $this->getRewritings($query, $con);
}
/**
* Clears out the collContentFolders collection
*
@@ -3422,11 +3084,6 @@ abstract class Folder implements ActiveRecordInterface
public function clearAllReferences($deep = false)
{
if ($deep) {
if ($this->collRewritings) {
foreach ($this->collRewritings as $o) {
$o->clearAllReferences($deep);
}
}
if ($this->collContentFolders) {
foreach ($this->collContentFolders as $o) {
$o->clearAllReferences($deep);
@@ -3463,10 +3120,6 @@ abstract class Folder implements ActiveRecordInterface
$this->currentLocale = 'en_EN';
$this->currentTranslations = null;
if ($this->collRewritings instanceof Collection) {
$this->collRewritings->clearIterator();
}
$this->collRewritings = null;
if ($this->collContentFolders instanceof Collection) {
$this->collContentFolders->clearIterator();
}

77
core/lib/Thelia/Model/Base/FolderQuery.php
View File

@@ -46,10 +46,6 @@ use Thelia\Model\Map\FolderTableMap;
* @method ChildFolderQuery rightJoin($relation) Adds a RIGHT JOIN clause to the query
* @method ChildFolderQuery innerJoin($relation) Adds a INNER JOIN clause to the query
*
* @method ChildFolderQuery leftJoinRewriting($relationAlias = null) Adds a LEFT JOIN clause to the query using the Rewriting relation
* @method ChildFolderQuery rightJoinRewriting($relationAlias = null) Adds a RIGHT JOIN clause to the query using the Rewriting relation
* @method ChildFolderQuery innerJoinRewriting($relationAlias = null) Adds a INNER JOIN clause to the query using the Rewriting relation
*
* @method ChildFolderQuery leftJoinContentFolder($relationAlias = null) Adds a LEFT JOIN clause to the query using the ContentFolder relation
* @method ChildFolderQuery rightJoinContentFolder($relationAlias = null) Adds a RIGHT JOIN clause to the query using the ContentFolder relation
* @method ChildFolderQuery innerJoinContentFolder($relationAlias = null) Adds a INNER JOIN clause to the query using the ContentFolder relation
@@ -639,79 +635,6 @@ abstract class FolderQuery extends ModelCriteria
return $this->addUsingAlias(FolderTableMap::VERSION_CREATED_BY, $versionCreatedBy, $comparison);
}
/**
* Filter the query by a related \Thelia\Model\Rewriting object
*
* @param \Thelia\Model\Rewriting|ObjectCollection $rewriting the related object to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return ChildFolderQuery The current query, for fluid interface
*/
public function filterByRewriting($rewriting, $comparison = null)
{
if ($rewriting instanceof \Thelia\Model\Rewriting) {
return $this
->addUsingAlias(FolderTableMap::ID, $rewriting->getFolderId(), $comparison);
} elseif ($rewriting instanceof ObjectCollection) {
return $this
->useRewritingQuery()
->filterByPrimaryKeys($rewriting->getPrimaryKeys())
->endUse();
} else {
throw new PropelException('filterByRewriting() only accepts arguments of type \Thelia\Model\Rewriting or Collection');
}
}
/**
* Adds a JOIN clause to the query using the Rewriting relation
*
* @param string $relationAlias optional alias for the relation
* @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
*
* @return ChildFolderQuery The current query, for fluid interface
*/
public function joinRewriting($relationAlias = null, $joinType = Criteria::LEFT_JOIN)
{
$tableMap = $this->getTableMap();
$relationMap = $tableMap->getRelation('Rewriting');
// 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, 'Rewriting');
}
return $this;
}
/**
* Use the Rewriting relation Rewriting 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\RewritingQuery A secondary query class using the current class as primary query
*/
public function useRewritingQuery($relationAlias = null, $joinType = Criteria::LEFT_JOIN)
{
return $this
->joinRewriting($relationAlias, $joinType)
->useQuery($relationAlias ? $relationAlias : 'Rewriting', '\Thelia\Model\RewritingQuery');
}
/**
* Filter the query by a related \Thelia\Model\ContentFolder object
*

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

@@ -41,8 +41,6 @@ use Thelia\Model\ProductSaleElements as ChildProductSaleElements;
use Thelia\Model\ProductSaleElementsQuery as ChildProductSaleElementsQuery;
use Thelia\Model\ProductVersion as ChildProductVersion;
use Thelia\Model\ProductVersionQuery as ChildProductVersionQuery;
use Thelia\Model\Rewriting as ChildRewriting;
use Thelia\Model\RewritingQuery as ChildRewritingQuery;
use Thelia\Model\TaxRule as ChildTaxRule;
use Thelia\Model\TaxRuleQuery as ChildTaxRuleQuery;
use Thelia\Model\Map\ProductTableMap;
@@ -191,12 +189,6 @@ abstract class Product implements ActiveRecordInterface
protected $collAccessoriesRelatedByAccessory;
protected $collAccessoriesRelatedByAccessoryPartial;
/**
* @var ObjectCollection|ChildRewriting[] Collection to store aggregation of ChildRewriting objects.
*/
protected $collRewritings;
protected $collRewritingsPartial;
/**
* @var ObjectCollection|ChildCartItem[] Collection to store aggregation of ChildCartItem objects.
*/
@@ -326,12 +318,6 @@ abstract class Product implements ActiveRecordInterface
*/
protected $accessoriesRelatedByAccessoryScheduledForDeletion = null;
/**
* An array of objects scheduled for deletion.
* @var ObjectCollection
*/
protected $rewritingsScheduledForDeletion = null;
/**
* An array of objects scheduled for deletion.
* @var ObjectCollection
@@ -1145,8 +1131,6 @@ abstract class Product implements ActiveRecordInterface
$this->collAccessoriesRelatedByAccessory = null;
$this->collRewritings = null;
$this->collCartItems = null;
$this->collProductAssociatedContents = null;
@@ -1515,23 +1499,6 @@ abstract class Product implements ActiveRecordInterface
}
}
if ($this->rewritingsScheduledForDeletion !== null) {
if (!$this->rewritingsScheduledForDeletion->isEmpty()) {
\Thelia\Model\RewritingQuery::create()
->filterByPrimaryKeys($this->rewritingsScheduledForDeletion->getPrimaryKeys(false))
->delete($con);
$this->rewritingsScheduledForDeletion = null;
}
}
if ($this->collRewritings !== null) {
foreach ($this->collRewritings as $referrerFK) {
if (!$referrerFK->isDeleted() && ($referrerFK->isNew() || $referrerFK->isModified())) {
$affectedRows += $referrerFK->save($con);
}
}
}
if ($this->cartItemsScheduledForDeletion !== null) {
if (!$this->cartItemsScheduledForDeletion->isEmpty()) {
\Thelia\Model\CartItemQuery::create()
@@ -1860,9 +1827,6 @@ abstract class Product implements ActiveRecordInterface
if (null !== $this->collAccessoriesRelatedByAccessory) {
$result['AccessoriesRelatedByAccessory'] = $this->collAccessoriesRelatedByAccessory->toArray(null, true, $keyType, $includeLazyLoadColumns, $alreadyDumpedObjects);
}
if (null !== $this->collRewritings) {
$result['Rewritings'] = $this->collRewritings->toArray(null, true, $keyType, $includeLazyLoadColumns, $alreadyDumpedObjects);
}
if (null !== $this->collCartItems) {
$result['CartItems'] = $this->collCartItems->toArray(null, true, $keyType, $includeLazyLoadColumns, $alreadyDumpedObjects);
}
@@ -2114,12 +2078,6 @@ abstract class Product implements ActiveRecordInterface
}
}
foreach ($this->getRewritings() as $relObj) {
if ($relObj !== $this) { // ensure that we don't try to copy a reference to ourselves
$copyObj->addRewriting($relObj->copy($deepCopy));
}
}
foreach ($this->getCartItems() as $relObj) {
if ($relObj !== $this) { // ensure that we don't try to copy a reference to ourselves
$copyObj->addCartItem($relObj->copy($deepCopy));
@@ -2257,9 +2215,6 @@ abstract class Product implements ActiveRecordInterface
if ('AccessoryRelatedByAccessory' == $relationName) {
return $this->initAccessoriesRelatedByAccessory();
}
if ('Rewriting' == $relationName) {
return $this->initRewritings();
}
if ('CartItem' == $relationName) {
return $this->initCartItems();
}
@@ -3878,299 +3833,6 @@ abstract class Product implements ActiveRecordInterface
return $this;
}
/**
* Clears out the collRewritings 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 addRewritings()
*/
public function clearRewritings()
{
$this->collRewritings = null; // important to set this to NULL since that means it is uninitialized
}
/**
* Reset is the collRewritings collection loaded partially.
*/
public function resetPartialRewritings($v = true)
{
$this->collRewritingsPartial = $v;
}
/**
* Initializes the collRewritings collection.
*
* By default this just sets the collRewritings collection to an empty array (like clearcollRewritings());
* 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.
*
* @param boolean $overrideExisting If set to true, the method call initializes
* the collection even if it is not empty
*
* @return void
*/
public function initRewritings($overrideExisting = true)
{
if (null !== $this->collRewritings && !$overrideExisting) {
return;
}
$this->collRewritings = new ObjectCollection();
$this->collRewritings->setModel('\Thelia\Model\Rewriting');
}
/**
* Gets an array of ChildRewriting 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.
* Next time the same method is called without $criteria, the cached collection is returned.
* If this ChildProduct is new, it will return
* an empty collection or the current collection; the criteria is ignored on a new object.
*
* @param Criteria $criteria optional Criteria object to narrow the query
* @param ConnectionInterface $con optional connection object
* @return Collection|ChildRewriting[] List of ChildRewriting objects
* @throws PropelException
*/
public function getRewritings($criteria = null, ConnectionInterface $con = null)
{
$partial = $this->collRewritingsPartial && !$this->isNew();
if (null === $this->collRewritings || null !== $criteria || $partial) {
if ($this->isNew() && null === $this->collRewritings) {
// return empty collection
$this->initRewritings();
} else {
$collRewritings = ChildRewritingQuery::create(null, $criteria)
->filterByProduct($this)
->find($con);
if (null !== $criteria) {
if (false !== $this->collRewritingsPartial && count($collRewritings)) {
$this->initRewritings(false);
foreach ($collRewritings as $obj) {
if (false == $this->collRewritings->contains($obj)) {
$this->collRewritings->append($obj);
}
}
$this->collRewritingsPartial = true;
}
$collRewritings->getInternalIterator()->rewind();
return $collRewritings;
}
if ($partial && $this->collRewritings) {
foreach ($this->collRewritings as $obj) {
if ($obj->isNew()) {
$collRewritings[] = $obj;
}
}
}
$this->collRewritings = $collRewritings;
$this->collRewritingsPartial = false;
}
}
return $this->collRewritings;
}
/**
* Sets a collection of Rewriting 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 $rewritings A Propel collection.
* @param ConnectionInterface $con Optional connection object
* @return ChildProduct The current object (for fluent API support)
*/
public function setRewritings(Collection $rewritings, ConnectionInterface $con = null)
{
$rewritingsToDelete = $this->getRewritings(new Criteria(), $con)->diff($rewritings);
$this->rewritingsScheduledForDeletion = $rewritingsToDelete;
foreach ($rewritingsToDelete as $rewritingRemoved) {
$rewritingRemoved->setProduct(null);
}
$this->collRewritings = null;
foreach ($rewritings as $rewriting) {
$this->addRewriting($rewriting);
}
$this->collRewritings = $rewritings;
$this->collRewritingsPartial = false;
return $this;
}
/**
* Returns the number of related Rewriting objects.
*
* @param Criteria $criteria
* @param boolean $distinct
* @param ConnectionInterface $con
* @return int Count of related Rewriting objects.
* @throws PropelException
*/
public function countRewritings(Criteria $criteria = null, $distinct = false, ConnectionInterface $con = null)
{
$partial = $this->collRewritingsPartial && !$this->isNew();
if (null === $this->collRewritings || null !== $criteria || $partial) {
if ($this->isNew() && null === $this->collRewritings) {
return 0;
}
if ($partial && !$criteria) {
return count($this->getRewritings());
}
$query = ChildRewritingQuery::create(null, $criteria);
if ($distinct) {
$query->distinct();
}
return $query
->filterByProduct($this)
->count($con);
}
return count($this->collRewritings);
}
/**
* Method called to associate a ChildRewriting object to this object
* through the ChildRewriting foreign key attribute.
*
* @param ChildRewriting $l ChildRewriting
* @return \Thelia\Model\Product The current object (for fluent API support)
*/
public function addRewriting(ChildRewriting $l)
{
if ($this->collRewritings === null) {
$this->initRewritings();
$this->collRewritingsPartial = true;
}
if (!in_array($l, $this->collRewritings->getArrayCopy(), true)) { // only add it if the **same** object is not already associated
$this->doAddRewriting($l);
}
return $this;
}
/**
* @param Rewriting $rewriting The rewriting object to add.
*/
protected function doAddRewriting($rewriting)
{
$this->collRewritings[]= $rewriting;
$rewriting->setProduct($this);
}
/**
* @param Rewriting $rewriting The rewriting object to remove.
* @return ChildProduct The current object (for fluent API support)
*/
public function removeRewriting($rewriting)
{
if ($this->getRewritings()->contains($rewriting)) {
$this->collRewritings->remove($this->collRewritings->search($rewriting));
if (null === $this->rewritingsScheduledForDeletion) {
$this->rewritingsScheduledForDeletion = clone $this->collRewritings;
$this->rewritingsScheduledForDeletion->clear();
}
$this->rewritingsScheduledForDeletion[]= $rewriting;
$rewriting->setProduct(null);
}
return $this;
}
/**
* If this collection has already been initialized with
* 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 Rewritings from storage.
*
* This method is protected by default in order to keep the public
* api reasonable. You can provide public methods for those you
* actually need in Product.
*
* @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|ChildRewriting[] List of ChildRewriting objects
*/
public function getRewritingsJoinCategory($criteria = null, $con = null, $joinBehavior = Criteria::LEFT_JOIN)
{
$query = ChildRewritingQuery::create(null, $criteria);
$query->joinWith('Category', $joinBehavior);
return $this->getRewritings($query, $con);
}
/**
* If this collection has already been initialized with
* 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 Rewritings from storage.
*
* This method is protected by default in order to keep the public
* api reasonable. You can provide public methods for those you
* actually need in Product.
*
* @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|ChildRewriting[] List of ChildRewriting objects
*/
public function getRewritingsJoinFolder($criteria = null, $con = null, $joinBehavior = Criteria::LEFT_JOIN)
{
$query = ChildRewritingQuery::create(null, $criteria);
$query->joinWith('Folder', $joinBehavior);
return $this->getRewritings($query, $con);
}
/**
* If this collection has already been initialized with
* 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 Rewritings from storage.
*
* This method is protected by default in order to keep the public
* api reasonable. You can provide public methods for those you
* actually need in Product.
*
* @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|ChildRewriting[] List of ChildRewriting objects
*/
public function getRewritingsJoinContent($criteria = null, $con = null, $joinBehavior = Criteria::LEFT_JOIN)
{
$query = ChildRewritingQuery::create(null, $criteria);
$query->joinWith('Content', $joinBehavior);
return $this->getRewritings($query, $con);
}
/**
* Clears out the collCartItems collection
*
@@ -5747,11 +5409,6 @@ abstract class Product implements ActiveRecordInterface
$o->clearAllReferences($deep);
}
}
if ($this->collRewritings) {
foreach ($this->collRewritings as $o) {
$o->clearAllReferences($deep);
}
}
if ($this->collCartItems) {
foreach ($this->collCartItems as $o) {
$o->clearAllReferences($deep);
@@ -5821,10 +5478,6 @@ abstract class Product implements ActiveRecordInterface
$this->collAccessoriesRelatedByAccessory->clearIterator();
}
$this->collAccessoriesRelatedByAccessory = null;
if ($this->collRewritings instanceof Collection) {
$this->collRewritings->clearIterator();
}
$this->collRewritings = null;
if ($this->collCartItems instanceof Collection) {
$this->collCartItems->clearIterator();
}

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

@@ -80,10 +80,6 @@ use Thelia\Model\Map\ProductTableMap;
* @method ChildProductQuery rightJoinAccessoryRelatedByAccessory($relationAlias = null) Adds a RIGHT JOIN clause to the query using the AccessoryRelatedByAccessory relation
* @method ChildProductQuery innerJoinAccessoryRelatedByAccessory($relationAlias = null) Adds a INNER JOIN clause to the query using the AccessoryRelatedByAccessory relation
*
* @method ChildProductQuery leftJoinRewriting($relationAlias = null) Adds a LEFT JOIN clause to the query using the Rewriting relation
* @method ChildProductQuery rightJoinRewriting($relationAlias = null) Adds a RIGHT JOIN clause to the query using the Rewriting relation
* @method ChildProductQuery innerJoinRewriting($relationAlias = null) Adds a INNER JOIN clause to the query using the Rewriting relation
*
* @method ChildProductQuery leftJoinCartItem($relationAlias = null) Adds a LEFT JOIN clause to the query using the CartItem relation
* @method ChildProductQuery rightJoinCartItem($relationAlias = null) Adds a RIGHT JOIN clause to the query using the CartItem relation
* @method ChildProductQuery innerJoinCartItem($relationAlias = null) Adds a INNER JOIN clause to the query using the CartItem relation
@@ -1288,79 +1284,6 @@ abstract class ProductQuery extends ModelCriteria
->useQuery($relationAlias ? $relationAlias : 'AccessoryRelatedByAccessory', '\Thelia\Model\AccessoryQuery');
}
/**
* Filter the query by a related \Thelia\Model\Rewriting object
*
* @param \Thelia\Model\Rewriting|ObjectCollection $rewriting 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 filterByRewriting($rewriting, $comparison = null)
{
if ($rewriting instanceof \Thelia\Model\Rewriting) {
return $this
->addUsingAlias(ProductTableMap::ID, $rewriting->getProductId(), $comparison);
} elseif ($rewriting instanceof ObjectCollection) {
return $this
->useRewritingQuery()
->filterByPrimaryKeys($rewriting->getPrimaryKeys())
->endUse();
} else {
throw new PropelException('filterByRewriting() only accepts arguments of type \Thelia\Model\Rewriting or Collection');
}
}
/**
* Adds a JOIN clause to the query using the Rewriting 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 joinRewriting($relationAlias = null, $joinType = Criteria::LEFT_JOIN)
{
$tableMap = $this->getTableMap();
$relationMap = $tableMap->getRelation('Rewriting');
// 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, 'Rewriting');
}
return $this;
}
/**
* Use the Rewriting relation Rewriting 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\RewritingQuery A secondary query class using the current class as primary query
*/
public function useRewritingQuery($relationAlias = null, $joinType = Criteria::LEFT_JOIN)
{
return $this
->joinRewriting($relationAlias, $joinType)
->useQuery($relationAlias ? $relationAlias : 'Rewriting', '\Thelia\Model\RewritingQuery');
}
/**
* Filter the query by a related \Thelia\Model\CartItem object
*

1417
core/lib/Thelia/Model/Base/RewritingArgument.php Normal file
View File

File diff suppressed because it is too large Load Diff

673
core/lib/Thelia/Model/Base/RewritingArgumentQuery.php Normal file
View File

@@ -0,0 +1,673 @@
<?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\RewritingArgument as ChildRewritingArgument;
use Thelia\Model\RewritingArgumentQuery as ChildRewritingArgumentQuery;
use Thelia\Model\Map\RewritingArgumentTableMap;
/**
* Base class that represents a query for the 'rewriting_argument' table.
*
*
*
* @method ChildRewritingArgumentQuery orderByRewritingUrlId($order = Criteria::ASC) Order by the rewriting_url_id column
* @method ChildRewritingArgumentQuery orderByParameter($order = Criteria::ASC) Order by the parameter column
* @method ChildRewritingArgumentQuery orderByValue($order = Criteria::ASC) Order by the value column
* @method ChildRewritingArgumentQuery orderByCreatedAt($order = Criteria::ASC) Order by the created_at column
* @method ChildRewritingArgumentQuery orderByUpdatedAt($order = Criteria::ASC) Order by the updated_at column
*
* @method ChildRewritingArgumentQuery groupByRewritingUrlId() Group by the rewriting_url_id column
* @method ChildRewritingArgumentQuery groupByParameter() Group by the parameter column
* @method ChildRewritingArgumentQuery groupByValue() Group by the value column
* @method ChildRewritingArgumentQuery groupByCreatedAt() Group by the created_at column
* @method ChildRewritingArgumentQuery groupByUpdatedAt() Group by the updated_at column
*
* @method ChildRewritingArgumentQuery leftJoin($relation) Adds a LEFT JOIN clause to the query
* @method ChildRewritingArgumentQuery rightJoin($relation) Adds a RIGHT JOIN clause to the query
* @method ChildRewritingArgumentQuery innerJoin($relation) Adds a INNER JOIN clause to the query
*
* @method ChildRewritingArgumentQuery leftJoinRewritingUrl($relationAlias = null) Adds a LEFT JOIN clause to the query using the RewritingUrl relation
* @method ChildRewritingArgumentQuery rightJoinRewritingUrl($relationAlias = null) Adds a RIGHT JOIN clause to the query using the RewritingUrl relation
* @method ChildRewritingArgumentQuery innerJoinRewritingUrl($relationAlias = null) Adds a INNER JOIN clause to the query using the RewritingUrl relation
*
* @method ChildRewritingArgument findOne(ConnectionInterface $con = null) Return the first ChildRewritingArgument matching the query
* @method ChildRewritingArgument findOneOrCreate(ConnectionInterface $con = null) Return the first ChildRewritingArgument matching the query, or a new ChildRewritingArgument object populated from the query conditions when no match is found
*
* @method ChildRewritingArgument findOneByRewritingUrlId(int $rewriting_url_id) Return the first ChildRewritingArgument filtered by the rewriting_url_id column
* @method ChildRewritingArgument findOneByParameter(string $parameter) Return the first ChildRewritingArgument filtered by the parameter column
* @method ChildRewritingArgument findOneByValue(string $value) Return the first ChildRewritingArgument filtered by the value column
* @method ChildRewritingArgument findOneByCreatedAt(string $created_at) Return the first ChildRewritingArgument filtered by the created_at column
* @method ChildRewritingArgument findOneByUpdatedAt(string $updated_at) Return the first ChildRewritingArgument filtered by the updated_at column
*
* @method array findByRewritingUrlId(int $rewriting_url_id) Return ChildRewritingArgument objects filtered by the rewriting_url_id column
* @method array findByParameter(string $parameter) Return ChildRewritingArgument objects filtered by the parameter column
* @method array findByValue(string $value) Return ChildRewritingArgument objects filtered by the value column
* @method array findByCreatedAt(string $created_at) Return ChildRewritingArgument objects filtered by the created_at column
* @method array findByUpdatedAt(string $updated_at) Return ChildRewritingArgument objects filtered by the updated_at column
*
*/
abstract class RewritingArgumentQuery extends ModelCriteria
{
/**
* Initializes internal state of \Thelia\Model\Base\RewritingArgumentQuery 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\\RewritingArgument', $modelAlias = null)
{
parent::__construct($dbName, $modelName, $modelAlias);
}
/**
* Returns a new ChildRewritingArgumentQuery object.
*
* @param string $modelAlias The alias of a model in the query
* @param Criteria $criteria Optional Criteria to build the query from
*
* @return ChildRewritingArgumentQuery
*/
public static function create($modelAlias = null, $criteria = null)
{
if ($criteria instanceof \Thelia\Model\RewritingArgumentQuery) {
return $criteria;
}
$query = new \Thelia\Model\RewritingArgumentQuery();
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(array(12, 34, 56), $con);
* </code>
*
* @param array[$rewriting_url_id, $parameter, $value] $key Primary key to use for the query
* @param ConnectionInterface $con an optional connection object
*
* @return ChildRewritingArgument|array|mixed the result, formatted by the current formatter
*/
public function findPk($key, $con = null)
{
if ($key === null) {
return null;
}
if ((null !== ($obj = RewritingArgumentTableMap::getInstanceFromPool(serialize(array((string) $key[0], (string) $key[1], (string) $key[2]))))) && !$this->formatter) {
// the object is already in the instance pool
return $obj;
}
if ($con === null) {
$con = Propel::getServiceContainer()->getReadConnection(RewritingArgumentTableMap::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 ChildRewritingArgument A model object, or null if the key is not found
*/
protected function findPkSimple($key, $con)
{
$sql = 'SELECT REWRITING_URL_ID, PARAMETER, VALUE, CREATED_AT, UPDATED_AT FROM rewriting_argument WHERE REWRITING_URL_ID = :p0 AND PARAMETER = :p1 AND VALUE = :p2';
try {
$stmt = $con->prepare($sql);
$stmt->bindValue(':p0', $key[0], PDO::PARAM_INT);
$stmt->bindValue(':p1', $key[1], PDO::PARAM_STR);
$stmt->bindValue(':p2', $key[2], PDO::PARAM_STR);
$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 ChildRewritingArgument();
$obj->hydrate($row);
RewritingArgumentTableMap::addInstanceToPool($obj, serialize(array((string) $key[0], (string) $key[1], (string) $key[2])));
}
$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 ChildRewritingArgument|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(array(12, 56), array(832, 123), array(123, 456)), $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 ChildRewritingArgumentQuery The current query, for fluid interface
*/
public function filterByPrimaryKey($key)
{
$this->addUsingAlias(RewritingArgumentTableMap::REWRITING_URL_ID, $key[0], Criteria::EQUAL);
$this->addUsingAlias(RewritingArgumentTableMap::PARAMETER, $key[1], Criteria::EQUAL);
$this->addUsingAlias(RewritingArgumentTableMap::VALUE, $key[2], Criteria::EQUAL);
return $this;
}
/**
* Filter the query by a list of primary keys
*
* @param array $keys The list of primary key to use for the query
*
* @return ChildRewritingArgumentQuery The current query, for fluid interface
*/
public function filterByPrimaryKeys($keys)
{
if (empty($keys)) {
return $this->add(null, '1<>1', Criteria::CUSTOM);
}
foreach ($keys as $key) {
$cton0 = $this->getNewCriterion(RewritingArgumentTableMap::REWRITING_URL_ID, $key[0], Criteria::EQUAL);
$cton1 = $this->getNewCriterion(RewritingArgumentTableMap::PARAMETER, $key[1], Criteria::EQUAL);
$cton0->addAnd($cton1);
$cton2 = $this->getNewCriterion(RewritingArgumentTableMap::VALUE, $key[2], Criteria::EQUAL);
$cton0->addAnd($cton2);
$this->addOr($cton0);
}
return $this;
}
/**
* Filter the query on the rewriting_url_id column
*
* Example usage:
* <code>
* $query->filterByRewritingUrlId(1234); // WHERE rewriting_url_id = 1234
* $query->filterByRewritingUrlId(array(12, 34)); // WHERE rewriting_url_id IN (12, 34)
* $query->filterByRewritingUrlId(array('min' => 12)); // WHERE rewriting_url_id > 12
* </code>
*
* @see filterByRewritingUrl()
*
* @param mixed $rewritingUrlId 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 ChildRewritingArgumentQuery The current query, for fluid interface
*/
public function filterByRewritingUrlId($rewritingUrlId = null, $comparison = null)
{
if (is_array($rewritingUrlId)) {
$useMinMax = false;
if (isset($rewritingUrlId['min'])) {
$this->addUsingAlias(RewritingArgumentTableMap::REWRITING_URL_ID, $rewritingUrlId['min'], Criteria::GREATER_EQUAL);
$useMinMax = true;
}
if (isset($rewritingUrlId['max'])) {
$this->addUsingAlias(RewritingArgumentTableMap::REWRITING_URL_ID, $rewritingUrlId['max'], Criteria::LESS_EQUAL);
$useMinMax = true;
}
if ($useMinMax) {
return $this;
}
if (null === $comparison) {
$comparison = Criteria::IN;
}
}
return $this->addUsingAlias(RewritingArgumentTableMap::REWRITING_URL_ID, $rewritingUrlId, $comparison);
}
/**
* Filter the query on the parameter column
*
* Example usage:
* <code>
* $query->filterByParameter('fooValue'); // WHERE parameter = 'fooValue'
* $query->filterByParameter('%fooValue%'); // WHERE parameter LIKE '%fooValue%'
* </code>
*
* @param string $parameter 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 ChildRewritingArgumentQuery The current query, for fluid interface
*/
public function filterByParameter($parameter = null, $comparison = null)
{
if (null === $comparison) {
if (is_array($parameter)) {
$comparison = Criteria::IN;
} elseif (preg_match('/[\%\*]/', $parameter)) {
$parameter = str_replace('*', '%', $parameter);
$comparison = Criteria::LIKE;
}
}
return $this->addUsingAlias(RewritingArgumentTableMap::PARAMETER, $parameter, $comparison);
}
/**
* Filter the query on the value column
*
* Example usage:
* <code>
* $query->filterByValue('fooValue'); // WHERE value = 'fooValue'
* $query->filterByValue('%fooValue%'); // WHERE value LIKE '%fooValue%'
* </code>
*
* @param string $value 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 ChildRewritingArgumentQuery The current query, for fluid interface
*/
public function filterByValue($value = null, $comparison = null)
{
if (null === $comparison) {
if (is_array($value)) {
$comparison = Criteria::IN;
} elseif (preg_match('/[\%\*]/', $value)) {
$value = str_replace('*', '%', $value);
$comparison = Criteria::LIKE;
}
}
return $this->addUsingAlias(RewritingArgumentTableMap::VALUE, $value, $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 ChildRewritingArgumentQuery 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(RewritingArgumentTableMap::CREATED_AT, $createdAt['min'], Criteria::GREATER_EQUAL);
$useMinMax = true;
}
if (isset($createdAt['max'])) {
$this->addUsingAlias(RewritingArgumentTableMap::CREATED_AT, $createdAt['max'], Criteria::LESS_EQUAL);
$useMinMax = true;
}
if ($useMinMax) {
return $this;
}
if (null === $comparison) {
$comparison = Criteria::IN;
}
}
return $this->addUsingAlias(RewritingArgumentTableMap::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 ChildRewritingArgumentQuery 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(RewritingArgumentTableMap::UPDATED_AT, $updatedAt['min'], Criteria::GREATER_EQUAL);
$useMinMax = true;
}
if (isset($updatedAt['max'])) {
$this->addUsingAlias(RewritingArgumentTableMap::UPDATED_AT, $updatedAt['max'], Criteria::LESS_EQUAL);
$useMinMax = true;
}
if ($useMinMax) {
return $this;
}
if (null === $comparison) {
$comparison = Criteria::IN;
}
}
return $this->addUsingAlias(RewritingArgumentTableMap::UPDATED_AT, $updatedAt, $comparison);
}
/**
* Filter the query by a related \Thelia\Model\RewritingUrl object
*
* @param \Thelia\Model\RewritingUrl|ObjectCollection $rewritingUrl The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return ChildRewritingArgumentQuery The current query, for fluid interface
*/
public function filterByRewritingUrl($rewritingUrl, $comparison = null)
{
if ($rewritingUrl instanceof \Thelia\Model\RewritingUrl) {
return $this
->addUsingAlias(RewritingArgumentTableMap::REWRITING_URL_ID, $rewritingUrl->getId(), $comparison);
} elseif ($rewritingUrl instanceof ObjectCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this
->addUsingAlias(RewritingArgumentTableMap::REWRITING_URL_ID, $rewritingUrl->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByRewritingUrl() only accepts arguments of type \Thelia\Model\RewritingUrl or Collection');
}
}
/**
* Adds a JOIN clause to the query using the RewritingUrl relation
*
* @param string $relationAlias optional alias for the relation
* @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
*
* @return ChildRewritingArgumentQuery The current query, for fluid interface
*/
public function joinRewritingUrl($relationAlias = null, $joinType = Criteria::INNER_JOIN)
{
$tableMap = $this->getTableMap();
$relationMap = $tableMap->getRelation('RewritingUrl');
// 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, 'RewritingUrl');
}
return $this;
}
/**
* Use the RewritingUrl relation RewritingUrl 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\RewritingUrlQuery A secondary query class using the current class as primary query
*/
public function useRewritingUrlQuery($relationAlias = null, $joinType = Criteria::INNER_JOIN)
{
return $this
->joinRewritingUrl($relationAlias, $joinType)
->useQuery($relationAlias ? $relationAlias : 'RewritingUrl', '\Thelia\Model\RewritingUrlQuery');
}
/**
* Exclude object from result
*
* @param ChildRewritingArgument $rewritingArgument Object to remove from the list of results
*
* @return ChildRewritingArgumentQuery The current query, for fluid interface
*/
public function prune($rewritingArgument = null)
{
if ($rewritingArgument) {
$this->addCond('pruneCond0', $this->getAliasedColName(RewritingArgumentTableMap::REWRITING_URL_ID), $rewritingArgument->getRewritingUrlId(), Criteria::NOT_EQUAL);
$this->addCond('pruneCond1', $this->getAliasedColName(RewritingArgumentTableMap::PARAMETER), $rewritingArgument->getParameter(), Criteria::NOT_EQUAL);
$this->addCond('pruneCond2', $this->getAliasedColName(RewritingArgumentTableMap::VALUE), $rewritingArgument->getValue(), Criteria::NOT_EQUAL);
$this->combine(array('pruneCond0', 'pruneCond1', 'pruneCond2'), Criteria::LOGICAL_OR);
}
return $this;
}
/**
* Deletes all rows from the rewriting_argument 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(RewritingArgumentTableMap::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).
RewritingArgumentTableMap::clearInstancePool();
RewritingArgumentTableMap::clearRelatedInstancePool();
$con->commit();
} catch (PropelException $e) {
$con->rollBack();
throw $e;
}
return $affectedRows;
}
/**
* Performs a DELETE on the database, given a ChildRewritingArgument or Criteria object OR a primary key value.
*
* @param mixed $values Criteria or ChildRewritingArgument 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(RewritingArgumentTableMap::DATABASE_NAME);
}
$criteria = $this;
// Set the correct dbName
$criteria->setDbName(RewritingArgumentTableMap::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();
RewritingArgumentTableMap::removeInstanceFromPool($criteria);
$affectedRows += ModelCriteria::delete($con);
RewritingArgumentTableMap::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 ChildRewritingArgumentQuery The current query, for fluid interface
*/
public function recentlyUpdated($nbDays = 7)
{
return $this->addUsingAlias(RewritingArgumentTableMap::UPDATED_AT, time() - $nbDays * 24 * 60 * 60, Criteria::GREATER_EQUAL);
}
/**
* Filter by the latest created
*
* @param int $nbDays Maximum age of in days
*
* @return ChildRewritingArgumentQuery The current query, for fluid interface
*/
public function recentlyCreated($nbDays = 7)
{
return $this->addUsingAlias(RewritingArgumentTableMap::CREATED_AT, time() - $nbDays * 24 * 60 * 60, Criteria::GREATER_EQUAL);
}
/**
* Order by update date desc
*
* @return ChildRewritingArgumentQuery The current query, for fluid interface
*/
public function lastUpdatedFirst()
{
return $this->addDescendingOrderByColumn(RewritingArgumentTableMap::UPDATED_AT);
}
/**
* Order by update date asc
*
* @return ChildRewritingArgumentQuery The current query, for fluid interface
*/
public function firstUpdatedFirst()
{
return $this->addAscendingOrderByColumn(RewritingArgumentTableMap::UPDATED_AT);
}
/**
* Order by create date desc
*
* @return ChildRewritingArgumentQuery The current query, for fluid interface
*/
public function lastCreatedFirst()
{
return $this->addDescendingOrderByColumn(RewritingArgumentTableMap::CREATED_AT);
}
/**
* Order by create date asc
*
* @return ChildRewritingArgumentQuery The current query, for fluid interface
*/
public function firstCreatedFirst()
{
return $this->addAscendingOrderByColumn(RewritingArgumentTableMap::CREATED_AT);
}
} // RewritingArgumentQuery

2147
core/lib/Thelia/Model/Base/RewritingUrl.php Normal file
View File

File diff suppressed because it is too large Load Diff

919
core/lib/Thelia/Model/Base/RewritingUrlQuery.php Normal file
View File

@@ -0,0 +1,919 @@
<?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\RewritingUrl as ChildRewritingUrl;
use Thelia\Model\RewritingUrlQuery as ChildRewritingUrlQuery;
use Thelia\Model\Map\RewritingUrlTableMap;
/**
* Base class that represents a query for the 'rewriting_url' table.
*
*
*
* @method ChildRewritingUrlQuery orderById($order = Criteria::ASC) Order by the id column
* @method ChildRewritingUrlQuery orderByUrl($order = Criteria::ASC) Order by the url column
* @method ChildRewritingUrlQuery orderByView($order = Criteria::ASC) Order by the view column
* @method ChildRewritingUrlQuery orderByViewId($order = Criteria::ASC) Order by the view_id column
* @method ChildRewritingUrlQuery orderByViewLocale($order = Criteria::ASC) Order by the view_locale column
* @method ChildRewritingUrlQuery orderByRedirected($order = Criteria::ASC) Order by the redirected column
* @method ChildRewritingUrlQuery orderByCreatedAt($order = Criteria::ASC) Order by the created_at column
* @method ChildRewritingUrlQuery orderByUpdatedAt($order = Criteria::ASC) Order by the updated_at column
*
* @method ChildRewritingUrlQuery groupById() Group by the id column
* @method ChildRewritingUrlQuery groupByUrl() Group by the url column
* @method ChildRewritingUrlQuery groupByView() Group by the view column
* @method ChildRewritingUrlQuery groupByViewId() Group by the view_id column
* @method ChildRewritingUrlQuery groupByViewLocale() Group by the view_locale column
* @method ChildRewritingUrlQuery groupByRedirected() Group by the redirected column
* @method ChildRewritingUrlQuery groupByCreatedAt() Group by the created_at column
* @method ChildRewritingUrlQuery groupByUpdatedAt() Group by the updated_at column
*
* @method ChildRewritingUrlQuery leftJoin($relation) Adds a LEFT JOIN clause to the query
* @method ChildRewritingUrlQuery rightJoin($relation) Adds a RIGHT JOIN clause to the query
* @method ChildRewritingUrlQuery innerJoin($relation) Adds a INNER JOIN clause to the query
*
* @method ChildRewritingUrlQuery leftJoinRewritingUrlRelatedByRedirected($relationAlias = null) Adds a LEFT JOIN clause to the query using the RewritingUrlRelatedByRedirected relation
* @method ChildRewritingUrlQuery rightJoinRewritingUrlRelatedByRedirected($relationAlias = null) Adds a RIGHT JOIN clause to the query using the RewritingUrlRelatedByRedirected relation
* @method ChildRewritingUrlQuery innerJoinRewritingUrlRelatedByRedirected($relationAlias = null) Adds a INNER JOIN clause to the query using the RewritingUrlRelatedByRedirected relation
*
* @method ChildRewritingUrlQuery leftJoinRewritingUrlRelatedById($relationAlias = null) Adds a LEFT JOIN clause to the query using the RewritingUrlRelatedById relation
* @method ChildRewritingUrlQuery rightJoinRewritingUrlRelatedById($relationAlias = null) Adds a RIGHT JOIN clause to the query using the RewritingUrlRelatedById relation
* @method ChildRewritingUrlQuery innerJoinRewritingUrlRelatedById($relationAlias = null) Adds a INNER JOIN clause to the query using the RewritingUrlRelatedById relation
*
* @method ChildRewritingUrlQuery leftJoinRewritingArgument($relationAlias = null) Adds a LEFT JOIN clause to the query using the RewritingArgument relation
* @method ChildRewritingUrlQuery rightJoinRewritingArgument($relationAlias = null) Adds a RIGHT JOIN clause to the query using the RewritingArgument relation
* @method ChildRewritingUrlQuery innerJoinRewritingArgument($relationAlias = null) Adds a INNER JOIN clause to the query using the RewritingArgument relation
*
* @method ChildRewritingUrl findOne(ConnectionInterface $con = null) Return the first ChildRewritingUrl matching the query
* @method ChildRewritingUrl findOneOrCreate(ConnectionInterface $con = null) Return the first ChildRewritingUrl matching the query, or a new ChildRewritingUrl object populated from the query conditions when no match is found
*
* @method ChildRewritingUrl findOneById(int $id) Return the first ChildRewritingUrl filtered by the id column
* @method ChildRewritingUrl findOneByUrl(string $url) Return the first ChildRewritingUrl filtered by the url column
* @method ChildRewritingUrl findOneByView(string $view) Return the first ChildRewritingUrl filtered by the view column
* @method ChildRewritingUrl findOneByViewId(string $view_id) Return the first ChildRewritingUrl filtered by the view_id column
* @method ChildRewritingUrl findOneByViewLocale(string $view_locale) Return the first ChildRewritingUrl filtered by the view_locale column
* @method ChildRewritingUrl findOneByRedirected(int $redirected) Return the first ChildRewritingUrl filtered by the redirected column
* @method ChildRewritingUrl findOneByCreatedAt(string $created_at) Return the first ChildRewritingUrl filtered by the created_at column
* @method ChildRewritingUrl findOneByUpdatedAt(string $updated_at) Return the first ChildRewritingUrl filtered by the updated_at column
*
* @method array findById(int $id) Return ChildRewritingUrl objects filtered by the id column
* @method array findByUrl(string $url) Return ChildRewritingUrl objects filtered by the url column
* @method array findByView(string $view) Return ChildRewritingUrl objects filtered by the view column
* @method array findByViewId(string $view_id) Return ChildRewritingUrl objects filtered by the view_id column
* @method array findByViewLocale(string $view_locale) Return ChildRewritingUrl objects filtered by the view_locale column
* @method array findByRedirected(int $redirected) Return ChildRewritingUrl objects filtered by the redirected column
* @method array findByCreatedAt(string $created_at) Return ChildRewritingUrl objects filtered by the created_at column
* @method array findByUpdatedAt(string $updated_at) Return ChildRewritingUrl objects filtered by the updated_at column
*
*/
abstract class RewritingUrlQuery extends ModelCriteria
{
/**
* Initializes internal state of \Thelia\Model\Base\RewritingUrlQuery 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\\RewritingUrl', $modelAlias = null)
{
parent::__construct($dbName, $modelName, $modelAlias);
}
/**
* Returns a new ChildRewritingUrlQuery object.
*
* @param string $modelAlias The alias of a model in the query
* @param Criteria $criteria Optional Criteria to build the query from
*
* @return ChildRewritingUrlQuery
*/
public static function create($modelAlias = null, $criteria = null)
{
if ($criteria instanceof \Thelia\Model\RewritingUrlQuery) {
return $criteria;
}
$query = new \Thelia\Model\RewritingUrlQuery();
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 ChildRewritingUrl|array|mixed the result, formatted by the current formatter
*/
public function findPk($key, $con = null)
{
if ($key === null) {
return null;
}
if ((null !== ($obj = RewritingUrlTableMap::getInstanceFromPool((string) $key))) && !$this->formatter) {
// the object is already in the instance pool
return $obj;
}
if ($con === null) {
$con = Propel::getServiceContainer()->getReadConnection(RewritingUrlTableMap::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 ChildRewritingUrl A model object, or null if the key is not found
*/
protected function findPkSimple($key, $con)
{
$sql = 'SELECT ID, URL, VIEW, VIEW_ID, VIEW_LOCALE, REDIRECTED, CREATED_AT, UPDATED_AT FROM rewriting_url 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 ChildRewritingUrl();
$obj->hydrate($row);
RewritingUrlTableMap::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 ChildRewritingUrl|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 ChildRewritingUrlQuery The current query, for fluid interface
*/
public function filterByPrimaryKey($key)
{
return $this->addUsingAlias(RewritingUrlTableMap::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 ChildRewritingUrlQuery The current query, for fluid interface
*/
public function filterByPrimaryKeys($keys)
{
return $this->addUsingAlias(RewritingUrlTableMap::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 ChildRewritingUrlQuery 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(RewritingUrlTableMap::ID, $id['min'], Criteria::GREATER_EQUAL);
$useMinMax = true;
}
if (isset($id['max'])) {
$this->addUsingAlias(RewritingUrlTableMap::ID, $id['max'], Criteria::LESS_EQUAL);
$useMinMax = true;
}
if ($useMinMax) {
return $this;
}
if (null === $comparison) {
$comparison = Criteria::IN;
}
}
return $this->addUsingAlias(RewritingUrlTableMap::ID, $id, $comparison);
}
/**
* Filter the query on the url column
*
* Example usage:
* <code>
* $query->filterByUrl('fooValue'); // WHERE url = 'fooValue'
* $query->filterByUrl('%fooValue%'); // WHERE url LIKE '%fooValue%'
* </code>
*
* @param string $url 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 ChildRewritingUrlQuery The current query, for fluid interface
*/
public function filterByUrl($url = null, $comparison = null)
{
if (null === $comparison) {
if (is_array($url)) {
$comparison = Criteria::IN;
} elseif (preg_match('/[\%\*]/', $url)) {
$url = str_replace('*', '%', $url);
$comparison = Criteria::LIKE;
}
}
return $this->addUsingAlias(RewritingUrlTableMap::URL, $url, $comparison);
}
/**
* Filter the query on the view column
*
* Example usage:
* <code>
* $query->filterByView('fooValue'); // WHERE view = 'fooValue'
* $query->filterByView('%fooValue%'); // WHERE view LIKE '%fooValue%'
* </code>
*
* @param string $view 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 ChildRewritingUrlQuery The current query, for fluid interface
*/
public function filterByView($view = null, $comparison = null)
{
if (null === $comparison) {
if (is_array($view)) {
$comparison = Criteria::IN;
} elseif (preg_match('/[\%\*]/', $view)) {
$view = str_replace('*', '%', $view);
$comparison = Criteria::LIKE;
}
}
return $this->addUsingAlias(RewritingUrlTableMap::VIEW, $view, $comparison);
}
/**
* Filter the query on the view_id column
*
* Example usage:
* <code>
* $query->filterByViewId('fooValue'); // WHERE view_id = 'fooValue'
* $query->filterByViewId('%fooValue%'); // WHERE view_id LIKE '%fooValue%'
* </code>
*
* @param string $viewId 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 ChildRewritingUrlQuery The current query, for fluid interface
*/
public function filterByViewId($viewId = null, $comparison = null)
{
if (null === $comparison) {
if (is_array($viewId)) {
$comparison = Criteria::IN;
} elseif (preg_match('/[\%\*]/', $viewId)) {
$viewId = str_replace('*', '%', $viewId);
$comparison = Criteria::LIKE;
}
}
return $this->addUsingAlias(RewritingUrlTableMap::VIEW_ID, $viewId, $comparison);
}
/**
* Filter the query on the view_locale column
*
* Example usage:
* <code>
* $query->filterByViewLocale('fooValue'); // WHERE view_locale = 'fooValue'
* $query->filterByViewLocale('%fooValue%'); // WHERE view_locale LIKE '%fooValue%'
* </code>
*
* @param string $viewLocale 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 ChildRewritingUrlQuery The current query, for fluid interface
*/
public function filterByViewLocale($viewLocale = null, $comparison = null)
{
if (null === $comparison) {
if (is_array($viewLocale)) {
$comparison = Criteria::IN;
} elseif (preg_match('/[\%\*]/', $viewLocale)) {
$viewLocale = str_replace('*', '%', $viewLocale);
$comparison = Criteria::LIKE;
}
}
return $this->addUsingAlias(RewritingUrlTableMap::VIEW_LOCALE, $viewLocale, $comparison);
}
/**
* Filter the query on the redirected column
*
* Example usage:
* <code>
* $query->filterByRedirected(1234); // WHERE redirected = 1234
* $query->filterByRedirected(array(12, 34)); // WHERE redirected IN (12, 34)
* $query->filterByRedirected(array('min' => 12)); // WHERE redirected > 12
* </code>
*
* @see filterByRewritingUrlRelatedByRedirected()
*
* @param mixed $redirected 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 ChildRewritingUrlQuery The current query, for fluid interface
*/
public function filterByRedirected($redirected = null, $comparison = null)
{
if (is_array($redirected)) {
$useMinMax = false;
if (isset($redirected['min'])) {
$this->addUsingAlias(RewritingUrlTableMap::REDIRECTED, $redirected['min'], Criteria::GREATER_EQUAL);
$useMinMax = true;
}
if (isset($redirected['max'])) {
$this->addUsingAlias(RewritingUrlTableMap::REDIRECTED, $redirected['max'], Criteria::LESS_EQUAL);
$useMinMax = true;
}
if ($useMinMax) {
return $this;
}
if (null === $comparison) {
$comparison = Criteria::IN;
}
}
return $this->addUsingAlias(RewritingUrlTableMap::REDIRECTED, $redirected, $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 ChildRewritingUrlQuery 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(RewritingUrlTableMap::CREATED_AT, $createdAt['min'], Criteria::GREATER_EQUAL);
$useMinMax = true;
}
if (isset($createdAt['max'])) {
$this->addUsingAlias(RewritingUrlTableMap::CREATED_AT, $createdAt['max'], Criteria::LESS_EQUAL);
$useMinMax = true;
}
if ($useMinMax) {
return $this;
}
if (null === $comparison) {
$comparison = Criteria::IN;
}
}
return $this->addUsingAlias(RewritingUrlTableMap::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 ChildRewritingUrlQuery 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(RewritingUrlTableMap::UPDATED_AT, $updatedAt['min'], Criteria::GREATER_EQUAL);
$useMinMax = true;
}
if (isset($updatedAt['max'])) {
$this->addUsingAlias(RewritingUrlTableMap::UPDATED_AT, $updatedAt['max'], Criteria::LESS_EQUAL);
$useMinMax = true;
}
if ($useMinMax) {
return $this;
}
if (null === $comparison) {
$comparison = Criteria::IN;
}
}
return $this->addUsingAlias(RewritingUrlTableMap::UPDATED_AT, $updatedAt, $comparison);
}
/**
* Filter the query by a related \Thelia\Model\RewritingUrl object
*
* @param \Thelia\Model\RewritingUrl|ObjectCollection $rewritingUrl The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return ChildRewritingUrlQuery The current query, for fluid interface
*/
public function filterByRewritingUrlRelatedByRedirected($rewritingUrl, $comparison = null)
{
if ($rewritingUrl instanceof \Thelia\Model\RewritingUrl) {
return $this
->addUsingAlias(RewritingUrlTableMap::REDIRECTED, $rewritingUrl->getId(), $comparison);
} elseif ($rewritingUrl instanceof ObjectCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this
->addUsingAlias(RewritingUrlTableMap::REDIRECTED, $rewritingUrl->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByRewritingUrlRelatedByRedirected() only accepts arguments of type \Thelia\Model\RewritingUrl or Collection');
}
}
/**
* Adds a JOIN clause to the query using the RewritingUrlRelatedByRedirected relation
*
* @param string $relationAlias optional alias for the relation
* @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
*
* @return ChildRewritingUrlQuery The current query, for fluid interface
*/
public function joinRewritingUrlRelatedByRedirected($relationAlias = null, $joinType = Criteria::LEFT_JOIN)
{
$tableMap = $this->getTableMap();
$relationMap = $tableMap->getRelation('RewritingUrlRelatedByRedirected');
// 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, 'RewritingUrlRelatedByRedirected');
}
return $this;
}
/**
* Use the RewritingUrlRelatedByRedirected relation RewritingUrl 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\RewritingUrlQuery A secondary query class using the current class as primary query
*/
public function useRewritingUrlRelatedByRedirectedQuery($relationAlias = null, $joinType = Criteria::LEFT_JOIN)
{
return $this
->joinRewritingUrlRelatedByRedirected($relationAlias, $joinType)
->useQuery($relationAlias ? $relationAlias : 'RewritingUrlRelatedByRedirected', '\Thelia\Model\RewritingUrlQuery');
}
/**
* Filter the query by a related \Thelia\Model\RewritingUrl object
*
* @param \Thelia\Model\RewritingUrl|ObjectCollection $rewritingUrl the related object to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return ChildRewritingUrlQuery The current query, for fluid interface
*/
public function filterByRewritingUrlRelatedById($rewritingUrl, $comparison = null)
{
if ($rewritingUrl instanceof \Thelia\Model\RewritingUrl) {
return $this
->addUsingAlias(RewritingUrlTableMap::ID, $rewritingUrl->getRedirected(), $comparison);
} elseif ($rewritingUrl instanceof ObjectCollection) {
return $this
->useRewritingUrlRelatedByIdQuery()
->filterByPrimaryKeys($rewritingUrl->getPrimaryKeys())
->endUse();
} else {
throw new PropelException('filterByRewritingUrlRelatedById() only accepts arguments of type \Thelia\Model\RewritingUrl or Collection');
}
}
/**
* Adds a JOIN clause to the query using the RewritingUrlRelatedById relation
*
* @param string $relationAlias optional alias for the relation
* @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
*
* @return ChildRewritingUrlQuery The current query, for fluid interface
*/
public function joinRewritingUrlRelatedById($relationAlias = null, $joinType = Criteria::LEFT_JOIN)
{
$tableMap = $this->getTableMap();
$relationMap = $tableMap->getRelation('RewritingUrlRelatedById');
// 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, 'RewritingUrlRelatedById');
}
return $this;
}
/**
* Use the RewritingUrlRelatedById relation RewritingUrl 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\RewritingUrlQuery A secondary query class using the current class as primary query
*/
public function useRewritingUrlRelatedByIdQuery($relationAlias = null, $joinType = Criteria::LEFT_JOIN)
{
return $this
->joinRewritingUrlRelatedById($relationAlias, $joinType)
->useQuery($relationAlias ? $relationAlias : 'RewritingUrlRelatedById', '\Thelia\Model\RewritingUrlQuery');
}
/**
* Filter the query by a related \Thelia\Model\RewritingArgument object
*
* @param \Thelia\Model\RewritingArgument|ObjectCollection $rewritingArgument the related object to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return ChildRewritingUrlQuery The current query, for fluid interface
*/
public function filterByRewritingArgument($rewritingArgument, $comparison = null)
{
if ($rewritingArgument instanceof \Thelia\Model\RewritingArgument) {
return $this
->addUsingAlias(RewritingUrlTableMap::ID, $rewritingArgument->getRewritingUrlId(), $comparison);
} elseif ($rewritingArgument instanceof ObjectCollection) {
return $this
->useRewritingArgumentQuery()
->filterByPrimaryKeys($rewritingArgument->getPrimaryKeys())
->endUse();
} else {
throw new PropelException('filterByRewritingArgument() only accepts arguments of type \Thelia\Model\RewritingArgument or Collection');
}
}
/**
* Adds a JOIN clause to the query using the RewritingArgument relation
*
* @param string $relationAlias optional alias for the relation
* @param string $joinType Accepted values are null, 'left join', 'right join', 'inner join'
*
* @return ChildRewritingUrlQuery The current query, for fluid interface
*/
public function joinRewritingArgument($relationAlias = null, $joinType = Criteria::INNER_JOIN)
{
$tableMap = $this->getTableMap();
$relationMap = $tableMap->getRelation('RewritingArgument');
// 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, 'RewritingArgument');
}
return $this;
}
/**
* Use the RewritingArgument relation RewritingArgument 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\RewritingArgumentQuery A secondary query class using the current class as primary query
*/
public function useRewritingArgumentQuery($relationAlias = null, $joinType = Criteria::INNER_JOIN)
{
return $this
->joinRewritingArgument($relationAlias, $joinType)
->useQuery($relationAlias ? $relationAlias : 'RewritingArgument', '\Thelia\Model\RewritingArgumentQuery');
}
/**
* Exclude object from result
*
* @param ChildRewritingUrl $rewritingUrl Object to remove from the list of results
*
* @return ChildRewritingUrlQuery The current query, for fluid interface
*/
public function prune($rewritingUrl = null)
{
if ($rewritingUrl) {
$this->addUsingAlias(RewritingUrlTableMap::ID, $rewritingUrl->getId(), Criteria::NOT_EQUAL);
}
return $this;
}
/**
* Deletes all rows from the rewriting_url 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(RewritingUrlTableMap::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).
RewritingUrlTableMap::clearInstancePool();
RewritingUrlTableMap::clearRelatedInstancePool();
$con->commit();
} catch (PropelException $e) {
$con->rollBack();
throw $e;
}
return $affectedRows;
}
/**
* Performs a DELETE on the database, given a ChildRewritingUrl or Criteria object OR a primary key value.
*
* @param mixed $values Criteria or ChildRewritingUrl 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(RewritingUrlTableMap::DATABASE_NAME);
}
$criteria = $this;
// Set the correct dbName
$criteria->setDbName(RewritingUrlTableMap::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();
RewritingUrlTableMap::removeInstanceFromPool($criteria);
$affectedRows += ModelCriteria::delete($con);
RewritingUrlTableMap::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 ChildRewritingUrlQuery The current query, for fluid interface
*/
public function recentlyUpdated($nbDays = 7)
{
return $this->addUsingAlias(RewritingUrlTableMap::UPDATED_AT, time() - $nbDays * 24 * 60 * 60, Criteria::GREATER_EQUAL);
}
/**
* Filter by the latest created
*
* @param int $nbDays Maximum age of in days
*
* @return ChildRewritingUrlQuery The current query, for fluid interface
*/
public function recentlyCreated($nbDays = 7)
{
return $this->addUsingAlias(RewritingUrlTableMap::CREATED_AT, time() - $nbDays * 24 * 60 * 60, Criteria::GREATER_EQUAL);
}
/**
* Order by update date desc
*
* @return ChildRewritingUrlQuery The current query, for fluid interface
*/
public function lastUpdatedFirst()
{
return $this->addDescendingOrderByColumn(RewritingUrlTableMap::UPDATED_AT);
}
/**
* Order by update date asc
*
* @return ChildRewritingUrlQuery The current query, for fluid interface
*/
public function firstUpdatedFirst()
{
return $this->addAscendingOrderByColumn(RewritingUrlTableMap::UPDATED_AT);
}
/**
* Order by create date desc
*
* @return ChildRewritingUrlQuery The current query, for fluid interface
*/
public function lastCreatedFirst()
{
return $this->addDescendingOrderByColumn(RewritingUrlTableMap::CREATED_AT);
}
/**
* Order by create date asc
*
* @return ChildRewritingUrlQuery The current query, for fluid interface
*/
public function firstCreatedFirst()
{
return $this->addAscendingOrderByColumn(RewritingUrlTableMap::CREATED_AT);
}
} // RewritingUrlQuery