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

Merge branch 'master' of https://github.com/thelia/thelia into coupon

Browse Source 
# By Etienne Roudeix (4) and franck (1)
# Via franck
* 'master' of https://github.com/thelia/thelia:
  Removed InternalEvent, simplified SecurityContext
  rewriting tables
  rewriting tables
  rewriting tables
  rewriting tables

Conflicts:
	composer.lock
	local/config/schema.xml
This commit is contained in:
gmorel
2013-08-28 18:19:38 +02:00
parent 6c2dbb0152 0361cd1ff2
commit 71a91ff60f
53 changed files with 6375 additions and 5245 deletions
Download Patch File Download Diff File Expand all files Collapse all files

77
core/lib/Thelia/Action/BaseAction.php
View File

@@ -40,52 +40,6 @@ class BaseAction
$this->container = $container;
}
/**
* Validate a BaseForm
*
* @param BaseForm $aBaseForm the form
* @param string $expectedMethod the expected method, POST or GET, or null for any of them
* @throws FormValidationException is the form contains error, or the method is not the right one
* @return \Symfony\Component\Form\Form Form the symfony form object
*/
protected function validateForm(BaseForm $aBaseForm, $expectedMethod = null)
{
$form = $aBaseForm->getForm();
if ($expectedMethod == null || $aBaseForm->getRequest()->isMethod($expectedMethod)) {
$form->bind($aBaseForm->getRequest());
if ($form->isValid()) {
return $form;
} else {
throw new FormValidationException("Missing or invalid data");
}
} else {
throw new FormValidationException(sprintf("Wrong form method, %s expected.", $expectedMethod));
}
}
/**
* Propagate a form error in the action event
*
* @param BaseForm $aBaseForm the form
* @param string $error_message an error message that may be displayed to the customer
* @param ActionEvent $event the action event
*/
protected function propagateFormError(BaseForm $aBaseForm, $error_message, ActionEvent $event)
{
// The form has an error
$aBaseForm->setError(true);
$aBaseForm->setErrorMessage($error_message);
// Store the form in the parser context
$event->setErrorForm($aBaseForm);
// Stop event propagation
$event->stopPropagation();
}
/**
* Return the event dispatcher,
*
@@ -96,4 +50,33 @@ class BaseAction
return $this->container->get('event_dispatcher');
}
}
/**
* Check current user authorisations.
*
* @param mixed $roles a single role or an array of roles.
* @param mixed $permissions a single permission or an array of permissions.
*
* @throws AuthenticationException if permissions are not granted to the current user.
*/
protected function checkAuth($roles, $permissions) {
if (! $this->getSecurityContext()->isGranted(
is_array($roles) ? $roles : array($roles),
is_array($permissions) ? $permissions : array($permissions)) ) {
Tlog::getInstance()->addAlert("Authorization roles:", $roles, " permissions:", $permissions, " refused.");
throw new AuthorizationException("Sorry, you're not allowed to perform this action");
}
}
/**
* Return the security context
*
* @return Thelia\Core\Security\SecurityContext
*/
protected function getSecurityContext()
{
return $this->container->get('thelia.securityContext');
}
}

249
core/lib/Thelia/Action/Category.php
View File

@@ -24,134 +24,46 @@
namespace Thelia\Action;
use Symfony\Component\EventDispatcher\EventSubscriberInterface;
use Thelia\Core\Event\ActionEvent;
use Thelia\Core\Event\TheliaEvents;
use Thelia\Model\Category as CategoryModel;
use Thelia\Form\CategoryCreationForm;
use Thelia\Core\Event\CategoryEvent;
use Thelia\Tools\Redirect;
use Thelia\Model\CategoryQuery;
use Thelia\Model\AdminLog;
use Thelia\Form\CategoryDeletionForm;
use Thelia\Action\Exception\FormValidationException;
use Propel\Runtime\ActiveQuery\Criteria;
use Propel\Runtime\Propel;
use Thelia\Model\Map\CategoryTableMap;
use Propel\Runtime\Exception\PropelException;
use Thelia\Core\Event\CategoryCreateEvent;
use Thelia\Core\Event\CategoryDeleteEvent;
use Thelia\Core\Event\CategoryToggleVisibilityEvent;
use Thelia\Core\Event\CategoryChangePositionEvent;
class Category extends BaseAction implements EventSubscriberInterface
{
public function create(ActionEvent $event)
public function create(CategoryCreateEvent $event)
{
$this->checkAuth("ADMIN", "admin.category.create");
$request = $event->getRequest();
$category = new CategoryModel();
try {
$categoryCreationForm = new CategoryCreationForm($request);
$event->getDispatcher()->dispatch(TheliaEvents::BEFORE_CREATECATEGORY, $event);
$form = $this->validateForm($categoryCreationForm, "POST");
$category->create(
$event->getTitle(),
$event->getParent(),
$event->getLocale()
);
$data = $form->getData();
$event->setCreatedCategory($category);
$category = new CategoryModel();
$event->getDispatcher()->dispatch(TheliaEvents::BEFORE_CREATECATEGORY, $event);
$category->create(
$data["title"],
$data["parent"],
$data["locale"]
);
AdminLog::append(sprintf("Category %s (ID %s) created", $category->getTitle(), $category->getId()), $request, $request->getSession()->getAdminUser());
$categoryEvent = new CategoryEvent($category);
$event->getDispatcher()->dispatch(TheliaEvents::AFTER_CREATECATEGORY, $categoryEvent);
// Substitute _ID_ in the URL with the ID of the created category
$successUrl = str_replace('_ID_', $category->getId(), $categoryCreationForm->getSuccessUrl());
// Redirect to the success URL
$this->redirect($successUrl);
} catch (PropelException $e) {
Tlog::getInstance()->error(sprintf('error during creating category with message "%s"', $e->getMessage()));
$message = "Failed to create this category, please try again.";
}
// The form has errors, propagate it.
$this->propagateFormError($categoryCreationForm, $message, $event);
$event->getDispatcher()->dispatch(TheliaEvents::AFTER_CREATECATEGORY, $event);
}
public function modify(ActionEvent $event)
public function modify(CategoryChangeEvent $event)
{
$this->checkAuth("ADMIN", "admin.category.change");
$this->checkAuth("ADMIN", "admin.category.delete");
$request = $event->getRequest();
$customerModification = new CustomerModification($request);
$form = $customerModification->getForm();
if ($request->isMethod("post")) {
$form->bind($request);
if ($form->isValid()) {
$data = $form->getData();
$customer = CustomerQuery::create()->findPk(1);
try {
$customerEvent = new CustomerEvent($customer);
$event->getDispatcher()->dispatch(TheliaEvents::BEFORE_CHANGECUSTOMER, $customerEvent);
$data = $form->getData();
$customer->createOrUpdate(
$data["title"],
$data["firstname"],
$data["lastname"],
$data["address1"],
$data["address2"],
$data["address3"],
$data["phone"],
$data["cellphone"],
$data["zipcode"],
$data["country"]
);
$customerEvent->customer = $customer;
$event->getDispatcher()->dispatch(TheliaEvents::AFTER_CHANGECUSTOMER, $customerEvent);
// Update the logged-in user, and redirect to the success URL (exits)
// We don-t send the login event, as the customer si already logged.
$this->processSuccessfullLogin($event, $customer, $customerModification);
} catch (PropelException $e) {
Tlog::getInstance()->error(sprintf('error during modifying customer on action/modifyCustomer with message "%s"', $e->getMessage()));
$message = "Failed to change your account, please try again.";
}
} else {
$message = "Missing or invalid data";
}
} else {
$message = "Wrong form method !";
}
// The form has an error
$customerModification->setError(true);
$customerModification->setErrorMessage($message);
// Dispatch the errored form
$event->setErrorForm($customerModification);
// TODO !!
}
/**
@@ -159,50 +71,22 @@ class Category extends BaseAction implements EventSubscriberInterface
*
* @param ActionEvent $event
*/
public function delete(ActionEvent $event)
public function delete(CategoryDeleteEvent $event)
{
$this->checkAuth("ADMIN", "admin.category.delete");
$request = $event->getRequest();
$category = CategoryQuery::create()->findPk($event->getId());
try {
$categoryDeletionForm = new CategoryDeletionForm($request);
if ($category !== null) {
$form = $this->validateForm($categoryDeletionForm, "POST");
$event->setDeletedCategory($category);
$data = $form->getData();
$category = CategoryQuery::create()->findPk($data['id']);
$categoryEvent = new CategoryEvent($category);
$event->getDispatcher()->dispatch(TheliaEvents::BEFORE_DELETECATEGORY, $categoryEvent);
$event->getDispatcher()->dispatch(TheliaEvents::BEFORE_DELETECATEGORY, $event);
$category->delete();
AdminLog::append(sprintf("Category %s (ID %s) deleted", $category->getTitle(), $category->getId()), $request, $request->getSession()->getAdminUser());
$categoryEvent->category = $category;
$event->getDispatcher()->dispatch(TheliaEvents::AFTER_DELETECATEGORY, $categoryEvent);
// Substitute _ID_ in the URL with the ID of the created category
$successUrl = str_replace('_ID_', $category->getParent(), $categoryDeletionForm->getSuccessUrl());
// Redirect to the success URL
Redirect::exec($successUrl);
} catch (PropelException $e) {
\Thelia\Log\Tlog::getInstance()->error(sprintf('error during deleting category ID=%s on action/modifyCustomer with message "%s"', $data['id'], $e->getMessage()));
$message = "Failed to change your account, please try again.";
} catch (FormValidationException $e) {
$message = $e->getMessage();
$event->getDispatcher()->dispatch(TheliaEvents::AFTER_DELETECATEGORY, $event);
}
$this->propagateFormError($categoryDeletionForm, $message, $event);
}
/**
@@ -210,63 +94,55 @@ class Category extends BaseAction implements EventSubscriberInterface
*
* @param ActionEvent $event
*/
public function toggleVisibility(ActionEvent $event)
public function toggleVisibility(CategoryToggleVisibilityEvent $event)
{
$this->checkAuth("ADMIN", "admin.category.edit");
$request = $event->getRequest();
$category = CategoryQuery::create()->findPk($request->get('category_id', 0));
$category = CategoryQuery::create()->findPk($event->getId());
if ($category !== null) {
$event->setCategory($category);
$event->getDispatcher()->dispatch(TheliaEvents::BEFORE_CHANGECATEGORY, $event);
$category->setVisible($category->getVisible() ? false : true);
$category->save();
$categoryEvent = new CategoryEvent($category);
$event->getDispatcher()->dispatch(TheliaEvents::AFTER_CHANGECATEGORY, $categoryEvent);
$event->setCategory($category);
$event->getDispatcher()->dispatch(TheliaEvents::AFTER_CHANGECATEGORY, $event);
}
}
/**
* Move category up
* Changes category position, selecting absolute ou relative change.
*
* @param ActionEvent $event
* @param CategoryChangePositionEvent $event
*/
public function changePositionUp(ActionEvent $event)
public function changePosition(CategoryChangePositionEvent $event)
{
return $this->exchangePosition($event, 'up');
}
$this->checkAuth("ADMIN", "admin.category.edit");
/**
* Move category down
*
* @param ActionEvent $event
*/
public function changePositionDown(ActionEvent $event)
{
return $this->exchangePosition($event, 'down');
if ($event->getMode() == CategoryChangePositionEvent::POSITION_ABSOLUTE)
return $this->changeAbsolutePosition($event);
else
return $this->exchangePosition($event);
}
/**
* Move up or down a category
*
* @param ActionEvent $event
* @param string $direction up to move up, down to move down
* @param CategoryChangePositionEvent $event
*/
protected function exchangePosition(ActionEvent $event, $direction)
protected function exchangePosition(CategoryChangePositionEvent $event)
{
$this->checkAuth("ADMIN", "admin.category.edit");
$request = $event->getRequest();
$category = CategoryQuery::create()->findPk($request->get('category_id', 0));
$category = CategoryQuery::create()->findPk($event->getId());
if ($category !== null) {
$event->setCategory($category);
$event->getDispatcher()->dispatch(TheliaEvents::BEFORE_CHANGECATEGORY, $event);
// The current position of the category
$my_position = $category->getPosition();
@@ -275,10 +151,10 @@ class Category extends BaseAction implements EventSubscriberInterface
->filterByParent($category->getParent());
// Up or down ?
if ($direction == 'up') {
if ($event->getMode() == CategoryChangePositionEvent::POSITION_UP) {
// Find the category immediately before me
$search->filterByPosition(array('max' => $my_position-1))->orderByPosition(Criteria::DESC);
} elseif ($direction == 'down') {
} elseif ($event->getMode() == CategoryChangePositionEvent::POSITION_DOWN) {
// Find the category immediately after me
$search->filterByPosition(array('min' => $my_position+1))->orderByPosition(Criteria::ASC);
} else
@@ -304,26 +180,30 @@ class Category extends BaseAction implements EventSubscriberInterface
$cnx->rollback();
}
}
$event->setCategory($category);
$event->getDispatcher()->dispatch(TheliaEvents::AFTER_CHANGECATEGORY, $event);
}
}
/**
* Changes category position
*
* @param ActionEvent $event
* @param CategoryChangePositionEvent $event
*/
public function changePosition(ActionEvent $event)
protected function changeAbsolutePosition(CategoryChangePositionEvent $event)
{
$this->checkAuth("ADMIN", "admin.category.edit");
$request = $event->getRequest();
$category = CategoryQuery::create()->findPk($request->get('category_id', 0));
$category = CategoryQuery::create()->findPk($event->getId());
if ($category !== null) {
$event->setCategory($category);
$event->getDispatcher()->dispatch(TheliaEvents::BEFORE_CHANGECATEGORY, $event);
// The required position
$new_position = $request->get('position', null);
$new_position = $event->getPosition();
// The current position
$current_position = $category->getPosition();
@@ -363,6 +243,9 @@ class Category extends BaseAction implements EventSubscriberInterface
$cnx->rollback();
}
}
$event->setCategory($category);
$event->getDispatcher()->dispatch(TheliaEvents::AFTER_CHANGECATEGORY, $event);
}
}
@@ -389,12 +272,14 @@ class Category extends BaseAction implements EventSubscriberInterface
public static function getSubscribedEvents()
{
return array(
"action.createCategory" => array("create", 128),
"action.modifyCategory" => array("modify", 128),
"action.deleteCategory" => array("delete", 128),
TheliaEvents::CATEGORY_CREATE => array("create", 128),
TheliaEvents::CATEGORY_MODIFY => array("modify", 128),
TheliaEvents::CATEGORY_DELETE => array("delete", 128),
"action.toggleCategoryVisibility" => array("toggleVisibility", 128),
"action.changeCategoryPositionUp" => array("changePositionUp", 128),
TheliaEvents::CATEGORY_TOGGLE_VISIBILITY => array("toggleVisibility", 128),
TheliaEvents::CATEGORY_CHANGE_POSITION => array("changePosition", 128),
"action.changeCategoryPositionU" => array("changePositionUp", 128),
"action.changeCategoryPositionDown" => array("changePositionDown", 128),
"action.changeCategoryPosition" => array("changePosition", 128),
);

6
core/lib/Thelia/Action/Customer.php
View File

@@ -96,7 +96,7 @@ class Customer extends BaseAction implements EventSubscriberInterface
{
$event->getDispatcher()->dispatch(TheliaEvents::CUSTOMER_LOGOUT, $event);
$this->getFrontSecurityContext()->clear();
$this->getSecurityContext()->clearCustomerUser();
}
public function changePassword(ActionEvent $event)
@@ -127,8 +127,8 @@ class Customer extends BaseAction implements EventSubscriberInterface
public static function getSubscribedEvents()
{
return array(
"action.createCustomer" => array("create", 128),
"action.modifyCustomer" => array("modify", 128),
TheliaEvents::CUSTOMER_CREATEACCOUNT => array("create", 128),
TheliaEvents::CUSTOMER_UPDATEACCOUNT => array("modify", 128),
);
}
}

19
core/lib/Thelia/Cart/CartTrait.php
View File

@@ -28,8 +28,8 @@ use Thelia\Model\ConfigQuery;
use Thelia\Model\Customer;
use Symfony\Component\HttpFoundation\Request;
use Thelia\Core\HttpFoundation\Session\Session;
use Thelia\Core\Event\Internal\CartEvent;
use Thelia\Core\Event\TheliaEvents;
use Thelia\Core\Event\CartEvent;
trait CartTrait
{
@@ -42,8 +42,9 @@ trait CartTrait
*/
public function getCart(Request $request)
{
$session = $request->getSession();
if (null !== $cart = $request->getSession()->getCart()) {
if (null !== $cart = $session->getCart()) {
return $cart;
}
@@ -55,26 +56,26 @@ trait CartTrait
if ($cart) {
//le panier existe en base
$customer = $request->getSession()->getCustomerUser();
$customer = $session->getCustomerUser();
if ($customer) {
if ($cart->getCustomerId() != $customer->getId()) {
//le customer du panier n'est pas le mm que celui connecté, il faut cloner le panier sans le customer_id
$cart = $this->duplicateCart($cart, $request->getSession(), $customer);
$cart = $this->duplicateCart($cart, $session, $customer);
}
} else {
if ($cart->getCustomerId() != null) {
//il faut dupliquer le panier sans le customer_id
$cart = $this->duplicateCart($cart, $request->getSession());
$cart = $this->duplicateCart($cart, $session);
}
}
} else {
$cart = $this->createCart($request->getSession());
$cart = $this->createCart($session);
}
} else {
//le cookie de panier n'existe pas, il va falloir le créer et faire un enregistrement en base.
$cart = $this->createCart($request->getSession());
$cart = $this->createCart($session);
}
return $cart;
@@ -116,7 +117,7 @@ trait CartTrait
$cartEvent = new CartEvent($newCart);
$this->getDispatcher()->dispatch(TheliaEvents::CART_DUPLICATE, $cartEvent);
return $cartEvent->cart;
return $cartEvent->getCart();
}
protected function generateCookie()
@@ -131,4 +132,4 @@ trait CartTrait
return $id;
}
}
}

10
core/lib/Thelia/Config/Resources/action.xml
View File

@@ -22,16 +22,16 @@
<tag name="kernel.event_subscriber"/>
</service>
<service id="thelia.action.category" class="Thelia\Action\Category">
<argument type="service" id="service_container"/>
<tag name="kernel.event_subscriber"/>
</service>
<service id="thelia.action.category" class="Thelia\Action\Image">
<argument type="service" id="service_container"/>
<tag name="kernel.event_subscriber"/>
</service>
<service id="thelia.action.customer" class="Thelia\Action\Category">
<argument type="service" id="service_container"/>
<tag name="kernel.event_subscriber"/>
</service>
</services>
</config>

2
core/lib/Thelia/Config/Resources/config.xml
View File

@@ -85,8 +85,6 @@
<argument type="service" id="request" />
</service>
<service id="thelia.envContext" class="Thelia\Core\Context"/>
<!-- Parser context -->
<service id="thelia.parser.context" class="Thelia\Core\Template\ParserContext" scope="request">

11
core/lib/Thelia/Controller/Admin/BaseAdminController.php
View File

@@ -30,11 +30,22 @@ use Symfony\Component\HttpKernel\HttpKernelInterface;
use Thelia\Core\Security\Exception\AuthenticationException;
use Thelia\Tools\URL;
use Thelia\Tools\Redirect;
use Thelia\Core\Security\SecurityContext;
use Thelia\Model\AdminLog;
class BaseAdminController extends BaseController
{
const TEMPLATE_404 = "404";
/**
* Helper to append a message to the admin log.
*
* @param unknown $message
*/
public function adminLogAppend($message) {
AdminLog::append($message, $this->getRequest(), $this->getSecurityContext()->getAdminUser());
}
public function processTemplateAction($template)
{
try {

106
core/lib/Thelia/Controller/Admin/CategoryController.php
View File

@@ -25,12 +25,52 @@ namespace Thelia\Controller\Admin;
use Thelia\Core\Security\Exception\AuthenticationException;
use Thelia\Core\Security\Exception\AuthorizationException;
use Thelia\Log\Tlog;
use Thelia\Core\Event\TheliaEvents;
use Thelia\Core\Event\CategoryCreateEvent;
use Thelia\Form\CategoryCreationForm;
use Thelia\Core\Event\CategoryDeleteEvent;
use Thelia\Core\Event\CategoryToggleVisibilityEvent;
use Thelia\Core\Event\CategoryChangePositionEvent;
use Thelia\Form\CategoryDeletionForm;
class CategoryController extends BaseAdminController
{
protected function createNewCategory($args)
{
$this->dispatchEvent("createCategory");
try {
$categoryCreationForm = new CategoryCreationForm($this->getRequest());
$form = $this->validateForm($categoryCreationForm, "POST");
$data = $form->getData();
$categoryCreateEvent = new CategoryCreateEvent(
$data["title"],
$data["parent"],
$data["locale"]
);
$this->dispatch(TheliaEvents::CATEGORY_CREATE, $categoryCreateEvent);
$category = $categoryCreateEvent->getCreatedCategory();
$this->adminLogAppend(sprintf("Category %s (ID %s) created", $category->getTitle(), $category->getId()));
// Substitute _ID_ in the URL with the ID of the created category
$successUrl = str_replace('_ID_', $category->getId(), $categoryCreationForm->getSuccessUrl());
// Redirect to the success URL
$this->redirect($successUrl);
}
catch (FormValidationException $e) {
$categoryCreationForm->setErrorMessage($e->getMessage());
$this->getParserContext()->setErrorForm($categoryCreationForm);
}
catch (Exception $e) {
Tlog::getInstance()->error(sprintf("Failed to create category: %s", $e->getMessage()));
$this->getParserContext()->setGeneralError($e->getMessage());
}
// At this point, the form has error, and should be redisplayed.
return $this->render('categories', $args);
@@ -45,9 +85,35 @@ class CategoryController extends BaseAdminController
protected function deleteCategory($args)
{
$this->dispatchEvent("deleteCategory");
try {
$categoryDeletionForm = new CategoryDeletionForm($this->getRequest());
// Something was wrong, category was not deleted. Display parent category list
$data = $this->validateForm($categoryDeletionForm, "POST")->getData();
var_dump($data);
$categoryDeleteEvent = new CategoryDeleteEvent($data['category_id']);
$this->dispatch(TheliaEvents::CATEGORY_DELETE, $categoryDeleteEvent);
$category = $categoryDeleteEvent->getDeletedCategory();
$this->adminLogAppend(sprintf("Category %s (ID %s) deleted", $category->getTitle(), $category->getId()));
// Substitute _ID_ in the URL with the ID of the created category
$successUrl = str_replace('_ID_', $categoryDeleteEvent->getDeletedCategory()->getId(), $categoryDeletionForm->getSuccessUrl());
// Redirect to the success URL
$this->redirect($successUrl);
}
catch (FormValidationException $e) {
$categoryDeletionForm->setErrorMessage($e->getMessage());
$this->getParserContext()->setErrorForm($categoryDeletionForm);
}
catch (Exception $e) {
Tlog::getInstance()->error(sprintf("Failed to delete category: %s", $e->getMessage()));
$this->getParserContext()->setGeneralError($e->getMessage());
}
// At this point, something was wrong, category was not deleted. Display parent category list
return $this->render('categories', $args);
}
@@ -60,28 +126,48 @@ class CategoryController extends BaseAdminController
protected function visibilityToggle($args)
{
$this->dispatchEvent("toggleCategoryVisibility");
$event = new CategoryToggleVisibilityEvent($this->getRequest()->get('category_id', 0));
$this->dispatch(TheliaEvents::CATEGORY_TOGGLE_VISIBILITY, $event);
return $this->nullResponse();
}
protected function changePosition($args)
{
$this->dispatchEvent("changeCategoryPosition");
$request = $this->getRequest();
$event = new CategoryChangePositionEvent(
$request->get('category_id', 0),
CategoryChangePositionEvent::POSITION_ABSOLUTE,
$request->get('position', null)
);
$this->dispatch(TheliaEvents::CATEGORY_CHANGE_POSITION, $event);
return $this->render('categories', $args);
}
protected function positionDown($args)
{
$this->dispatchEvent("changeCategoryPositionDown");
$event = new CategoryChangePositionEvent(
$this->getRequest()->get('category_id', 0),
CategoryChangePositionEvent::POSITION_DOWN
);
$this->dispatch(TheliaEvents::CATEGORY_CHANGE_POSITION, $event);
return $this->render('categories', $args);
}
protected function positionUp($args)
{
$this->dispatchEvent("changeCategoryPositionUp");
$event = new CategoryChangePositionEvent(
$this->getRequest()->get('category_id', 0),
CategoryChangePositionEvent::POSITION_UP
);
$this->dispatch(TheliaEvents::CATEGORY_CHANGE_POSITION, $event);
return $this->render('categories', $args);
}
@@ -138,9 +224,11 @@ class CategoryController extends BaseAdminController
return $this->positionDown($args);
}
} catch (AuthorizationException $ex) {
}
catch (AuthorizationException $ex) {
return $this->errorPage($ex->getMessage());
} catch (AuthenticationException $ex) {
}
catch (AuthenticationException $ex) {
return $this->errorPage($ex->getMessage());
}

4
core/lib/Thelia/Controller/Admin/SessionController.php
View File

@@ -43,7 +43,7 @@ class SessionController extends BaseAdminController
{
$this->dispatch(TheliaEvents::ADMIN_LOGOUT);
$this->getSecurityContext()->clear();
$this->getSecurityContext()->clearAdminUser();
// Go back to login page.
return Redirect::exec(URL::absoluteUrl('/admin/login')); // FIXME - should be a parameter
@@ -61,7 +61,7 @@ class SessionController extends BaseAdminController
$user = $authenticator->getAuthentifiedUser();
// Success -> store user in security context
$this->getSecurityContext()->setUser($user);
$this->getSecurityContext()->setAdminUser($user);
// Log authentication success
AdminLog::append("Authentication successful", $request, $user);

39
core/lib/Thelia/Controller/BaseController.php
View File

@@ -34,6 +34,7 @@ use Symfony\Component\EventDispatcher\EventDispatcher;
use Thelia\Core\Factory\ActionEventFactory;
use Thelia\Form\BaseForm;
use Thelia\Form\Exception\FormValidationException;
use Symfony\Component\EventDispatcher\Event;
/**
*
@@ -56,34 +57,12 @@ class BaseController extends ContainerAware
}
/**
* Create an action event
* Dispatch a Thelia event
*
* @param string $action
* @return EventDispatcher
* @param string $eventName a TheliaEvent name, as defined in TheliaEvents class
* @param Event $event the event
*/
protected function dispatchEvent($action)
{
// Create the
$eventFactory = new ActionEventFactory($this->getRequest(), $action, $this->container->getParameter("thelia.actionEvent"));
$actionEvent = $eventFactory->createActionEvent();
$this->dispatch("action.$action", $actionEvent);
if ($actionEvent->hasErrorForm()) {
$this->getParserContext()->setErrorForm($actionEvent->getErrorForm());
}
return $actionEvent;
}
/**
* Dispatch a Thelia event to modules
*
* @param string $eventName a TheliaEvent name, as defined in TheliaEvents class
* @param ActionEvent $event the event
*/
protected function dispatch($eventName, ActionEvent $event = null)
protected function dispatch($eventName, Event $event = null)
{
$this->getDispatcher()->dispatch($eventName, $event);
}
@@ -113,13 +92,9 @@ class BaseController extends ContainerAware
*
* @return \Thelia\Core\Security\SecurityContext
*/
protected function getSecurityContext($context = false)
protected function getSecurityContext()
{
$securityContext = $this->container->get('thelia.securityContext');
$securityContext->setContext($context === false ? SecurityContext::CONTEXT_BACK_OFFICE : $context);
return $securityContext;
return $this->container->get('thelia.securityContext');
}
/**

13
core/lib/Thelia/Controller/Front/CustomerController.php
View File

@@ -36,6 +36,7 @@ use Thelia\Form\CustomerModification;
use Thelia\Form\Exception\FormValidationException;
use Thelia\Model\Customer;
use Thelia\Core\Event\TheliaEvents;
use Thelia\Core\Event\CustomerEvent;
class CustomerController extends BaseFrontController
{
@@ -76,7 +77,7 @@ class CustomerController extends BaseFrontController
try {
$customer = $this->getSecurityContext(SecurityContext::CONTEXT_FRONT_OFFICE)->getUser();
$customer = $this->getSecurityContext()->getCustomerUser();
$form = $this->validateForm($customerModification, "post");
@@ -116,9 +117,7 @@ class CustomerController extends BaseFrontController
try {
$customer = $authenticator->getAuthentifiedUser();
$customerLoginEvent = new CustomerLoginEvent($customer);
$this->processLogin($customer, $customerLoginEvent);
$this->processLogin($customer);
$this->redirectSuccess();
} catch (ValidatorException $e) {
@@ -132,11 +131,11 @@ class CustomerController extends BaseFrontController
}
}
public function processLogin(Customer $customer,$event = null)
public function processLogin(Customer $customer)
{
$this->getSecurityContext(SecurityContext::CONTEXT_FRONT_OFFICE)->setUser($customer);
$this->getSecurityContext()->setCustomerUser($customer);
if($event) $this->dispatch(TheliaEvents::CUSTOMER_LOGIN, $event);
if($event) $this->dispatch(TheliaEvents::CUSTOMER_LOGIN, new CustomerLoginEvent($customer));
}
/**

47
core/lib/Thelia/Core/Event/ActionEvent.php
View File

@@ -35,27 +35,8 @@ use Thelia\Form\BaseForm;
*/
abstract class ActionEvent extends Event
{
/**
*
* @var Symfony\Component\HttpFoundation\Request
*/
protected $request;
protected $errorForm = null;
protected $parameters = array();
/**
*
* @param \Symfony\Component\HttpFoundation\Request $request
* @param string $action
*/
public function __construct(Request $request)
{
$this->request = $request;
}
public function __set($name, $value)
{
$this->parameters[$name] = $value;
@@ -69,30 +50,4 @@ abstract class ActionEvent extends Event
return null;
}
/**
*
* @return \Symfony\Component\HttpFoundation\Request
*/
public function getRequest()
{
return $this->request;
}
public function setErrorForm(BaseForm $form)
{
$this->errorForm = $form;
if ($form != null) $this->stopPropagation();
}
public function getErrorForm()
{
return $this->errorForm;
}
public function hasErrorForm()
{
return $this->errorForm != null ? true : false;
}
}
}

2
core/lib/Thelia/Core/Event/CartItemEvent.php
View File

@@ -25,7 +25,7 @@ namespace Thelia\Core\Event;
use Thelia\Model\CartItem;
class CartItemEvent extends InternalEvent
class CartItemEvent extends ActionEvent
{
protected $cartItem;

68
core/lib/Thelia/Core/Context.php → core/lib/Thelia/Core/Event/CategoryChangePositionEvent.php Executable file → Normal file
View File

@@ -21,34 +21,64 @@
/* */
/*************************************************************************************/
namespace Thelia\Core;
namespace Thelia\Core\Event;
use Thelia\Model\Category;
class Context
class CategoryChangePositionEvent extends ActionEvent
{
const CONTEXT_FRONT_OFFICE = 'front';
const CONTEXT_BACK_OFFICE = 'admin';
const POSITION_UP = 1;
const POSITION_DOWN = 2;
const POSITION_ABSOLUTE = 3;
protected $defineContext = array(
self::CONTEXT_BACK_OFFICE,
self::CONTEXT_FRONT_OFFICE
);
protected $id;
protected $mode;
protected $position;
protected $category;
protected $currentContext = self::CONTEXT_FRONT_OFFICE;
public function isValidContext($context)
public function __construct($id, $mode, $position = null)
{
return in_array($context, $this->defineContext);
$this->id = $id;
$this->mode = $mode;
$this->position = $position;
}
public function setContext($context)
public function getId()
{
if ($this->isValidContext($context)) {
$this->currentContext = $context;
}
return $this->id;
}
public function getContext()
public function setId($id)
{
return $this->currentContext;
$this->id = $id;
}
}
public function getMode()
{
return $this->mode;
}
public function setMode($mode)
{
$this->mode = $mode;
}
public function getPosition()
{
return $this->position;
}
public function setPosition($position)
{
$this->position = $position;
}
public function getCategory()
{
return $this->category;
}
public function setCategory($category)
{
$this->category = $category;
}
}

64
core/lib/Thelia/Core/Event/Internal/InternalEvent.php → core/lib/Thelia/Core/Event/CategoryCreateEvent.php Executable file → Normal file
View File

@@ -21,16 +21,62 @@
/* */
/*************************************************************************************/
namespace Thelia\Core\Event\Internal;
namespace Thelia\Core\Event;
use Symfony\Component\EventDispatcher\Event;
use Thelia\Model\Category;
/**
* Base class used for internal event like creating new Customer, adding item to cart, etc
*
* Class InternalEvent
* @package Thelia\Core\Event
*/
abstract class InternalEvent extends Event
class CategoryCreateEvent extends ActionEvent
{
protected $title;
protected $parent;
protected $locale;
protected $created_category;
public function __construct($title, $parent, $locale)
{
$this->title = $title;
$this->parent = $parent;
$this->locale = $locale;
}
public function getTitle()
{
return $this->title;
}
public function setTitle($title)
{
$this->title = $title;
}
public function getParent()
{
return $this->parent;
}
public function setParent($parent)
{
$this->parent = $parent;
}
public function getLocale()
{
return $this->locale;
}
public function setLocale($locale)
{
$this->locale = $locale;
}
public function getCreatedCategory()
{
return $this->created_category;
}
public function setCreatedCategory(Category $created_category)
{
$this->created_category = $created_category;
var_dump($this->created_category);
}
}

33
core/lib/Thelia/Core/Event/Internal/CartEvent.php → core/lib/Thelia/Core/Event/CategoryDeleteEvent.php Executable file → Normal file
View File

@@ -21,17 +21,36 @@
/* */
/*************************************************************************************/
namespace Thelia\Core\Event\Internal;
namespace Thelia\Core\Event;
use Thelia\Model\Category;
use Thelia\Model\Cart;
class CartEvent extends InternalEvent
class CategoryDeleteEvent extends ActionEvent
{
public $cart;
protected $id;
protected $deleted_category;
public function __construct(Cart $cart)
public function __construct($id)
{
$this->cart = $cart;
$this->id = $id;
}
public function getId()
{
return $this->id;
}
public function setId($id)
{
$this->id = $id;
}
public function getDeletedCategory()
{
return $this->deleted_category;
}
public function setDeletedCategory(Category $deleted_category)
{
$this->deleted_category = $deleted_category;
}
}

30
core/lib/Thelia/Core/Event/CategoryEvent.php → core/lib/Thelia/Core/Event/CategoryToggleVisibilityEvent.php Executable file → Normal file
View File

@@ -22,15 +22,35 @@
/*************************************************************************************/
namespace Thelia\Core\Event;
use Thelia\Model\Category;
class CategoryEvent extends InternalEvent
class CategoryToggleVisibilityEvent extends ActionEvent
{
public $category;
protected $id;
protected $category;
public function __construct(Category $category)
public function __construct($id)
{
$this->id = $id;
}
public function getId()
{
return $this->id;
}
public function setId($id)
{
$this->id = $id;
}
public function getCategory()
{
return $this->category;
}
public function setCategory(Category $category)
{
$this->category = $category;
}
}
}

5
core/lib/Thelia/Core/Event/Internal/CustomerEvent.php → core/lib/Thelia/Core/Event/CustomerEvent.php
View File

@@ -21,11 +21,12 @@
/* */
/*************************************************************************************/
namespace Thelia\Core\Event\Internal;
namespace Thelia\Core\Event;
use Thelia\Model\Customer;
use Thelia\Core\Event\ActionEvent;
class CustomerEvent extends InternalEvent
class CustomerEvent extends ActionEvent
{
public $customer;

24
core/lib/Thelia/Core/Event/TheliaEvents.php
View File

@@ -94,11 +94,29 @@ final class TheliaEvents
*/
const AFTER_CHANGECUSTOMER = "action.after_changecustomer";
/**
* Sent once the category creation form has been successfully validated, and before category insertion in the database.
*/
const BEFORE_CREATECATEGORY = "action.before_createcategory";
/**
* Create, change or delete a category
*/
const CATEGORY_CREATE = "action.createCategory";
const CATEGORY_MODIFY = "action.modifyCategory";
const CATEGORY_DELETE = "action.deleteCategory";
/**
* Toggle category visibility
*/
const CATEGORY_TOGGLE_VISIBILITY = "action.toggleCategoryVisibility";
/**
* Change category position
*/
const CATEGORY_CHANGE_POSITION = "action.changeCategoryPosition";
/**
* Sent just after a successful insert of a new category in the database.
*/
@@ -113,6 +131,11 @@ final class TheliaEvents
*/
const AFTER_DELETECATEGORY = "action.after_deletecategory";
/**
* Sent just before a successful change of a category in the database.
*/
const BEFORE_CHANGECATEGORY = "action.before_changecategory";
/**
* Sent just after a successful change of a category in the database.
*/
@@ -154,5 +177,4 @@ final class TheliaEvents
* Sent on cimage cache clear request
*/
const IMAGE_CLEAR_CACHE = "action.clearImageCache";
}

177
core/lib/Thelia/Core/Security/SecurityContext.php
View File

@@ -33,36 +33,11 @@ use Thelia\Core\HttpFoundation\Request;
*/
class SecurityContext
{
const CONTEXT_FRONT_OFFICE = 'front';
const CONTEXT_BACK_OFFICE = 'admin';
private $request;
private $context;
public function __construct(Request $request)
{
$this->request = $request;
$this->context = null;
}
public function setContext($context)
{
if ($context !== self::CONTEXT_FRONT_OFFICE && $context !== self::CONTEXT_BACK_OFFICE) {
throw new \InvalidArgumentException(sprintf("Invalid or empty context identifier '%s'", $context));
}
$this->context = $context;
return $this;
}
public function getContext($exception_if_context_undefined = false)
{
if (null === $this->context && $exception_if_context_undefined === true)
throw new \LogicException("No context defined. Please use setContext() first.");
return $this->context;
}
private function getSession()
@@ -76,28 +51,47 @@ class SecurityContext
}
/**
* Gets the currently authenticated user in the current context, or null if none is defined
* Gets the currently authenticated user in the admin, or null if none is defined
*
* @return UserInterface|null A UserInterface instance or null if no user is available
*/
public function getUser()
public function getAdminUser()
{
$context = $this->getContext(true);
if ($context === self::CONTEXT_FRONT_OFFICE)
$user = $this->getSession()->getCustomerUser();
else if ($context == self::CONTEXT_BACK_OFFICE)
$user = $this->getSession()->getAdminUser();
else
$user = null;
return $user;
return $this->getSession()->getAdminUser();
}
final public function isAuthenticated()
/**
* Gets the currently authenticated customer, or null if none is defined
*
* @return UserInterface|null A UserInterface instance or null if no user is available
*/
public function getCustomerUser()
{
if (null !== $this->getUser()) {
return true;
return $this->getSession()->getCustomerUser();
}
/**
* Check if a user has at least one of the required roles
*
* @param UserInterface $user the user
* @param array $roles the roles
* @return boolean true if the user has the required role, false otherwise
*/
final public function hasRequiredRole($user, array $roles) {
if ($user != null) {
// Check if user's roles matches required roles
$userRoles = $user->getRoles();
$roleFound = false;
foreach ($userRoles as $role) {
if (in_array($role, $roles)) {
$roleFound = true;
return true;
}
}
}
return false;
@@ -110,85 +104,88 @@ class SecurityContext
*/
final public function isGranted(array $roles, array $permissions)
{
if ($this->isAuthenticated() === true) {
// Find a user which matches the required roles.
$user = $this->getCustomerUser();
$user = $this->getUser();
if (! $this->hasRequiredRole($user, $roles)) {
$user = $this->getAdminUser();
// Check if user's roles matches required roles
$userRoles = $user->getRoles();
if (! $this->hasRequiredRole($user, $roles)) {
$user = null;
}
}
$roleFound = false;
if ($user != null) {
foreach ($userRoles as $role) {
if (in_array($role, $roles)) {
$roleFound = true;
break;
}
if (empty($permissions)) {
return true;
}
if ($roleFound) {
// Get permissions from profile
// $userPermissions = $user->getPermissions(); FIXME
if (empty($permissions)) {
return true;
}
// TODO: Finalize permissions system !;
// Get permissions from profile
// $userPermissions = $user->getPermissions(); FIXME
$userPermissions = array('*'); // FIXME !
// TODO: Finalize permissions system !;
$permissionsFound = true;
$userPermissions = array('*'); // FIXME !
// User have all permissions ?
if (in_array('*', $userPermissions))
return true;
$permissionsFound = true;
// Check that user's permissions matches required permissions
foreach ($permissions as $permission) {
if (! in_array($permission, $userPermissions)) {
$permissionsFound = false;
// User have all permissions ?
if (in_array('*', $userPermissions))
return true;
// Check that user's permissions matches required permissions
foreach ($permissions as $permission) {
if (! in_array($permission, $userPermissions)) {
$permissionsFound = false;
break;
}
}
return $permissionsFound;
break;
}
}
return $permissionsFound;
}
return false;
}
/**
* Sets the authenticated user.
* Sets the authenticated admin user.
*
* @param UserInterface $user A UserInterface, or null if no further user should be stored
*/
public function setUser(UserInterface $user)
public function setAdminUser(UserInterface $user)
{
$context = $this->getContext(true);
$user->eraseCredentials();
if ($context === self::CONTEXT_FRONT_OFFICE)
$this->getSession()->setCustomerUser($user);
else if ($context == self::CONTEXT_BACK_OFFICE)
$this->getSession()->setAdminUser($user);
$this->getSession()->setAdminUser($user);
}
/**
* Clear the user from the security context
* Sets the authenticated customer user.
*
* @param UserInterface $user A UserInterface, or null if no further user should be stored
*/
public function clear()
public function setCustomerUser(UserInterface $user)
{
$context = $this->getContext(true);
$user->eraseCredentials();
if ($context === self::CONTEXT_FRONT_OFFICE)
$this->getSession()->clearCustomerUser();
else if ($context == self::CONTEXT_BACK_OFFICE)
$this->getSession()->clearAdminUser();
$this->getSession()->setCustomerUser($user);
}
}
/**
* Clear the customer from the security context
*/
public function clearCustomerUser()
{
$this->getSession()->clearCustomerUser();
}
/**
* Clear the admin from the security context
*/
public function clearAdminUser()
{
$this->getSession()->clearAdminUser();
}
}

3
core/lib/Thelia/Core/Template/Loop/Auth.php
View File

@@ -68,15 +68,12 @@ class Auth extends BaseLoop
*/
public function exec(&$pagination)
{
$context = $this->getContext();
$roles = $this->_explode($this->getRoles());
$permissions = $this->_explode($this->getPermissions());
$loopResult = new LoopResult();
try {
$this->securityContext->setContext($context);
if (true === $this->securityContext->isGranted($roles, $permissions == null ? array() : $permissions)) {
// Create an empty row: loop is no longer empty :)

7
core/lib/Thelia/Core/Template/Smarty/Plugins/DataAccessFunctions.php
View File

@@ -52,7 +52,7 @@ class DataAccessFunctions extends AbstractSmartyPlugin
*/
public function adminDataAccess($params, &$smarty)
{
return $this->userDataAccess("Admin User", SecurityContext::CONTEXT_BACK_OFFICE, $params);
return $this->userDataAccess("Admin User", $this->securityContext->getAdminUser(), $params);
}
/**
@@ -64,7 +64,7 @@ class DataAccessFunctions extends AbstractSmartyPlugin
*/
public function customerDataAccess($params, &$smarty)
{
return $this->userDataAccess("Customer User", SecurityContext::CONTEXT_FRONT_OFFICE, $params);
return $this->userDataAccess("Customer User", $this->securityContext->getCustomerUser(), $params);
}
/**
@@ -75,12 +75,11 @@ class DataAccessFunctions extends AbstractSmartyPlugin
* @return string the value of the requested attribute
* @throws InvalidArgumentException if the object does not have the requested attribute.
*/
protected function userDataAccess($objectLabel, $context, $params)
protected function userDataAccess($objectLabel, $user, $params)
{
$attribute = $this->getNormalizedParam($params, array('attribute', 'attrib', 'attr'));
if (! empty($attribute)) {
$user = $this->securityContext->setContext($context)->getUser();
if (null != $user) {
$getter = sprintf("get%s", ucfirst($attribute));

5
core/lib/Thelia/Core/Template/Smarty/Plugins/Security.php
View File

@@ -46,11 +46,6 @@ class Security extends AbstractSmartyPlugin
*/
public function checkAuthFunction($params, &$smarty)
{
// Context: 'front' or 'admin'
$context = $this->getNormalizedParam($params, 'context');
$this->securityContext->setContext($context);
$roles = $this->_explode($this->getParam($params, 'roles'));
$permissions = $this->_explode($this->getParam($params, 'permissions'));

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
*

767
core/lib/Thelia/Model/Base/Rewriting.php → core/lib/Thelia/Model/Base/RewritingArgument.php Executable file → 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

1044
core/lib/Thelia/Model/Base/RewritingQuery.php
View File

File diff suppressed because it is too large Load Diff

2158
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/CartItem.php
View File

@@ -4,10 +4,10 @@ namespace Thelia\Model;
use Propel\Runtime\Connection\ConnectionInterface;
use Symfony\Component\EventDispatcher\EventDispatcherInterface;
use Thelia\Core\Event\Internal\CartEvent;
use Thelia\Core\Event\TheliaEvents;
use Thelia\Model\Base\CartItem as BaseCartItem;
use Thelia\Model\ConfigQuery;
use Thelia\Core\Event\CartEvent;
class CartItem extends BaseCartItem
{

2
core/lib/Thelia/Model/Customer.php
View File

@@ -3,7 +3,6 @@
namespace Thelia\Model;
use Symfony\Component\Config\Definition\Exception\Exception;
use Thelia\Core\Event\Internal\CustomerEvent;
use Thelia\Model\Base\Customer as BaseCustomer;
use Thelia\Model\Exception\InvalidArgumentException;
@@ -17,6 +16,7 @@ use Propel\Runtime\Connection\ConnectionInterface;
use Propel\Runtime\Propel;
use Thelia\Model\Map\CustomerTableMap;
use Thelia\Core\Security\Role\Role;
use Thelia\Core\Event\CustomerEvent;
/**
* Skeleton subclass for representing a row from the 'customer' table.

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();

184
core/lib/Thelia/Model/Map/RewritingTableMap.php → core/lib/Thelia/Model/Map/RewritingUrlTableMap.php Executable file → Normal file
View File

@@ -10,12 +10,12 @@ use Propel\Runtime\Exception\PropelException;
use Propel\Runtime\Map\RelationMap;
use Propel\Runtime\Map\TableMap;
use Propel\Runtime\Map\TableMapTrait;
use Thelia\Model\Rewriting;
use Thelia\Model\RewritingQuery;
use Thelia\Model\RewritingUrl;
use Thelia\Model\RewritingUrlQuery;
/**
* This class defines the structure of the 'rewriting' table.
* This class defines the structure of the 'rewriting_url' table.
*
*
*
@@ -25,14 +25,14 @@ use Thelia\Model\RewritingQuery;
* (i.e. if it's a text column type).
*
*/
class RewritingTableMap extends TableMap
class RewritingUrlTableMap extends TableMap
{
use InstancePoolTrait;
use TableMapTrait;
/**
* The (dot-path) name of this class
*/
const CLASS_NAME = 'Thelia.Model.Map.RewritingTableMap';
const CLASS_NAME = 'Thelia.Model.Map.RewritingUrlTableMap';
/**
* The default database name for this class
@@ -42,17 +42,17 @@ class RewritingTableMap extends TableMap
/**
* The table name for this class
*/
const TABLE_NAME = 'rewriting';
const TABLE_NAME = 'rewriting_url';
/**
* The related Propel class for this table
*/
const OM_CLASS = '\\Thelia\\Model\\Rewriting';
const OM_CLASS = '\\Thelia\\Model\\RewritingUrl';
/**
* A class that can be returned by this tableMap
*/
const CLASS_DEFAULT = 'Thelia.Model.Rewriting';
const CLASS_DEFAULT = 'Thelia.Model.RewritingUrl';
/**
* The total number of columns
@@ -72,42 +72,42 @@ class RewritingTableMap extends TableMap
/**
* the column name for the ID field
*/
const ID = 'rewriting.ID';
const ID = 'rewriting_url.ID';
/**
* the column name for the URL field
*/
const URL = 'rewriting.URL';
const URL = 'rewriting_url.URL';
/**
* the column name for the PRODUCT_ID field
* the column name for the VIEW field
*/
const PRODUCT_ID = 'rewriting.PRODUCT_ID';
const VIEW = 'rewriting_url.VIEW';
/**
* the column name for the CATEGORY_ID field
* the column name for the VIEW_ID field
*/
const CATEGORY_ID = 'rewriting.CATEGORY_ID';
const VIEW_ID = 'rewriting_url.VIEW_ID';
/**
* the column name for the FOLDER_ID field
* the column name for the VIEW_LOCALE field
*/
const FOLDER_ID = 'rewriting.FOLDER_ID';
const VIEW_LOCALE = 'rewriting_url.VIEW_LOCALE';
/**
* the column name for the CONTENT_ID field
* the column name for the REDIRECTED field
*/
const CONTENT_ID = 'rewriting.CONTENT_ID';
const REDIRECTED = 'rewriting_url.REDIRECTED';
/**
* the column name for the CREATED_AT field
*/
const CREATED_AT = 'rewriting.CREATED_AT';
const CREATED_AT = 'rewriting_url.CREATED_AT';
/**
* the column name for the UPDATED_AT field
*/
const UPDATED_AT = 'rewriting.UPDATED_AT';
const UPDATED_AT = 'rewriting_url.UPDATED_AT';
/**
* The default string format for model objects of the related table
@@ -121,11 +121,11 @@ class RewritingTableMap extends TableMap
* e.g. self::$fieldNames[self::TYPE_PHPNAME][0] = 'Id'
*/
protected static $fieldNames = array (
self::TYPE_PHPNAME => array('Id', 'Url', 'ProductId', 'CategoryId', 'FolderId', 'ContentId', 'CreatedAt', 'UpdatedAt', ),
self::TYPE_STUDLYPHPNAME => array('id', 'url', 'productId', 'categoryId', 'folderId', 'contentId', 'createdAt', 'updatedAt', ),
self::TYPE_COLNAME => array(RewritingTableMap::ID, RewritingTableMap::URL, RewritingTableMap::PRODUCT_ID, RewritingTableMap::CATEGORY_ID, RewritingTableMap::FOLDER_ID, RewritingTableMap::CONTENT_ID, RewritingTableMap::CREATED_AT, RewritingTableMap::UPDATED_AT, ),
self::TYPE_RAW_COLNAME => array('ID', 'URL', 'PRODUCT_ID', 'CATEGORY_ID', 'FOLDER_ID', 'CONTENT_ID', 'CREATED_AT', 'UPDATED_AT', ),
self::TYPE_FIELDNAME => array('id', 'url', 'product_id', 'category_id', 'folder_id', 'content_id', 'created_at', 'updated_at', ),
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, )
);
@@ -136,11 +136,11 @@ class RewritingTableMap extends TableMap
* e.g. self::$fieldKeys[self::TYPE_PHPNAME]['Id'] = 0
*/
protected static $fieldKeys = array (
self::TYPE_PHPNAME => array('Id' => 0, 'Url' => 1, 'ProductId' => 2, 'CategoryId' => 3, 'FolderId' => 4, 'ContentId' => 5, 'CreatedAt' => 6, 'UpdatedAt' => 7, ),
self::TYPE_STUDLYPHPNAME => array('id' => 0, 'url' => 1, 'productId' => 2, 'categoryId' => 3, 'folderId' => 4, 'contentId' => 5, 'createdAt' => 6, 'updatedAt' => 7, ),
self::TYPE_COLNAME => array(RewritingTableMap::ID => 0, RewritingTableMap::URL => 1, RewritingTableMap::PRODUCT_ID => 2, RewritingTableMap::CATEGORY_ID => 3, RewritingTableMap::FOLDER_ID => 4, RewritingTableMap::CONTENT_ID => 5, RewritingTableMap::CREATED_AT => 6, RewritingTableMap::UPDATED_AT => 7, ),
self::TYPE_RAW_COLNAME => array('ID' => 0, 'URL' => 1, 'PRODUCT_ID' => 2, 'CATEGORY_ID' => 3, 'FOLDER_ID' => 4, 'CONTENT_ID' => 5, 'CREATED_AT' => 6, 'UPDATED_AT' => 7, ),
self::TYPE_FIELDNAME => array('id' => 0, 'url' => 1, 'product_id' => 2, 'category_id' => 3, 'folder_id' => 4, 'content_id' => 5, 'created_at' => 6, 'updated_at' => 7, ),
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, )
);
@@ -154,18 +154,18 @@ class RewritingTableMap extends TableMap
public function initialize()
{
// attributes
$this->setName('rewriting');
$this->setPhpName('Rewriting');
$this->setClassName('\\Thelia\\Model\\Rewriting');
$this->setName('rewriting_url');
$this->setPhpName('RewritingUrl');
$this->setClassName('\\Thelia\\Model\\RewritingUrl');
$this->setPackage('Thelia.Model');
$this->setUseIdGenerator(false);
$this->setUseIdGenerator(true);
// columns
$this->addPrimaryKey('ID', 'Id', 'INTEGER', true, null, null);
$this->addColumn('URL', 'Url', 'VARCHAR', true, 255, null);
$this->addForeignKey('PRODUCT_ID', 'ProductId', 'INTEGER', 'product', 'ID', false, null, null);
$this->addForeignKey('CATEGORY_ID', 'CategoryId', 'INTEGER', 'category', 'ID', false, null, null);
$this->addForeignKey('FOLDER_ID', 'FolderId', 'INTEGER', 'folder', 'ID', false, null, null);
$this->addForeignKey('CONTENT_ID', 'ContentId', 'INTEGER', 'content', 'ID', false, null, 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()
@@ -175,10 +175,9 @@ class RewritingTableMap extends TableMap
*/
public function buildRelations()
{
$this->addRelation('Product', '\\Thelia\\Model\\Product', RelationMap::MANY_TO_ONE, array('product_id' => 'id', ), 'CASCADE', 'RESTRICT');
$this->addRelation('Category', '\\Thelia\\Model\\Category', RelationMap::MANY_TO_ONE, array('category_id' => 'id', ), 'CASCADE', 'RESTRICT');
$this->addRelation('Folder', '\\Thelia\\Model\\Folder', RelationMap::MANY_TO_ONE, array('folder_id' => 'id', ), 'CASCADE', 'RESTRICT');
$this->addRelation('Content', '\\Thelia\\Model\\Content', RelationMap::MANY_TO_ONE, array('content_id' => 'id', ), 'CASCADE', 'RESTRICT');
$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()
/**
@@ -193,6 +192,15 @@ class RewritingTableMap extends TableMap
'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.
@@ -250,7 +258,7 @@ class RewritingTableMap extends TableMap
*/
public static function getOMClass($withPrefix = true)
{
return $withPrefix ? RewritingTableMap::CLASS_DEFAULT : RewritingTableMap::OM_CLASS;
return $withPrefix ? RewritingUrlTableMap::CLASS_DEFAULT : RewritingUrlTableMap::OM_CLASS;
}
/**
@@ -264,21 +272,21 @@ class RewritingTableMap extends TableMap
*
* @throws PropelException Any exceptions caught during processing will be
* rethrown wrapped into a PropelException.
* @return array (Rewriting object, last column rank)
* @return array (RewritingUrl object, last column rank)
*/
public static function populateObject($row, $offset = 0, $indexType = TableMap::TYPE_NUM)
{
$key = RewritingTableMap::getPrimaryKeyHashFromRow($row, $offset, $indexType);
if (null !== ($obj = RewritingTableMap::getInstanceFromPool($key))) {
$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 + RewritingTableMap::NUM_HYDRATE_COLUMNS;
$col = $offset + RewritingUrlTableMap::NUM_HYDRATE_COLUMNS;
} else {
$cls = RewritingTableMap::OM_CLASS;
$cls = RewritingUrlTableMap::OM_CLASS;
$obj = new $cls();
$col = $obj->hydrate($row, $offset, false, $indexType);
RewritingTableMap::addInstanceToPool($obj, $key);
RewritingUrlTableMap::addInstanceToPool($obj, $key);
}
return array($obj, $col);
@@ -301,8 +309,8 @@ class RewritingTableMap extends TableMap
$cls = static::getOMClass(false);
// populate the object(s)
while ($row = $dataFetcher->fetch()) {
$key = RewritingTableMap::getPrimaryKeyHashFromRow($row, 0, $dataFetcher->getIndexType());
if (null !== ($obj = RewritingTableMap::getInstanceFromPool($key))) {
$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
@@ -311,7 +319,7 @@ class RewritingTableMap extends TableMap
$obj = new $cls();
$obj->hydrate($row);
$results[] = $obj;
RewritingTableMap::addInstanceToPool($obj, $key);
RewritingUrlTableMap::addInstanceToPool($obj, $key);
} // if key exists
}
@@ -332,21 +340,21 @@ class RewritingTableMap extends TableMap
public static function addSelectColumns(Criteria $criteria, $alias = null)
{
if (null === $alias) {
$criteria->addSelectColumn(RewritingTableMap::ID);
$criteria->addSelectColumn(RewritingTableMap::URL);
$criteria->addSelectColumn(RewritingTableMap::PRODUCT_ID);
$criteria->addSelectColumn(RewritingTableMap::CATEGORY_ID);
$criteria->addSelectColumn(RewritingTableMap::FOLDER_ID);
$criteria->addSelectColumn(RewritingTableMap::CONTENT_ID);
$criteria->addSelectColumn(RewritingTableMap::CREATED_AT);
$criteria->addSelectColumn(RewritingTableMap::UPDATED_AT);
$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 . '.PRODUCT_ID');
$criteria->addSelectColumn($alias . '.CATEGORY_ID');
$criteria->addSelectColumn($alias . '.FOLDER_ID');
$criteria->addSelectColumn($alias . '.CONTENT_ID');
$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');
}
@@ -361,7 +369,7 @@ class RewritingTableMap extends TableMap
*/
public static function getTableMap()
{
return Propel::getServiceContainer()->getDatabaseMap(RewritingTableMap::DATABASE_NAME)->getTable(RewritingTableMap::TABLE_NAME);
return Propel::getServiceContainer()->getDatabaseMap(RewritingUrlTableMap::DATABASE_NAME)->getTable(RewritingUrlTableMap::TABLE_NAME);
}
/**
@@ -369,16 +377,16 @@ class RewritingTableMap extends TableMap
*/
public static function buildTableMap()
{
$dbMap = Propel::getServiceContainer()->getDatabaseMap(RewritingTableMap::DATABASE_NAME);
if (!$dbMap->hasTable(RewritingTableMap::TABLE_NAME)) {
$dbMap->addTableObject(new RewritingTableMap());
$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 Rewriting or Criteria object OR a primary key value.
* Performs a DELETE on the database, given a RewritingUrl or Criteria object OR a primary key value.
*
* @param mixed $values Criteria or Rewriting object or primary key or array of primary keys
* @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
@@ -389,25 +397,25 @@ class RewritingTableMap extends TableMap
public static function doDelete($values, ConnectionInterface $con = null)
{
if (null === $con) {
$con = Propel::getServiceContainer()->getWriteConnection(RewritingTableMap::DATABASE_NAME);
$con = Propel::getServiceContainer()->getWriteConnection(RewritingUrlTableMap::DATABASE_NAME);
}
if ($values instanceof Criteria) {
// rename for clarity
$criteria = $values;
} elseif ($values instanceof \Thelia\Model\Rewriting) { // it's a model object
} 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(RewritingTableMap::DATABASE_NAME);
$criteria->add(RewritingTableMap::ID, (array) $values, Criteria::IN);
$criteria = new Criteria(RewritingUrlTableMap::DATABASE_NAME);
$criteria->add(RewritingUrlTableMap::ID, (array) $values, Criteria::IN);
}
$query = RewritingQuery::create()->mergeWith($criteria);
$query = RewritingUrlQuery::create()->mergeWith($criteria);
if ($values instanceof Criteria) { RewritingTableMap::clearInstancePool();
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) { RewritingTableMap::removeInstanceFromPool($singleval);
foreach ((array) $values as $singleval) { RewritingUrlTableMap::removeInstanceFromPool($singleval);
}
}
@@ -415,20 +423,20 @@ class RewritingTableMap extends TableMap
}
/**
* Deletes all rows from the rewriting table.
* 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 RewritingQuery::create()->doDeleteAll($con);
return RewritingUrlQuery::create()->doDeleteAll($con);
}
/**
* Performs an INSERT on the database, given a Rewriting or Criteria object.
* Performs an INSERT on the database, given a RewritingUrl or Criteria object.
*
* @param mixed $criteria Criteria or Rewriting object containing data that is used to create the INSERT statement.
* @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
@@ -437,18 +445,22 @@ class RewritingTableMap extends TableMap
public static function doInsert($criteria, ConnectionInterface $con = null)
{
if (null === $con) {
$con = Propel::getServiceContainer()->getWriteConnection(RewritingTableMap::DATABASE_NAME);
$con = Propel::getServiceContainer()->getWriteConnection(RewritingUrlTableMap::DATABASE_NAME);
}
if ($criteria instanceof Criteria) {
$criteria = clone $criteria; // rename for clarity
} else {
$criteria = $criteria->buildCriteria(); // build Criteria from Rewriting object
$criteria = $criteria->buildCriteria(); // build Criteria from RewritingUrl object
}
if ($criteria->containsKey(RewritingUrlTableMap::ID) && $criteria->keyContainsValue(RewritingUrlTableMap::ID) ) {
throw new PropelException('Cannot insert a value for auto-increment primary key ('.RewritingUrlTableMap::ID.')');
}
// Set the correct dbName
$query = RewritingQuery::create()->mergeWith($criteria);
$query = RewritingUrlQuery::create()->mergeWith($criteria);
try {
// use transaction because $criteria could contain info
@@ -464,7 +476,7 @@ class RewritingTableMap extends TableMap
return $pk;
}
} // RewritingTableMap
} // RewritingUrlTableMap
// This is the static code needed to register the TableMap for this table with the main Propel class.
//
RewritingTableMap::buildTableMap();
RewritingUrlTableMap::buildTableMap();

9
core/lib/Thelia/Model/Rewriting.php
View File

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

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 {
}

8
core/lib/Thelia/Model/RewritingQuery.php → core/lib/Thelia/Model/RewritingUrlQuery.php Executable file → Normal file
View File

@@ -2,11 +2,11 @@
namespace Thelia\Model;
use Thelia\Model\Base\RewritingQuery as BaseRewritingQuery;
use Thelia\Model\Base\RewritingUrlQuery as BaseRewritingUrlQuery;
/**
* Skeleton subclass for performing query and update operations on the 'rewriting' table.
* Skeleton subclass for performing query and update operations on the 'rewriting_url' table.
*
*
*
@@ -15,6 +15,6 @@ use Thelia\Model\Base\RewritingQuery as BaseRewritingQuery;
* long as it does not already exist in the output directory.
*
*/
class RewritingQuery extends BaseRewritingQuery {
class RewritingUrlQuery extends BaseRewritingUrlQuery {
} // RewritingQuery
} // RewritingUrlQuery