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

2
core/lib/Thelia/Model/Map/CategoryTableMap.php
View File

@@ -193,7 +193,6 @@ class CategoryTableMap extends TableMap
$this->addRelation('ProductCategory', '\\Thelia\\Model\\ProductCategory', RelationMap::ONE_TO_MANY, array('id' => 'category_id', ), 'CASCADE', 'RESTRICT', 'ProductCategories');
$this->addRelation('FeatureCategory', '\\Thelia\\Model\\FeatureCategory', RelationMap::ONE_TO_MANY, array('id' => 'category_id', ), 'CASCADE', 'RESTRICT', 'FeatureCategories');
$this->addRelation('AttributeCategory', '\\Thelia\\Model\\AttributeCategory', RelationMap::ONE_TO_MANY, array('id' => 'category_id', ), 'CASCADE', 'RESTRICT', 'AttributeCategories');
$this->addRelation('Rewriting', '\\Thelia\\Model\\Rewriting', RelationMap::ONE_TO_MANY, array('id' => 'category_id', ), 'CASCADE', 'RESTRICT', 'Rewritings');
$this->addRelation('CategoryImage', '\\Thelia\\Model\\CategoryImage', RelationMap::ONE_TO_MANY, array('id' => 'category_id', ), 'CASCADE', 'RESTRICT', 'CategoryImages');
$this->addRelation('CategoryDocument', '\\Thelia\\Model\\CategoryDocument', RelationMap::ONE_TO_MANY, array('id' => 'category_id', ), 'CASCADE', 'RESTRICT', 'CategoryDocuments');
$this->addRelation('CategoryAssociatedContent', '\\Thelia\\Model\\CategoryAssociatedContent', RelationMap::ONE_TO_MANY, array('id' => 'category_id', ), 'CASCADE', 'RESTRICT', 'CategoryAssociatedContents');
@@ -228,7 +227,6 @@ class CategoryTableMap extends TableMap
ProductCategoryTableMap::clearInstancePool();
FeatureCategoryTableMap::clearInstancePool();
AttributeCategoryTableMap::clearInstancePool();
RewritingTableMap::clearInstancePool();
CategoryImageTableMap::clearInstancePool();
CategoryDocumentTableMap::clearInstancePool();
CategoryAssociatedContentTableMap::clearInstancePool();

2
core/lib/Thelia/Model/Map/ContentTableMap.php
View File

@@ -184,7 +184,6 @@ class ContentTableMap extends TableMap
*/
public function buildRelations()
{
$this->addRelation('Rewriting', '\\Thelia\\Model\\Rewriting', RelationMap::ONE_TO_MANY, array('id' => 'content_id', ), 'CASCADE', 'RESTRICT', 'Rewritings');
$this->addRelation('ContentFolder', '\\Thelia\\Model\\ContentFolder', RelationMap::ONE_TO_MANY, array('id' => 'content_id', ), 'CASCADE', 'RESTRICT', 'ContentFolders');
$this->addRelation('ContentImage', '\\Thelia\\Model\\ContentImage', RelationMap::ONE_TO_MANY, array('id' => 'content_id', ), 'CASCADE', 'RESTRICT', 'ContentImages');
$this->addRelation('ContentDocument', '\\Thelia\\Model\\ContentDocument', RelationMap::ONE_TO_MANY, array('id' => 'content_id', ), 'CASCADE', 'RESTRICT', 'ContentDocuments');
@@ -216,7 +215,6 @@ class ContentTableMap extends TableMap
{
// Invalidate objects in ".$this->getClassNameFromBuilder($joinedTableTableMapBuilder)." instance pool,
// since one or more of them may be deleted by ON DELETE CASCADE/SETNULL rule.
RewritingTableMap::clearInstancePool();
ContentFolderTableMap::clearInstancePool();
ContentImageTableMap::clearInstancePool();
ContentDocumentTableMap::clearInstancePool();

2
core/lib/Thelia/Model/Map/FolderTableMap.php
View File

@@ -190,7 +190,6 @@ class FolderTableMap extends TableMap
*/
public function buildRelations()
{
$this->addRelation('Rewriting', '\\Thelia\\Model\\Rewriting', RelationMap::ONE_TO_MANY, array('id' => 'folder_id', ), 'CASCADE', 'RESTRICT', 'Rewritings');
$this->addRelation('ContentFolder', '\\Thelia\\Model\\ContentFolder', RelationMap::ONE_TO_MANY, array('id' => 'folder_id', ), 'CASCADE', 'RESTRICT', 'ContentFolders');
$this->addRelation('FolderImage', '\\Thelia\\Model\\FolderImage', RelationMap::ONE_TO_MANY, array('id' => 'folder_id', ), 'CASCADE', 'RESTRICT', 'FolderImages');
$this->addRelation('FolderDocument', '\\Thelia\\Model\\FolderDocument', RelationMap::ONE_TO_MANY, array('id' => 'folder_id', ), 'CASCADE', 'RESTRICT', 'FolderDocuments');
@@ -220,7 +219,6 @@ class FolderTableMap extends TableMap
{
// Invalidate objects in ".$this->getClassNameFromBuilder($joinedTableTableMapBuilder)." instance pool,
// since one or more of them may be deleted by ON DELETE CASCADE/SETNULL rule.
RewritingTableMap::clearInstancePool();
ContentFolderTableMap::clearInstancePool();
FolderImageTableMap::clearInstancePool();
FolderDocumentTableMap::clearInstancePool();

2
core/lib/Thelia/Model/Map/ProductTableMap.php
View File

@@ -204,7 +204,6 @@ class ProductTableMap extends TableMap
$this->addRelation('ProductDocument', '\\Thelia\\Model\\ProductDocument', RelationMap::ONE_TO_MANY, array('id' => 'product_id', ), 'CASCADE', 'RESTRICT', 'ProductDocuments');
$this->addRelation('AccessoryRelatedByProductId', '\\Thelia\\Model\\Accessory', RelationMap::ONE_TO_MANY, array('id' => 'product_id', ), 'CASCADE', 'RESTRICT', 'AccessoriesRelatedByProductId');
$this->addRelation('AccessoryRelatedByAccessory', '\\Thelia\\Model\\Accessory', RelationMap::ONE_TO_MANY, array('id' => 'accessory', ), 'CASCADE', 'RESTRICT', 'AccessoriesRelatedByAccessory');
$this->addRelation('Rewriting', '\\Thelia\\Model\\Rewriting', RelationMap::ONE_TO_MANY, array('id' => 'product_id', ), 'CASCADE', 'RESTRICT', 'Rewritings');
$this->addRelation('CartItem', '\\Thelia\\Model\\CartItem', RelationMap::ONE_TO_MANY, array('id' => 'product_id', ), null, null, 'CartItems');
$this->addRelation('ProductAssociatedContent', '\\Thelia\\Model\\ProductAssociatedContent', RelationMap::ONE_TO_MANY, array('id' => 'product_id', ), 'CASCADE', 'RESTRICT', 'ProductAssociatedContents');
$this->addRelation('ProductI18n', '\\Thelia\\Model\\ProductI18n', RelationMap::ONE_TO_MANY, array('id' => 'id', ), 'CASCADE', null, 'ProductI18ns');
@@ -241,7 +240,6 @@ class ProductTableMap extends TableMap
ProductImageTableMap::clearInstancePool();
ProductDocumentTableMap::clearInstancePool();
AccessoryTableMap::clearInstancePool();
RewritingTableMap::clearInstancePool();
ProductAssociatedContentTableMap::clearInstancePool();
ProductI18nTableMap::clearInstancePool();
ProductVersionTableMap::clearInstancePool();

503
core/lib/Thelia/Model/Map/RewritingArgumentTableMap.php Normal file
View File

@@ -0,0 +1,503 @@
<?php
namespace Thelia\Model\Map;
use Propel\Runtime\Propel;
use Propel\Runtime\ActiveQuery\Criteria;
use Propel\Runtime\ActiveQuery\InstancePoolTrait;
use Propel\Runtime\Connection\ConnectionInterface;
use Propel\Runtime\Exception\PropelException;
use Propel\Runtime\Map\RelationMap;
use Propel\Runtime\Map\TableMap;
use Propel\Runtime\Map\TableMapTrait;
use Thelia\Model\RewritingArgument;
use Thelia\Model\RewritingArgumentQuery;
/**
* This class defines the structure of the 'rewriting_argument' table.
*
*
*
* This map class is used by Propel to do runtime db structure discovery.
* For example, the createSelectSql() method checks the type of a given column used in an
* ORDER BY clause to know whether it needs to apply SQL to make the ORDER BY case-insensitive
* (i.e. if it's a text column type).
*
*/
class RewritingArgumentTableMap extends TableMap
{
use InstancePoolTrait;
use TableMapTrait;
/**
* The (dot-path) name of this class
*/
const CLASS_NAME = 'Thelia.Model.Map.RewritingArgumentTableMap';
/**
* The default database name for this class
*/
const DATABASE_NAME = 'thelia';
/**
* The table name for this class
*/
const TABLE_NAME = 'rewriting_argument';
/**
* The related Propel class for this table
*/
const OM_CLASS = '\\Thelia\\Model\\RewritingArgument';
/**
* A class that can be returned by this tableMap
*/
const CLASS_DEFAULT = 'Thelia.Model.RewritingArgument';
/**
* The total number of columns
*/
const NUM_COLUMNS = 5;
/**
* The number of lazy-loaded columns
*/
const NUM_LAZY_LOAD_COLUMNS = 0;
/**
* The number of columns to hydrate (NUM_COLUMNS - NUM_LAZY_LOAD_COLUMNS)
*/
const NUM_HYDRATE_COLUMNS = 5;
/**
* the column name for the REWRITING_URL_ID field
*/
const REWRITING_URL_ID = 'rewriting_argument.REWRITING_URL_ID';
/**
* the column name for the PARAMETER field
*/
const PARAMETER = 'rewriting_argument.PARAMETER';
/**
* the column name for the VALUE field
*/
const VALUE = 'rewriting_argument.VALUE';
/**
* the column name for the CREATED_AT field
*/
const CREATED_AT = 'rewriting_argument.CREATED_AT';
/**
* the column name for the UPDATED_AT field
*/
const UPDATED_AT = 'rewriting_argument.UPDATED_AT';
/**
* The default string format for model objects of the related table
*/
const DEFAULT_STRING_FORMAT = 'YAML';
/**
* holds an array of fieldnames
*
* first dimension keys are the type constants
* e.g. self::$fieldNames[self::TYPE_PHPNAME][0] = 'Id'
*/
protected static $fieldNames = array (
self::TYPE_PHPNAME => array('RewritingUrlId', 'Parameter', 'Value', 'CreatedAt', 'UpdatedAt', ),
self::TYPE_STUDLYPHPNAME => array('rewritingUrlId', 'parameter', 'value', 'createdAt', 'updatedAt', ),
self::TYPE_COLNAME => array(RewritingArgumentTableMap::REWRITING_URL_ID, RewritingArgumentTableMap::PARAMETER, RewritingArgumentTableMap::VALUE, RewritingArgumentTableMap::CREATED_AT, RewritingArgumentTableMap::UPDATED_AT, ),
self::TYPE_RAW_COLNAME => array('REWRITING_URL_ID', 'PARAMETER', 'VALUE', 'CREATED_AT', 'UPDATED_AT', ),
self::TYPE_FIELDNAME => array('rewriting_url_id', 'parameter', 'value', 'created_at', 'updated_at', ),
self::TYPE_NUM => array(0, 1, 2, 3, 4, )
);
/**
* holds an array of keys for quick access to the fieldnames array
*
* first dimension keys are the type constants
* e.g. self::$fieldKeys[self::TYPE_PHPNAME]['Id'] = 0
*/
protected static $fieldKeys = array (
self::TYPE_PHPNAME => array('RewritingUrlId' => 0, 'Parameter' => 1, 'Value' => 2, 'CreatedAt' => 3, 'UpdatedAt' => 4, ),
self::TYPE_STUDLYPHPNAME => array('rewritingUrlId' => 0, 'parameter' => 1, 'value' => 2, 'createdAt' => 3, 'updatedAt' => 4, ),
self::TYPE_COLNAME => array(RewritingArgumentTableMap::REWRITING_URL_ID => 0, RewritingArgumentTableMap::PARAMETER => 1, RewritingArgumentTableMap::VALUE => 2, RewritingArgumentTableMap::CREATED_AT => 3, RewritingArgumentTableMap::UPDATED_AT => 4, ),
self::TYPE_RAW_COLNAME => array('REWRITING_URL_ID' => 0, 'PARAMETER' => 1, 'VALUE' => 2, 'CREATED_AT' => 3, 'UPDATED_AT' => 4, ),
self::TYPE_FIELDNAME => array('rewriting_url_id' => 0, 'parameter' => 1, 'value' => 2, 'created_at' => 3, 'updated_at' => 4, ),
self::TYPE_NUM => array(0, 1, 2, 3, 4, )
);
/**
* Initialize the table attributes and columns
* Relations are not initialized by this method since they are lazy loaded
*
* @return void
* @throws PropelException
*/
public function initialize()
{
// attributes
$this->setName('rewriting_argument');
$this->setPhpName('RewritingArgument');
$this->setClassName('\\Thelia\\Model\\RewritingArgument');
$this->setPackage('Thelia.Model');
$this->setUseIdGenerator(false);
// columns
$this->addForeignPrimaryKey('REWRITING_URL_ID', 'RewritingUrlId', 'INTEGER' , 'rewriting_url', 'ID', true, null, null);
$this->addPrimaryKey('PARAMETER', 'Parameter', 'VARCHAR', true, 255, null);
$this->addPrimaryKey('VALUE', 'Value', 'VARCHAR', true, 255, null);
$this->addColumn('CREATED_AT', 'CreatedAt', 'TIMESTAMP', false, null, null);
$this->addColumn('UPDATED_AT', 'UpdatedAt', 'TIMESTAMP', false, null, null);
} // initialize()
/**
* Build the RelationMap objects for this table relationships
*/
public function buildRelations()
{
$this->addRelation('RewritingUrl', '\\Thelia\\Model\\RewritingUrl', RelationMap::MANY_TO_ONE, array('rewriting_url_id' => 'id', ), 'CASCADE', 'RESTRICT');
} // buildRelations()
/**
*
* Gets the list of behaviors registered for this table
*
* @return array Associative array (name => parameters) of behaviors
*/
public function getBehaviors()
{
return array(
'timestampable' => array('create_column' => 'created_at', 'update_column' => 'updated_at', ),
);
} // getBehaviors()
/**
* Adds an object to the instance pool.
*
* Propel keeps cached copies of objects in an instance pool when they are retrieved
* from the database. In some cases you may need to explicitly add objects
* to the cache in order to ensure that the same objects are always returned by find*()
* and findPk*() calls.
*
* @param \Thelia\Model\RewritingArgument $obj A \Thelia\Model\RewritingArgument object.
* @param string $key (optional) key to use for instance map (for performance boost if key was already calculated externally).
*/
public static function addInstanceToPool($obj, $key = null)
{
if (Propel::isInstancePoolingEnabled()) {
if (null === $key) {
$key = serialize(array((string) $obj->getRewritingUrlId(), (string) $obj->getParameter(), (string) $obj->getValue()));
} // if key === null
self::$instances[$key] = $obj;
}
}
/**
* Removes an object from the instance pool.
*
* Propel keeps cached copies of objects in an instance pool when they are retrieved
* from the database. In some cases -- especially when you override doDelete
* methods in your stub classes -- you may need to explicitly remove objects
* from the cache in order to prevent returning objects that no longer exist.
*
* @param mixed $value A \Thelia\Model\RewritingArgument object or a primary key value.
*/
public static function removeInstanceFromPool($value)
{
if (Propel::isInstancePoolingEnabled() && null !== $value) {
if (is_object($value) && $value instanceof \Thelia\Model\RewritingArgument) {
$key = serialize(array((string) $value->getRewritingUrlId(), (string) $value->getParameter(), (string) $value->getValue()));
} elseif (is_array($value) && count($value) === 3) {
// assume we've been passed a primary key";
$key = serialize(array((string) $value[0], (string) $value[1], (string) $value[2]));
} elseif ($value instanceof Criteria) {
self::$instances = [];
return;
} else {
$e = new PropelException("Invalid value passed to removeInstanceFromPool(). Expected primary key or \Thelia\Model\RewritingArgument object; got " . (is_object($value) ? get_class($value) . ' object.' : var_export($value, true)));
throw $e;
}
unset(self::$instances[$key]);
}
}
/**
* Retrieves a string version of the primary key from the DB resultset row that can be used to uniquely identify a row in this table.
*
* For tables with a single-column primary key, that simple pkey value will be returned. For tables with
* a multi-column primary key, a serialize()d version of the primary key will be returned.
*
* @param array $row resultset row.
* @param int $offset The 0-based offset for reading from the resultset row.
* @param string $indexType One of the class type constants TableMap::TYPE_PHPNAME, TableMap::TYPE_STUDLYPHPNAME
* TableMap::TYPE_COLNAME, TableMap::TYPE_FIELDNAME, TableMap::TYPE_NUM
*/
public static function getPrimaryKeyHashFromRow($row, $offset = 0, $indexType = TableMap::TYPE_NUM)
{
// If the PK cannot be derived from the row, return NULL.
if ($row[TableMap::TYPE_NUM == $indexType ? 0 + $offset : static::translateFieldName('RewritingUrlId', TableMap::TYPE_PHPNAME, $indexType)] === null && $row[TableMap::TYPE_NUM == $indexType ? 1 + $offset : static::translateFieldName('Parameter', TableMap::TYPE_PHPNAME, $indexType)] === null && $row[TableMap::TYPE_NUM == $indexType ? 2 + $offset : static::translateFieldName('Value', TableMap::TYPE_PHPNAME, $indexType)] === null) {
return null;
}
return serialize(array((string) $row[TableMap::TYPE_NUM == $indexType ? 0 + $offset : static::translateFieldName('RewritingUrlId', TableMap::TYPE_PHPNAME, $indexType)], (string) $row[TableMap::TYPE_NUM == $indexType ? 1 + $offset : static::translateFieldName('Parameter', TableMap::TYPE_PHPNAME, $indexType)], (string) $row[TableMap::TYPE_NUM == $indexType ? 2 + $offset : static::translateFieldName('Value', TableMap::TYPE_PHPNAME, $indexType)]));
}
/**
* Retrieves the primary key from the DB resultset row
* For tables with a single-column primary key, that simple pkey value will be returned. For tables with
* a multi-column primary key, an array of the primary key columns will be returned.
*
* @param array $row resultset row.
* @param int $offset The 0-based offset for reading from the resultset row.
* @param string $indexType One of the class type constants TableMap::TYPE_PHPNAME, TableMap::TYPE_STUDLYPHPNAME
* TableMap::TYPE_COLNAME, TableMap::TYPE_FIELDNAME, TableMap::TYPE_NUM
*
* @return mixed The primary key of the row
*/
public static function getPrimaryKeyFromRow($row, $offset = 0, $indexType = TableMap::TYPE_NUM)
{
return $pks;
}
/**
* The class that the tableMap will make instances of.
*
* If $withPrefix is true, the returned path
* uses a dot-path notation which is translated into a path
* relative to a location on the PHP include_path.
* (e.g. path.to.MyClass -> 'path/to/MyClass.php')
*
* @param boolean $withPrefix Whether or not to return the path with the class name
* @return string path.to.ClassName
*/
public static function getOMClass($withPrefix = true)
{
return $withPrefix ? RewritingArgumentTableMap::CLASS_DEFAULT : RewritingArgumentTableMap::OM_CLASS;
}
/**
* Populates an object of the default type or an object that inherit from the default.
*
* @param array $row row returned by DataFetcher->fetch().
* @param int $offset The 0-based offset for reading from the resultset row.
* @param string $indexType The index type of $row. Mostly DataFetcher->getIndexType().
One of the class type constants TableMap::TYPE_PHPNAME, TableMap::TYPE_STUDLYPHPNAME
* TableMap::TYPE_COLNAME, TableMap::TYPE_FIELDNAME, TableMap::TYPE_NUM.
*
* @throws PropelException Any exceptions caught during processing will be
* rethrown wrapped into a PropelException.
* @return array (RewritingArgument object, last column rank)
*/
public static function populateObject($row, $offset = 0, $indexType = TableMap::TYPE_NUM)
{
$key = RewritingArgumentTableMap::getPrimaryKeyHashFromRow($row, $offset, $indexType);
if (null !== ($obj = RewritingArgumentTableMap::getInstanceFromPool($key))) {
// We no longer rehydrate the object, since this can cause data loss.
// See http://www.propelorm.org/ticket/509
// $obj->hydrate($row, $offset, true); // rehydrate
$col = $offset + RewritingArgumentTableMap::NUM_HYDRATE_COLUMNS;
} else {
$cls = RewritingArgumentTableMap::OM_CLASS;
$obj = new $cls();
$col = $obj->hydrate($row, $offset, false, $indexType);
RewritingArgumentTableMap::addInstanceToPool($obj, $key);
}
return array($obj, $col);
}
/**
* The returned array will contain objects of the default type or
* objects that inherit from the default.
*
* @param DataFetcherInterface $dataFetcher
* @return array
* @throws PropelException Any exceptions caught during processing will be
* rethrown wrapped into a PropelException.
*/
public static function populateObjects(DataFetcherInterface $dataFetcher)
{
$results = array();
// set the class once to avoid overhead in the loop
$cls = static::getOMClass(false);
// populate the object(s)
while ($row = $dataFetcher->fetch()) {
$key = RewritingArgumentTableMap::getPrimaryKeyHashFromRow($row, 0, $dataFetcher->getIndexType());
if (null !== ($obj = RewritingArgumentTableMap::getInstanceFromPool($key))) {
// We no longer rehydrate the object, since this can cause data loss.
// See http://www.propelorm.org/ticket/509
// $obj->hydrate($row, 0, true); // rehydrate
$results[] = $obj;
} else {
$obj = new $cls();
$obj->hydrate($row);
$results[] = $obj;
RewritingArgumentTableMap::addInstanceToPool($obj, $key);
} // if key exists
}
return $results;
}
/**
* Add all the columns needed to create a new object.
*
* Note: any columns that were marked with lazyLoad="true" in the
* XML schema will not be added to the select list and only loaded
* on demand.
*
* @param Criteria $criteria object containing the columns to add.
* @param string $alias optional table alias
* @throws PropelException Any exceptions caught during processing will be
* rethrown wrapped into a PropelException.
*/
public static function addSelectColumns(Criteria $criteria, $alias = null)
{
if (null === $alias) {
$criteria->addSelectColumn(RewritingArgumentTableMap::REWRITING_URL_ID);
$criteria->addSelectColumn(RewritingArgumentTableMap::PARAMETER);
$criteria->addSelectColumn(RewritingArgumentTableMap::VALUE);
$criteria->addSelectColumn(RewritingArgumentTableMap::CREATED_AT);
$criteria->addSelectColumn(RewritingArgumentTableMap::UPDATED_AT);
} else {
$criteria->addSelectColumn($alias . '.REWRITING_URL_ID');
$criteria->addSelectColumn($alias . '.PARAMETER');
$criteria->addSelectColumn($alias . '.VALUE');
$criteria->addSelectColumn($alias . '.CREATED_AT');
$criteria->addSelectColumn($alias . '.UPDATED_AT');
}
}
/**
* Returns the TableMap related to this object.
* This method is not needed for general use but a specific application could have a need.
* @return TableMap
* @throws PropelException Any exceptions caught during processing will be
* rethrown wrapped into a PropelException.
*/
public static function getTableMap()
{
return Propel::getServiceContainer()->getDatabaseMap(RewritingArgumentTableMap::DATABASE_NAME)->getTable(RewritingArgumentTableMap::TABLE_NAME);
}
/**
* Add a TableMap instance to the database for this tableMap class.
*/
public static function buildTableMap()
{
$dbMap = Propel::getServiceContainer()->getDatabaseMap(RewritingArgumentTableMap::DATABASE_NAME);
if (!$dbMap->hasTable(RewritingArgumentTableMap::TABLE_NAME)) {
$dbMap->addTableObject(new RewritingArgumentTableMap());
}
}
/**
* Performs a DELETE on the database, given a RewritingArgument or Criteria object OR a primary key value.
*
* @param mixed $values Criteria or RewritingArgument 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 static function doDelete($values, ConnectionInterface $con = null)
{
if (null === $con) {
$con = Propel::getServiceContainer()->getWriteConnection(RewritingArgumentTableMap::DATABASE_NAME);
}
if ($values instanceof Criteria) {
// rename for clarity
$criteria = $values;
} elseif ($values instanceof \Thelia\Model\RewritingArgument) { // it's a model object
// create criteria based on pk values
$criteria = $values->buildPkeyCriteria();
} else { // it's a primary key, or an array of pks
$criteria = new Criteria(RewritingArgumentTableMap::DATABASE_NAME);
// primary key is composite; we therefore, expect
// the primary key passed to be an array of pkey values
if (count($values) == count($values, COUNT_RECURSIVE)) {
// array is not multi-dimensional
$values = array($values);
}
foreach ($values as $value) {
$criterion = $criteria->getNewCriterion(RewritingArgumentTableMap::REWRITING_URL_ID, $value[0]);
$criterion->addAnd($criteria->getNewCriterion(RewritingArgumentTableMap::PARAMETER, $value[1]));
$criterion->addAnd($criteria->getNewCriterion(RewritingArgumentTableMap::VALUE, $value[2]));
$criteria->addOr($criterion);
}
}
$query = RewritingArgumentQuery::create()->mergeWith($criteria);
if ($values instanceof Criteria) { RewritingArgumentTableMap::clearInstancePool();
} elseif (!is_object($values)) { // it's a primary key, or an array of pks
foreach ((array) $values as $singleval) { RewritingArgumentTableMap::removeInstanceFromPool($singleval);
}
}
return $query->delete($con);
}
/**
* 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 static function doDeleteAll(ConnectionInterface $con = null)
{
return RewritingArgumentQuery::create()->doDeleteAll($con);
}
/**
* Performs an INSERT on the database, given a RewritingArgument or Criteria object.
*
* @param mixed $criteria Criteria or RewritingArgument object containing data that is used to create the INSERT statement.
* @param ConnectionInterface $con the ConnectionInterface connection to use
* @return mixed The new primary key.
* @throws PropelException Any exceptions caught during processing will be
* rethrown wrapped into a PropelException.
*/
public static function doInsert($criteria, ConnectionInterface $con = null)
{
if (null === $con) {
$con = Propel::getServiceContainer()->getWriteConnection(RewritingArgumentTableMap::DATABASE_NAME);
}
if ($criteria instanceof Criteria) {
$criteria = clone $criteria; // rename for clarity
} else {
$criteria = $criteria->buildCriteria(); // build Criteria from RewritingArgument object
}
// Set the correct dbName
$query = RewritingArgumentQuery::create()->mergeWith($criteria);
try {
// use transaction because $criteria could contain info
// for more than one table (I guess, conceivably)
$con->beginTransaction();
$pk = $query->doInsert($con);
$con->commit();
} catch (PropelException $e) {
$con->rollBack();
throw $e;
}
return $pk;
}
} // RewritingArgumentTableMap
// This is the static code needed to register the TableMap for this table with the main Propel class.
//
RewritingArgumentTableMap::buildTableMap();

478
core/lib/Thelia/Model/Map/RewritingUrlTableMap.php Normal file
View File

@@ -0,0 +1,478 @@
<?php
namespace Thelia\Model\Map;
use Propel\Runtime\Propel;
use Propel\Runtime\ActiveQuery\Criteria;
use Propel\Runtime\ActiveQuery\InstancePoolTrait;
use Propel\Runtime\Connection\ConnectionInterface;
use Propel\Runtime\Exception\PropelException;
use Propel\Runtime\Map\RelationMap;
use Propel\Runtime\Map\TableMap;
use Propel\Runtime\Map\TableMapTrait;
use Thelia\Model\RewritingUrl;
use Thelia\Model\RewritingUrlQuery;
/**
* This class defines the structure of the 'rewriting_url' table.
*
*
*
* This map class is used by Propel to do runtime db structure discovery.
* For example, the createSelectSql() method checks the type of a given column used in an
* ORDER BY clause to know whether it needs to apply SQL to make the ORDER BY case-insensitive
* (i.e. if it's a text column type).
*
*/
class RewritingUrlTableMap extends TableMap
{
use InstancePoolTrait;
use TableMapTrait;
/**
* The (dot-path) name of this class
*/
const CLASS_NAME = 'Thelia.Model.Map.RewritingUrlTableMap';
/**
* The default database name for this class
*/
const DATABASE_NAME = 'thelia';
/**
* The table name for this class
*/
const TABLE_NAME = 'rewriting_url';
/**
* The related Propel class for this table
*/
const OM_CLASS = '\\Thelia\\Model\\RewritingUrl';
/**
* A class that can be returned by this tableMap
*/
const CLASS_DEFAULT = 'Thelia.Model.RewritingUrl';
/**
* The total number of columns
*/
const NUM_COLUMNS = 8;
/**
* The number of lazy-loaded columns
*/
const NUM_LAZY_LOAD_COLUMNS = 0;
/**
* The number of columns to hydrate (NUM_COLUMNS - NUM_LAZY_LOAD_COLUMNS)
*/
const NUM_HYDRATE_COLUMNS = 8;
/**
* the column name for the ID field
*/
const ID = 'rewriting_url.ID';
/**
* the column name for the URL field
*/
const URL = 'rewriting_url.URL';
/**
* the column name for the VIEW field
*/
const VIEW = 'rewriting_url.VIEW';
/**
* the column name for the VIEW_ID field
*/
const VIEW_ID = 'rewriting_url.VIEW_ID';
/**
* the column name for the VIEW_LOCALE field
*/
const VIEW_LOCALE = 'rewriting_url.VIEW_LOCALE';
/**
* the column name for the REDIRECTED field
*/
const REDIRECTED = 'rewriting_url.REDIRECTED';
/**
* the column name for the CREATED_AT field
*/
const CREATED_AT = 'rewriting_url.CREATED_AT';
/**
* the column name for the UPDATED_AT field
*/
const UPDATED_AT = 'rewriting_url.UPDATED_AT';
/**
* The default string format for model objects of the related table
*/
const DEFAULT_STRING_FORMAT = 'YAML';
/**
* holds an array of fieldnames
*
* first dimension keys are the type constants
* e.g. self::$fieldNames[self::TYPE_PHPNAME][0] = 'Id'
*/
protected static $fieldNames = array (
self::TYPE_PHPNAME => array('Id', 'Url', 'View', 'ViewId', 'ViewLocale', 'Redirected', 'CreatedAt', 'UpdatedAt', ),
self::TYPE_STUDLYPHPNAME => array('id', 'url', 'view', 'viewId', 'viewLocale', 'redirected', 'createdAt', 'updatedAt', ),
self::TYPE_COLNAME => array(RewritingUrlTableMap::ID, RewritingUrlTableMap::URL, RewritingUrlTableMap::VIEW, RewritingUrlTableMap::VIEW_ID, RewritingUrlTableMap::VIEW_LOCALE, RewritingUrlTableMap::REDIRECTED, RewritingUrlTableMap::CREATED_AT, RewritingUrlTableMap::UPDATED_AT, ),
self::TYPE_RAW_COLNAME => array('ID', 'URL', 'VIEW', 'VIEW_ID', 'VIEW_LOCALE', 'REDIRECTED', 'CREATED_AT', 'UPDATED_AT', ),
self::TYPE_FIELDNAME => array('id', 'url', 'view', 'view_id', 'view_locale', 'redirected', 'created_at', 'updated_at', ),
self::TYPE_NUM => array(0, 1, 2, 3, 4, 5, 6, 7, )
);
/**
* holds an array of keys for quick access to the fieldnames array
*
* first dimension keys are the type constants
* e.g. self::$fieldKeys[self::TYPE_PHPNAME]['Id'] = 0
*/
protected static $fieldKeys = array (
self::TYPE_PHPNAME => array('Id' => 0, 'Url' => 1, 'View' => 2, 'ViewId' => 3, 'ViewLocale' => 4, 'Redirected' => 5, 'CreatedAt' => 6, 'UpdatedAt' => 7, ),
self::TYPE_STUDLYPHPNAME => array('id' => 0, 'url' => 1, 'view' => 2, 'viewId' => 3, 'viewLocale' => 4, 'redirected' => 5, 'createdAt' => 6, 'updatedAt' => 7, ),
self::TYPE_COLNAME => array(RewritingUrlTableMap::ID => 0, RewritingUrlTableMap::URL => 1, RewritingUrlTableMap::VIEW => 2, RewritingUrlTableMap::VIEW_ID => 3, RewritingUrlTableMap::VIEW_LOCALE => 4, RewritingUrlTableMap::REDIRECTED => 5, RewritingUrlTableMap::CREATED_AT => 6, RewritingUrlTableMap::UPDATED_AT => 7, ),
self::TYPE_RAW_COLNAME => array('ID' => 0, 'URL' => 1, 'VIEW' => 2, 'VIEW_ID' => 3, 'VIEW_LOCALE' => 4, 'REDIRECTED' => 5, 'CREATED_AT' => 6, 'UPDATED_AT' => 7, ),
self::TYPE_FIELDNAME => array('id' => 0, 'url' => 1, 'view' => 2, 'view_id' => 3, 'view_locale' => 4, 'redirected' => 5, 'created_at' => 6, 'updated_at' => 7, ),
self::TYPE_NUM => array(0, 1, 2, 3, 4, 5, 6, 7, )
);
/**
* Initialize the table attributes and columns
* Relations are not initialized by this method since they are lazy loaded
*
* @return void
* @throws PropelException
*/
public function initialize()
{
// attributes
$this->setName('rewriting_url');
$this->setPhpName('RewritingUrl');
$this->setClassName('\\Thelia\\Model\\RewritingUrl');
$this->setPackage('Thelia.Model');
$this->setUseIdGenerator(false);
// columns
$this->addPrimaryKey('ID', 'Id', 'INTEGER', true, null, null);
$this->addColumn('URL', 'Url', 'VARCHAR', true, 255, null);
$this->addColumn('VIEW', 'View', 'VARCHAR', false, 255, null);
$this->addColumn('VIEW_ID', 'ViewId', 'VARCHAR', false, 255, null);
$this->addColumn('VIEW_LOCALE', 'ViewLocale', 'VARCHAR', false, 255, null);
$this->addForeignKey('REDIRECTED', 'Redirected', 'INTEGER', 'rewriting_url', 'ID', false, null, null);
$this->addColumn('CREATED_AT', 'CreatedAt', 'TIMESTAMP', false, null, null);
$this->addColumn('UPDATED_AT', 'UpdatedAt', 'TIMESTAMP', false, null, null);
} // initialize()
/**
* Build the RelationMap objects for this table relationships
*/
public function buildRelations()
{
$this->addRelation('RewritingUrlRelatedByRedirected', '\\Thelia\\Model\\RewritingUrl', RelationMap::MANY_TO_ONE, array('redirected' => 'id', ), 'RESTRICT', 'RESTRICT');
$this->addRelation('RewritingUrlRelatedById', '\\Thelia\\Model\\RewritingUrl', RelationMap::ONE_TO_MANY, array('id' => 'redirected', ), 'RESTRICT', 'RESTRICT', 'RewritingUrlsRelatedById');
$this->addRelation('RewritingArgument', '\\Thelia\\Model\\RewritingArgument', RelationMap::ONE_TO_MANY, array('id' => 'rewriting_url_id', ), 'CASCADE', 'RESTRICT', 'RewritingArguments');
} // buildRelations()
/**
*
* Gets the list of behaviors registered for this table
*
* @return array Associative array (name => parameters) of behaviors
*/
public function getBehaviors()
{
return array(
'timestampable' => array('create_column' => 'created_at', 'update_column' => 'updated_at', ),
);
} // getBehaviors()
/**
* Method to invalidate the instance pool of all tables related to rewriting_url * by a foreign key with ON DELETE CASCADE
*/
public static function clearRelatedInstancePool()
{
// Invalidate objects in ".$this->getClassNameFromBuilder($joinedTableTableMapBuilder)." instance pool,
// since one or more of them may be deleted by ON DELETE CASCADE/SETNULL rule.
RewritingArgumentTableMap::clearInstancePool();
}
/**
* Retrieves a string version of the primary key from the DB resultset row that can be used to uniquely identify a row in this table.
*
* For tables with a single-column primary key, that simple pkey value will be returned. For tables with
* a multi-column primary key, a serialize()d version of the primary key will be returned.
*
* @param array $row resultset row.
* @param int $offset The 0-based offset for reading from the resultset row.
* @param string $indexType One of the class type constants TableMap::TYPE_PHPNAME, TableMap::TYPE_STUDLYPHPNAME
* TableMap::TYPE_COLNAME, TableMap::TYPE_FIELDNAME, TableMap::TYPE_NUM
*/
public static function getPrimaryKeyHashFromRow($row, $offset = 0, $indexType = TableMap::TYPE_NUM)
{
// If the PK cannot be derived from the row, return NULL.
if ($row[TableMap::TYPE_NUM == $indexType ? 0 + $offset : static::translateFieldName('Id', TableMap::TYPE_PHPNAME, $indexType)] === null) {
return null;
}
return (string) $row[TableMap::TYPE_NUM == $indexType ? 0 + $offset : static::translateFieldName('Id', TableMap::TYPE_PHPNAME, $indexType)];
}
/**
* Retrieves the primary key from the DB resultset row
* For tables with a single-column primary key, that simple pkey value will be returned. For tables with
* a multi-column primary key, an array of the primary key columns will be returned.
*
* @param array $row resultset row.
* @param int $offset The 0-based offset for reading from the resultset row.
* @param string $indexType One of the class type constants TableMap::TYPE_PHPNAME, TableMap::TYPE_STUDLYPHPNAME
* TableMap::TYPE_COLNAME, TableMap::TYPE_FIELDNAME, TableMap::TYPE_NUM
*
* @return mixed The primary key of the row
*/
public static function getPrimaryKeyFromRow($row, $offset = 0, $indexType = TableMap::TYPE_NUM)
{
return (int) $row[
$indexType == TableMap::TYPE_NUM
? 0 + $offset
: self::translateFieldName('Id', TableMap::TYPE_PHPNAME, $indexType)
];
}
/**
* The class that the tableMap will make instances of.
*
* If $withPrefix is true, the returned path
* uses a dot-path notation which is translated into a path
* relative to a location on the PHP include_path.
* (e.g. path.to.MyClass -> 'path/to/MyClass.php')
*
* @param boolean $withPrefix Whether or not to return the path with the class name
* @return string path.to.ClassName
*/
public static function getOMClass($withPrefix = true)
{
return $withPrefix ? RewritingUrlTableMap::CLASS_DEFAULT : RewritingUrlTableMap::OM_CLASS;
}
/**
* Populates an object of the default type or an object that inherit from the default.
*
* @param array $row row returned by DataFetcher->fetch().
* @param int $offset The 0-based offset for reading from the resultset row.
* @param string $indexType The index type of $row. Mostly DataFetcher->getIndexType().
One of the class type constants TableMap::TYPE_PHPNAME, TableMap::TYPE_STUDLYPHPNAME
* TableMap::TYPE_COLNAME, TableMap::TYPE_FIELDNAME, TableMap::TYPE_NUM.
*
* @throws PropelException Any exceptions caught during processing will be
* rethrown wrapped into a PropelException.
* @return array (RewritingUrl object, last column rank)
*/
public static function populateObject($row, $offset = 0, $indexType = TableMap::TYPE_NUM)
{
$key = RewritingUrlTableMap::getPrimaryKeyHashFromRow($row, $offset, $indexType);
if (null !== ($obj = RewritingUrlTableMap::getInstanceFromPool($key))) {
// We no longer rehydrate the object, since this can cause data loss.
// See http://www.propelorm.org/ticket/509
// $obj->hydrate($row, $offset, true); // rehydrate
$col = $offset + RewritingUrlTableMap::NUM_HYDRATE_COLUMNS;
} else {
$cls = RewritingUrlTableMap::OM_CLASS;
$obj = new $cls();
$col = $obj->hydrate($row, $offset, false, $indexType);
RewritingUrlTableMap::addInstanceToPool($obj, $key);
}
return array($obj, $col);
}
/**
* The returned array will contain objects of the default type or
* objects that inherit from the default.
*
* @param DataFetcherInterface $dataFetcher
* @return array
* @throws PropelException Any exceptions caught during processing will be
* rethrown wrapped into a PropelException.
*/
public static function populateObjects(DataFetcherInterface $dataFetcher)
{
$results = array();
// set the class once to avoid overhead in the loop
$cls = static::getOMClass(false);
// populate the object(s)
while ($row = $dataFetcher->fetch()) {
$key = RewritingUrlTableMap::getPrimaryKeyHashFromRow($row, 0, $dataFetcher->getIndexType());
if (null !== ($obj = RewritingUrlTableMap::getInstanceFromPool($key))) {
// We no longer rehydrate the object, since this can cause data loss.
// See http://www.propelorm.org/ticket/509
// $obj->hydrate($row, 0, true); // rehydrate
$results[] = $obj;
} else {
$obj = new $cls();
$obj->hydrate($row);
$results[] = $obj;
RewritingUrlTableMap::addInstanceToPool($obj, $key);
} // if key exists
}
return $results;
}
/**
* Add all the columns needed to create a new object.
*
* Note: any columns that were marked with lazyLoad="true" in the
* XML schema will not be added to the select list and only loaded
* on demand.
*
* @param Criteria $criteria object containing the columns to add.
* @param string $alias optional table alias
* @throws PropelException Any exceptions caught during processing will be
* rethrown wrapped into a PropelException.
*/
public static function addSelectColumns(Criteria $criteria, $alias = null)
{
if (null === $alias) {
$criteria->addSelectColumn(RewritingUrlTableMap::ID);
$criteria->addSelectColumn(RewritingUrlTableMap::URL);
$criteria->addSelectColumn(RewritingUrlTableMap::VIEW);
$criteria->addSelectColumn(RewritingUrlTableMap::VIEW_ID);
$criteria->addSelectColumn(RewritingUrlTableMap::VIEW_LOCALE);
$criteria->addSelectColumn(RewritingUrlTableMap::REDIRECTED);
$criteria->addSelectColumn(RewritingUrlTableMap::CREATED_AT);
$criteria->addSelectColumn(RewritingUrlTableMap::UPDATED_AT);
} else {
$criteria->addSelectColumn($alias . '.ID');
$criteria->addSelectColumn($alias . '.URL');
$criteria->addSelectColumn($alias . '.VIEW');
$criteria->addSelectColumn($alias . '.VIEW_ID');
$criteria->addSelectColumn($alias . '.VIEW_LOCALE');
$criteria->addSelectColumn($alias . '.REDIRECTED');
$criteria->addSelectColumn($alias . '.CREATED_AT');
$criteria->addSelectColumn($alias . '.UPDATED_AT');
}
}
/**
* Returns the TableMap related to this object.
* This method is not needed for general use but a specific application could have a need.
* @return TableMap
* @throws PropelException Any exceptions caught during processing will be
* rethrown wrapped into a PropelException.
*/
public static function getTableMap()
{
return Propel::getServiceContainer()->getDatabaseMap(RewritingUrlTableMap::DATABASE_NAME)->getTable(RewritingUrlTableMap::TABLE_NAME);
}
/**
* Add a TableMap instance to the database for this tableMap class.
*/
public static function buildTableMap()
{
$dbMap = Propel::getServiceContainer()->getDatabaseMap(RewritingUrlTableMap::DATABASE_NAME);
if (!$dbMap->hasTable(RewritingUrlTableMap::TABLE_NAME)) {
$dbMap->addTableObject(new RewritingUrlTableMap());
}
}
/**
* Performs a DELETE on the database, given a RewritingUrl or Criteria object OR a primary key value.
*
* @param mixed $values Criteria or RewritingUrl 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 static function doDelete($values, ConnectionInterface $con = null)
{
if (null === $con) {
$con = Propel::getServiceContainer()->getWriteConnection(RewritingUrlTableMap::DATABASE_NAME);
}
if ($values instanceof Criteria) {
// rename for clarity
$criteria = $values;
} elseif ($values instanceof \Thelia\Model\RewritingUrl) { // it's a model object
// create criteria based on pk values
$criteria = $values->buildPkeyCriteria();
} else { // it's a primary key, or an array of pks
$criteria = new Criteria(RewritingUrlTableMap::DATABASE_NAME);
$criteria->add(RewritingUrlTableMap::ID, (array) $values, Criteria::IN);
}
$query = RewritingUrlQuery::create()->mergeWith($criteria);
if ($values instanceof Criteria) { RewritingUrlTableMap::clearInstancePool();
} elseif (!is_object($values)) { // it's a primary key, or an array of pks
foreach ((array) $values as $singleval) { RewritingUrlTableMap::removeInstanceFromPool($singleval);
}
}
return $query->delete($con);
}
/**
* 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 static function doDeleteAll(ConnectionInterface $con = null)
{
return RewritingUrlQuery::create()->doDeleteAll($con);
}
/**
* Performs an INSERT on the database, given a RewritingUrl or Criteria object.
*
* @param mixed $criteria Criteria or RewritingUrl object containing data that is used to create the INSERT statement.
* @param ConnectionInterface $con the ConnectionInterface connection to use
* @return mixed The new primary key.
* @throws PropelException Any exceptions caught during processing will be
* rethrown wrapped into a PropelException.
*/
public static function doInsert($criteria, ConnectionInterface $con = null)
{
if (null === $con) {
$con = Propel::getServiceContainer()->getWriteConnection(RewritingUrlTableMap::DATABASE_NAME);
}
if ($criteria instanceof Criteria) {
$criteria = clone $criteria; // rename for clarity
} else {
$criteria = $criteria->buildCriteria(); // build Criteria from RewritingUrl object
}
// Set the correct dbName
$query = RewritingUrlQuery::create()->mergeWith($criteria);
try {
// use transaction because $criteria could contain info
// for more than one table (I guess, conceivably)
$con->beginTransaction();
$pk = $query->doInsert($con);
$con->commit();
} catch (PropelException $e) {
$con->rollBack();
throw $e;
}
return $pk;
}
} // RewritingUrlTableMap
// This is the static code needed to register the TableMap for this table with the main Propel class.
//
RewritingUrlTableMap::buildTableMap();

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

@@ -0,0 +1,9 @@
<?php
namespace Thelia\Model;
use Thelia\Model\Base\RewritingArgument as BaseRewritingArgument;
class RewritingArgument extends BaseRewritingArgument {
}

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

@@ -0,0 +1,20 @@
<?php
namespace Thelia\Model;
use Thelia\Model\Base\RewritingArgumentQuery as BaseRewritingArgumentQuery;
/**
* Skeleton subclass for performing query and update operations on the 'rewriting_argument' table.
*
*
*
* You should add additional methods to this class to meet the
* application requirements. This class will only be generated as
* long as it does not already exist in the output directory.
*
*/
class RewritingArgumentQuery extends BaseRewritingArgumentQuery {
} // RewritingArgumentQuery

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

@@ -0,0 +1,9 @@
<?php
namespace Thelia\Model;
use Thelia\Model\Base\RewritingUrl as BaseRewritingUrl;
class RewritingUrl extends BaseRewritingUrl {
}

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

@@ -0,0 +1,20 @@
<?php
namespace Thelia\Model;
use Thelia\Model\Base\RewritingUrlQuery as BaseRewritingUrlQuery;
/**
* Skeleton subclass for performing query and update operations on the 'rewriting_url' table.
*
*
*
* You should add additional methods to this class to meet the
* application requirements. This class will only be generated as
* long as it does not already exist in the output directory.
*
*/
class RewritingUrlQuery extends BaseRewritingUrlQuery {
} // RewritingUrlQuery

2
install/thelia.sql
View File

@@ -1485,7 +1485,7 @@ DROP TABLE IF EXISTS `rewriting_url`;
CREATE TABLE `rewriting_url`
(
`id` INTEGER NOT NULL,
`url` VARCHAR(255),
`url` VARCHAR(255) NOT NULL,
`view` VARCHAR(255),
`view_id` VARCHAR(255),
`view_locale` VARCHAR(255),

35
local/config/schema.xml
View File

@@ -755,39 +755,6 @@
<parameter name="log_created_by" value="true" />
</behavior>
</table>
<table name="rewriting" namespace="Thelia\Model">
<column name="id" primaryKey="true" required="true" type="INTEGER" />
<column name="url" required="true" size="255" type="VARCHAR" />
<column name="product_id" type="INTEGER" />
<column name="category_id" type="INTEGER" />
<column name="folder_id" type="INTEGER" />
<column name="content_id" type="INTEGER" />
<foreign-key foreignTable="product" name="fk_rewriting_product_id" onDelete="CASCADE" onUpdate="RESTRICT">
<reference foreign="id" local="product_id" />
</foreign-key>
<foreign-key foreignTable="category" name="fk_rewriting_category_id" onDelete="CASCADE" onUpdate="RESTRICT">
<reference foreign="id" local="category_id" />
</foreign-key>
<foreign-key foreignTable="folder" name="fk_rewriting_folder_id" onDelete="CASCADE" onUpdate="RESTRICT">
<reference foreign="id" local="folder_id" />
</foreign-key>
<foreign-key foreignTable="content" name="fk_rewriting_content_id" onDelete="CASCADE" onUpdate="RESTRICT">
<reference foreign="id" local="content_id" />
</foreign-key>
<index name="idx_rewriting_product_id">
<index-column name="product_id" />
</index>
<index name="idx_rewriting_category_id">
<index-column name="category_id" />
</index>
<index name="idx_rewriting_folder_id">
<index-column name="folder_id" />
</index>
<index name="idx_rewriting_content_id">
<index-column name="content_id" />
</index>
<behavior name="timestampable" />
</table>
<table name="coupon" namespace="Thelia\Model">
<column autoIncrement="true" name="id" primaryKey="true" required="true" type="INTEGER" />
<column name="code" required="true" size="45" type="VARCHAR" />
@@ -1128,7 +1095,7 @@
</table>
<table name="rewriting_url" namespace="Thelia\Model">
<column name="id" primaryKey="true" required="true" type="INTEGER" />
<column name="url" size="255" type="VARCHAR" />
<column name="url" required="true" size="255" type="VARCHAR" />
<column name="view" size="255" type="VARCHAR" />
<column name="view_id" size="255" type="VARCHAR" />
<column name="view_locale" size="255" type="VARCHAR" />