[11/06/2024] Les premières modifs + installation de quelques modules indispensables

2024-06-11 14:57:59 +02:00
parent 5ac5653ae5
commit 77cf2c7cc6
1626 changed files with 171457 additions and 131 deletions
--- a/domokits/local/modules/RewriteUrl/Controller/Admin/ModuleConfigController.php
+++ b/domokits/local/modules/RewriteUrl/Controller/Admin/ModuleConfigController.php
@@ -0,0 +1,321 @@
+<?php
+
+/*
+ * This file is part of the Thelia package.
+ * http://www.thelia.net
+ *
+ * (c) OpenStudio <info@thelia.net>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace RewriteUrl\Controller\Admin;
+
+use Propel\Runtime\ActiveQuery\Criteria;
+use RewriteUrl\Model\RewriteurlRule;
+use RewriteUrl\Model\RewriteurlRuleParam;
+use RewriteUrl\Model\RewriteurlRuleQuery;
+use RewriteUrl\RewriteUrl;
+use Thelia\Controller\Admin\BaseAdminController;
+use Thelia\Core\HttpFoundation\JsonResponse;
+use Thelia\Core\HttpFoundation\Request;
+use Thelia\Core\HttpFoundation\Response;
+use Thelia\Core\Security\AccessManager;
+use Thelia\Core\Security\Resource\AdminResources;
+use Thelia\Core\Translation\Translator;
+use Thelia\Exception\TheliaProcessException;
+use Thelia\Model\ConfigQuery;
+
+class ModuleConfigController extends BaseAdminController
+{
+    public function viewConfigAction()
+    {
+        if (null !== $response = $this->checkAuth([AdminResources::MODULE], 'RewriteUrl', AccessManager::VIEW)) {
+            return $response;
+        }
+
+        $isRewritingEnabled = ConfigQuery::isRewritingEnable();
+
+        return $this->render(
+            'RewriteUrl/module-configuration',
+            [
+                'isRewritingEnabled' => $isRewritingEnabled,
+            ]
+        );
+    }
+
+    public function getDatatableRules(Request $request)
+    {
+        $requestSearchValue = $request->get('search') ? '%' . $request->get('search')['value'] . '%' : '';
+        $recordsTotal = RewriteurlRuleQuery::create()->count();
+        $search = RewriteurlRuleQuery::create();
+        if ('' !== $requestSearchValue) {
+            $search
+                ->filterByValue($requestSearchValue, Criteria::LIKE)
+                ->_or()
+                ->filterByRedirectUrl($requestSearchValue);
+        }
+
+        $recordsFiltered = $search->count();
+
+        $orderColumn = $request->get('order')[0]['column'];
+        $orderDirection = $request->get('order')[0]['dir'];
+        switch ($orderColumn) {
+            case '0':
+                $search->orderByRuleType($orderDirection);
+                break;
+            case '1':
+                $search->orderByValue($orderDirection);
+                break;
+            case '2':
+                $search->orderByOnly404($orderDirection);
+                break;
+            case '3':
+                $search->orderByRedirectUrl($orderDirection);
+                break;
+            case '4':
+                $search->orderByPosition($orderDirection);
+                break;
+            default:
+                $search->orderByPosition();
+                break;
+        }
+
+        $search
+            ->offset($request->get('start'))
+            ->limit($request->get('length'));
+        $searchArray = $search->find()->toArray();
+
+        $resultsArray = [];
+        foreach ($searchArray as $row) {
+            $id = $row['Id'];
+            $isRegexSelected = $row['RuleType'] === RewriteurlRule::TYPE_REGEX ? 'selected' : '';
+            $isParamsSelected = $row['RuleType'] === RewriteurlRule::TYPE_GET_PARAMS ? 'selected' : '';
+            $isRegexParamsSelected = $row['RuleType'] === RewriteurlRule::TYPE_REGEX_GET_PARAMS ? 'selected' : '';
+            $isTextParamsSelected = $row['RuleType'] === RewriteurlRule::TYPE_TEXT ? 'selected' : '';
+            $isOnly404Checked = $row['Only404'] ? 'checked' : '';
+            $rewriteUrlRuleParams = RewriteurlRuleQuery::create()->findPk($row['Id'])->getRewriteUrlParamCollection();
+            $resultsArray[] = [
+                'Id' => $row['Id'],
+                'RuleType' => '<select class="js_rule_type form-control" data-idrule="' . $id . '" required>
+                                <option value="' . RewriteurlRule::TYPE_REGEX . '" ' . $isRegexSelected . '>' . Translator::getInstance()->trans('Regex', [], RewriteUrl::MODULE_DOMAIN) . '</option>
+                                <option value="' . RewriteurlRule::TYPE_GET_PARAMS . '" ' . $isParamsSelected . '>' . Translator::getInstance()->trans('Get Params', [], RewriteUrl::MODULE_DOMAIN) . '</option>
+                                <option value="' . RewriteurlRule::TYPE_REGEX_GET_PARAMS . '" ' . $isRegexParamsSelected . '>' . Translator::getInstance()->trans('Regex and Get Params', [], RewriteUrl::MODULE_DOMAIN) . '</option>
+                                <option value="' . RewriteurlRule::TYPE_TEXT . '" ' . $isTextParamsSelected . '>' . Translator::getInstance()->trans('Text', [], RewriteUrl::MODULE_DOMAIN) . '</option>
+                               </select>',
+                'Value' => $this->renderRaw(
+                    'RewriteUrl/tab-value-render',
+                    [
+                        'ID' => $row['Id'],
+                        'REWRITE_URL_PARAMS' => $rewriteUrlRuleParams,
+                        'VALUE' => $row['Value'],
+                    ]
+                ),
+                'Only404' => '<input class="js_only404 form-control" type="checkbox" style="width: 100%!important;" ' . $isOnly404Checked . '/>',
+                'RedirectUrl' => '<div class="col-md-12 input-group">
+                                    <input class="js_url_to_redirect form-control" type="text" placeholder="/path/mypage.html" value="' . $row['RedirectUrl'] . '"/>
+                                  </div>',
+                'Position' => '<a href="#" class="u-position-up js_move_rule_position_up" data-idrule="' . $id . '"><i class="glyphicon glyphicon-arrow-up"></i></a>
+                                <span class="js_editable_rule_position editable editable-click" data-idrule="' . $id . '">' . $row['Position'] . '</span>
+                               <a href="#" class="u-position-down js_move_rule_position_down" data-idrule="' . $id . '"><i class="glyphicon glyphicon-arrow-down"></i></a>',
+                'Actions' => '<a href="#" class="js_btn_update_rule btn btn-success" data-idrule="' . $id . '"><span class="glyphicon glyphicon-check"></span></a>
+                              <a href="#" class="js_btn_remove_rule btn btn-danger" data-idrule="' . $id . '"><span class="glyphicon glyphicon-remove"></span></a>
+',
+            ];
+        }
+
+        return new JsonResponse([
+            'draw' => $request->get('draw'),
+            'recordsTotal' => $recordsTotal,
+            'recordsFiltered' => $recordsFiltered,
+            'data' => $resultsArray,
+        ]);
+    }
+
+    public function setRewritingEnableAction(Request $request): Response
+    {
+        $isRewritingEnable = $request->get('rewriting_enable', null);
+
+        if ($isRewritingEnable !== null) {
+            ConfigQuery::write('rewriting_enable', $isRewritingEnable ? 1 : 0);
+
+            return $this->jsonResponse(json_encode(['state' => 'Success']), 200);
+        }
+
+        return $this->jsonResponse(Translator::getInstance()->trans(
+            'Unable to change the configuration variable.',
+            [],
+            RewriteUrl::MODULE_DOMAIN
+        ), 500);
+    }
+
+    public function addRuleAction(Request $request)
+    {
+        try {
+            $rule = new RewriteurlRule();
+
+            $this->fillRuleObjectFields($rule, $request);
+        } catch (\Exception $ex) {
+            return $this->jsonResponse($ex->getMessage(), 500);
+        }
+
+        return $this->jsonResponse(json_encode(['state' => 'Success']), 200);
+    }
+
+    public function updateRuleAction(Request $request)
+    {
+        try {
+            $rule = RewriteurlRuleQuery::create()->findOneById($request->get('id'));
+
+            if ($rule === null) {
+                throw new \Exception(Translator::getInstance()->trans(
+                    'Unable to find rule to update.',
+                    [],
+                    RewriteUrl::MODULE_DOMAIN
+                ));
+            }
+
+            $this->fillRuleObjectFields($rule, $request);
+        } catch (\Exception $ex) {
+            return $this->jsonResponse($ex->getMessage(), 500);
+        }
+
+        return $this->jsonResponse(json_encode(['state' => 'Success']), 200);
+    }
+
+    public function removeRuleAction(Request $request)
+    {
+        try {
+            $rule = RewriteurlRuleQuery::create()->findOneById($request->get('id'));
+
+            if ($rule === null) {
+                throw new \Exception(Translator::getInstance()->trans(
+                    'Unable to find rule to remove.',
+                    [],
+                    RewriteUrl::MODULE_DOMAIN
+                ));
+            }
+
+            $rule->delete();
+        } catch (\Exception $ex) {
+            return $this->jsonResponse($ex->getMessage(), 500);
+        }
+
+        return $this->jsonResponse(json_encode(['state' => 'Success']), 200);
+    }
+
+    public function moveRulePositionAction(Request $request)
+    {
+        try {
+            $rule = RewriteurlRuleQuery::create()->findOneById($request->get('id'));
+
+            if ($rule === null) {
+                throw new \Exception(Translator::getInstance()->trans(
+                    'Unable to find rule to change position.',
+                    [],
+                    RewriteUrl::MODULE_DOMAIN
+                ));
+            }
+
+            $type = $request->get('type', null);
+
+            if ($type === 'up') {
+                $rule->movePositionUp();
+            } elseif ($type === 'down') {
+                $rule->movePositionDown();
+            } elseif ($type === 'absolute') {
+                $position = $request->get('position', null);
+                if (!empty($position)) {
+                    $rule->changeAbsolutePosition($position);
+                }
+            }
+        } catch (\Exception $ex) {
+            return $this->jsonResponse($ex->getMessage(), 500);
+        }
+
+        return $this->jsonResponse(json_encode(['state' => 'Success']), 200);
+    }
+
+    /**
+     * @throws \Propel\Runtime\Exception\PropelException
+     */
+    protected function fillRuleObjectFields(RewriteurlRule $rule, Request $request): void
+    {
+        $ruleType = $request->get('ruleType', null);
+
+        $isParamRule = $ruleType === RewriteurlRule::TYPE_GET_PARAMS || $ruleType === RewriteurlRule::TYPE_REGEX_GET_PARAMS;
+        $isRegexRule = $ruleType === RewriteurlRule::TYPE_REGEX || $ruleType === RewriteurlRule::TYPE_REGEX_GET_PARAMS;
+        $isTextRule = $ruleType === RewriteurlRule::TYPE_TEXT;
+
+        if (!($isParamRule || $isRegexRule || $isTextRule)) {
+            throw new TheliaProcessException(Translator::getInstance()->trans('Unknown rule type.', [], RewriteUrl::MODULE_DOMAIN));
+        }
+
+        if ($isTextRule && !$textValue = $request->get('textValue', null)) {
+            throw new TheliaProcessException(Translator::getInstance()->trans('Text value cannot be empty.', [], RewriteUrl::MODULE_DOMAIN));
+        }
+
+        $regexValue = $request->get('value', null);
+
+        if ($isRegexRule && empty($regexValue)) {
+            throw new TheliaProcessException(Translator::getInstance()->trans('Regex value cannot be empty.', [], RewriteUrl::MODULE_DOMAIN));
+        }
+
+        $redirectUrl = $request->get('redirectUrl', null);
+
+        if (empty($redirectUrl)) {
+            throw new TheliaProcessException(Translator::getInstance()->trans('Redirect url cannot be empty.', [], RewriteUrl::MODULE_DOMAIN));
+        }
+
+        $value = $isTextRule ? $textValue : $regexValue;
+
+        $paramRuleArray = [];
+
+        if ($isParamRule) {
+            $paramRuleArray = $request->get('paramRules', null);
+            if (empty($paramRuleArray)) {
+                throw new TheliaProcessException(Translator::getInstance()->trans('At least one GET parameter is required.', [], RewriteUrl::MODULE_DOMAIN));
+            }
+        }
+
+        $rule->setRuleType($ruleType)
+            ->setValue($value)
+            ->setOnly404($request->get('only404', 1))
+            ->setRedirectUrl($redirectUrl);
+
+        if (empty($rule->getPosition())) {
+            $rule->setPosition($rule->getNextPosition());
+        }
+
+        $rule->deleteAllRelatedParam();
+
+        $rule->save();
+
+        if ($isParamRule) {
+            foreach ($paramRuleArray as $paramRule) {
+                if (!\array_key_exists('paramName', $paramRule) || empty($paramRule['paramName'])) {
+                    throw new TheliaProcessException(Translator::getInstance()->trans(
+                        'Param name is empty.',
+                        [],
+                        RewriteUrl::MODULE_DOMAIN
+                    ));
+                }
+                if (!\array_key_exists('condition', $paramRule) || empty($paramRule['condition'])) {
+                    throw new TheliaProcessException(Translator::getInstance()->trans(
+                        'Param condition is empty.',
+                        [],
+                        RewriteUrl::MODULE_DOMAIN
+                    ));
+                }
+
+                (new RewriteurlRuleParam())
+                    ->setParamName($paramRule['paramName'])
+                    ->setParamCondition($paramRule['condition'])
+                    ->setParamValue($paramRule['paramValue'])
+                    ->setIdRule($rule->getId())
+                    ->save();
+            }
+        }
+    }
+}
--- a/domokits/local/modules/RewriteUrl/Controller/Admin/NotRewritenUrlsAdminController.php
+++ b/domokits/local/modules/RewriteUrl/Controller/Admin/NotRewritenUrlsAdminController.php
@@ -0,0 +1,39 @@
+<?php
+/*************************************************************************************/
+/*      This file is part of the RewriteUrl module for Thelia.                       */
+/*                                                                                   */
+/*      Copyright (c) OpenStudio                                                     */
+/*      email : dev@thelia.net                                                       */
+/*      web : http://www.thelia.net                                                  */
+/*                                                                                   */
+/*      For the full copyright and license information, please view the LICENSE.txt  */
+/*      file that was distributed with this source code.                             */
+/*************************************************************************************/
+
+namespace RewriteUrl\Controller\Admin;
+
+use Thelia\Controller\Admin\AdminController;
+use Thelia\Core\HttpFoundation\Request;
+
+/**
+ * Class NotRewrittenUrlsAdminController
+ * @package RewriteUrl\Controller\Admin
+ * @author Tom Pradat <tpradat@openstudio.fr>
+ */
+class NotRewritenUrlsAdminController extends AdminController
+{
+    public function defaultAction(Request $request)
+    {
+        return $this->render(
+            'list-notrewritenurls',
+            array(
+                'current_tab' => $request->get('current_tab', 'categories'),
+                'page_category' => $request->get('page_category', 1),
+                'page_product' => $request->get('page_product', 1),
+                'page_brand' => $request->get('page_brand', 1),
+                'page_folder' => $request->get('page_folder', 1),
+                'page_content' => $request->get('page_content', 1),
+                )
+        );
+    }
+}
--- a/domokits/local/modules/RewriteUrl/Controller/Admin/RewriteUrlAdminController.php
+++ b/domokits/local/modules/RewriteUrl/Controller/Admin/RewriteUrlAdminController.php
@@ -0,0 +1,480 @@
+<?php
+/*************************************************************************************/
+/*      This file is part of the RewriteUrl module for Thelia.                       */
+/*                                                                                   */
+/*      Copyright (c) OpenStudio                                                     */
+/*      email : dev@thelia.net                                                       */
+/*      web : http://www.thelia.net                                                  */
+/*                                                                                   */
+/*      For the full copyright and license information, please view the LICENSE.txt  */
+/*      file that was distributed with this source code.                             */
+/*************************************************************************************/
+
+namespace RewriteUrl\Controller\Admin;
+
+use Propel\Runtime\ActiveQuery\Criteria;
+use RewriteUrl\Model\RewritingRedirectType;
+use RewriteUrl\Model\RewritingRedirectTypeQuery;
+use RewriteUrl\Model\RewritingUrlOverride;
+use RewriteUrl\Event\RewriteUrlEvent;
+use RewriteUrl\Event\RewriteUrlEvents;
+use RewriteUrl\Form\AddUrlForm;
+use RewriteUrl\Form\ReassignForm;
+use RewriteUrl\Form\SetDefaultForm;
+use RewriteUrl\RewriteUrl;
+use Symfony\Contracts\EventDispatcher\EventDispatcherInterface;
+use Thelia\Controller\Admin\BaseAdminController;
+use Thelia\Core\HttpFoundation\Request;
+use Thelia\Core\HttpFoundation\Response;
+use Thelia\Core\Security\AccessManager;
+use Thelia\Core\Security\Resource\AdminResources;
+use Thelia\Core\Template\ParserContext;
+use Thelia\Core\Translation\Translator;
+use Thelia\Form\Exception\FormValidationException;
+use Thelia\Model\BrandI18nQuery;
+use Thelia\Model\CategoryI18nQuery;
+use Thelia\Model\ContentI18nQuery;
+use Thelia\Model\FolderI18nQuery;
+use Thelia\Model\ProductI18nQuery;
+use Thelia\Model\ProductQuery;
+use Thelia\Model\RewritingUrl;
+use Thelia\Model\RewritingUrlQuery;
+use Thelia\Tools\URL;
+use Thelia\Log\Tlog;
+
+/**
+ * Class RewriteUrlAdminController
+ * @package RewriteUrl\Controller\Admin
+ * @author Vincent Lopes <vlopes@openstudio.fr>
+ * @author Gilles Bourgeat <gbourgeat@openstudio.fr>
+ */
+class RewriteUrlAdminController extends BaseAdminController
+{
+    /** @var array */
+    private $correspondence = array(
+        'brand'     => 'brand',
+        'category'  => 'categories',
+        'content'   => 'content',
+        'folder'    => 'folders',
+        'product'   => 'products'
+    );
+
+    /**
+     * @return mixed
+     */
+    public function deleteAction(
+        Request $request,
+        EventDispatcherInterface $dispatcher
+    ) {
+        if (null !== $response = $this->checkAuth(array(AdminResources::MODULE), 'RewriteUrl', AccessManager::DELETE)) {
+            return $response;
+        }
+
+        $urlId = $request->request->get('id_url');
+        $rewritingUrl = RewritingUrlQuery::create()->findOneById($urlId);
+
+        if ($rewritingUrl !== null) {
+            $event = new RewriteUrlEvent($rewritingUrl);
+            $dispatcher->dispatch($event,RewriteUrlEvents::REWRITEURL_DELETE);
+        }
+
+        return $this->generateRedirectFromRoute(
+            'admin.'.$this->correspondence[$rewritingUrl->getView()].'.update',
+            [
+                $rewritingUrl->getView().'_id'=>$rewritingUrl->getViewId(),
+                'current_tab' => 'modules'
+            ],
+            [
+                $rewritingUrl->getView().'_id'=>$rewritingUrl->getViewId()
+            ]
+        );
+    }
+
+    /**
+     * @return mixed
+     */
+    public function addAction(EventDispatcherInterface $dispatcher, ParserContext $parserContext)
+    {
+        $message = null;
+        $exception = null;
+
+        if (null !== $response = $this->checkAuth(array(AdminResources::MODULE), 'RewriteUrl', AccessManager::CREATE)) {
+            return $response;
+        }
+
+        $addForm = $this->createForm(AddUrlForm::getName());
+
+        try {
+            $form = $this->validateForm($addForm);
+            $data = $form->getData();
+
+            $findExist = RewritingUrlQuery::create()->findOneByUrl(($data['url']));
+
+            if ($findExist !== null && !in_array($findExist->getView(), RewriteUrl::getUnknownSources()) && $findExist->getView() !== '') {
+                $url = $this->generateUrlByRewritingUrl($findExist);
+
+                throw new \Exception(
+                    Translator::getInstance()->trans(
+                        "This url is already used here %url.",
+                        ['%url' => '<a href="' . $url . '">' . $url . '</a>'],
+                        RewriteUrl::MODULE_DOMAIN
+                    )
+                );
+            }
+
+            $rewriting = $findExist !== null ? $findExist : new RewritingUrlOverride();
+            $rewriting->setUrl($data['url'])
+            ->setView($data['view'])
+            ->setViewId($data['view-id'])
+            ->setViewLocale($data['locale']);
+
+            $rewriteDefault = RewritingUrlQuery::create()
+                ->filterByView($rewriting->getView())
+                ->filterByViewId($rewriting->getViewId())
+                ->filterByViewLocale($rewriting->getViewLocale())
+                ->findOneByRedirected(null);
+
+            $redirectType = null;
+
+            if ($data['default'] == 1) {
+                $rewriting->setRedirected(null);
+            } else {
+                if ($rewriteDefault !== null) {
+                    $rewriting->setRedirected($rewriteDefault->getId());
+                    $redirectType = RewritingRedirectTypeQuery::create()
+                        ->filterById($rewriting->getId())
+                        ->findOneOrCreate();
+                    $redirectType->setHttpcode($data['httpcode']);
+                } else {
+                    $rewriting->setRedirected(null);
+                }
+            }
+
+            $dispatcher->dispatch(
+                new RewriteUrlEvent($rewriting, $redirectType),
+                RewriteUrlEvents::REWRITEURL_ADD
+            );
+
+            return $this->generateSuccessRedirect($addForm);
+        } catch (FormValidationException $exception) {
+            $message = $this->createStandardFormValidationErrorMessage($exception);
+        } catch (\Exception $exception) {
+            $message = $exception->getMessage();
+        }
+
+        if ($message !== null && $exception !== null) {
+            Tlog::getInstance()->error(sprintf("Error during order delivery process : %s. Exception was %s", $message, $exception->getMessage()));
+
+            $addForm->setErrorMessage($message);
+
+            $parserContext
+                ->addForm($addForm)
+                ->setGeneralError($message);
+        }
+
+        return $this->generateSuccessRedirect($addForm);
+    }
+
+    /**
+     * @return mixed
+     */
+    public function setDefaultAction(Request $request, EventDispatcherInterface $dispatcher)
+    {
+        if (null !== $response = $this->checkAuth(AdminResources::MODULE, 'RewriteUrl', AccessManager::UPDATE)) {
+            return $response;
+        }
+
+        $urlId = $request->request->get('id_url');
+        $rewritingUrl = RewritingUrlQuery::create()->findOneById($urlId);
+
+        if ($rewritingUrl !== null) {
+            $event = new RewriteUrlEvent($rewritingUrl);
+            $dispatcher->dispatch($event,RewriteUrlEvents::REWRITEURL_SET_DEFAULT);
+        }
+
+        return $this->generateRedirectFromRoute(
+            'admin.'.$this->correspondence[$rewritingUrl->getView()].'.update',
+            [
+                $rewritingUrl->getView().'_id'=>$rewritingUrl->getViewId(),
+                'current_tab' => 'modules'
+            ],
+            [
+                $rewritingUrl->getView().'_id'=>$rewritingUrl->getViewId()
+            ]
+        );
+    }
+
+
+    public function changeRedirectTypeAction(Request $request, EventDispatcherInterface $dispatcher)
+    {
+        if (null !== $response = $this->checkAuth(AdminResources::MODULE, 'RewriteUrl', AccessManager::UPDATE)) {
+            return $response;
+        }
+
+        $urlId = $request->get('id_url');
+        $httpcode = $request->get('httpcode');
+        $rewritingUrl = RewritingUrlQuery::create()->findOneById($urlId);
+
+        if ($rewritingUrl !== null) {
+            $rewritingRedirectType = RewritingRedirectTypeQuery::create()
+                ->filterById($urlId)
+                ->findOneOrCreate();
+            $rewritingRedirectType->setHttpcode($httpcode);
+
+            $event = new RewriteUrlEvent($rewritingUrl, $rewritingRedirectType);
+            $dispatcher->dispatch($event,RewriteUrlEvents::REWRITEURL_UPDATE);
+        }
+
+        return new Response("", Response::HTTP_OK);
+    }
+
+    /**
+     * @return mixed
+     */
+    public function reassignAction(EventDispatcherInterface $dispatcher, ParserContext $parserContext)
+    {
+        if (null !== $response = $this->checkAuth(AdminResources::MODULE, 'RewriteUrl', AccessManager::UPDATE)) {
+            return $response;
+        }
+
+        $reassignForm = $this->createForm(ReassignForm::getName());
+
+        try {
+            $form = $this->validateForm($reassignForm);
+            $data = $form->getData();
+
+            $all = $data['all'];
+            $newRewrite = explode('::', $data['select-reassign']);
+            $rewriteId = $data['rewrite-id'];
+            $newView = $newRewrite[1];
+            $newViewId = $newRewrite[0];
+
+            if ($all === 1) {
+                self::allReassign($dispatcher, $rewriteId, $newView, $newViewId);
+            } else {
+                self::simpleReassign($dispatcher, $rewriteId, $newView, $newViewId);
+            }
+
+            return $this->generateSuccessRedirect($reassignForm);
+        } catch (FormValidationException $e) {
+            $message = $this->createStandardFormValidationErrorMessage($e);
+        } catch (\Exception $e) {
+            $message = $e->getMessage();
+        }
+
+        $reassignForm->setErrorMessage($message);
+
+        $parserContext
+            ->addForm($reassignForm)
+            ->setGeneralError($message)
+        ;
+
+        return $this->generateSuccessRedirect($reassignForm);
+    }
+
+    /**
+     * @return mixed|\Thelia\Core\HttpFoundation\Response
+     */
+    public function existAction(Request $request)
+    {
+        if (null !== $response = $this->checkAuth(array(AdminResources::MODULE), 'RewriteUrl', AccessManager::VIEW)) {
+            return $response;
+        }
+
+        $search = $request->query->get('q');
+
+        $rewritingUrl = RewritingUrlQuery::create()
+            ->filterByView(RewriteUrl::getUnknownSources(), Criteria::NOT_IN)
+            ->findOneByUrl($search);
+
+        if ($rewritingUrl !== null) {
+            if (!in_array($rewritingUrl->getView(), $this->correspondence)) {
+                return $this->jsonResponse(json_encode(false));
+            }
+
+            $rewritingUrlArray = ["reassignUrl" => $this->generateUrlByRewritingUrl($rewritingUrl)];
+
+            return $this->jsonResponse(json_encode($rewritingUrlArray));
+        } else {
+            return $this->jsonResponse(json_encode(false));
+        }
+    }
+
+    /**
+     * @return mixed|\Thelia\Core\HttpFoundation\Response
+     * @throws \Propel\Runtime\Exception\PropelException
+     */
+    public function searchAction(Request $request)
+    {
+        if (null !== $response = $this->checkAuth(array(AdminResources::MODULE), 'RewriteUrl', AccessManager::VIEW)) {
+            return $response;
+        }
+
+        $search = '%'.$request->query->get('q').'%';
+
+        $resultArray = array();
+
+        $categoriesI18n = CategoryI18nQuery::create()->filterByTitle($search, Criteria::LIKE)->limit(10);
+        $contentsI18n = ContentI18nQuery::create()->filterByTitle($search, Criteria::LIKE)->limit(10);
+        $foldersI18n = FolderI18nQuery::create()->filterByTitle($search, Criteria::LIKE)->limit(10);
+        $brandsI18n = BrandI18nQuery::create()->filterByTitle($search, Criteria::LIKE)->limit(10);
+
+        $productsI18n = ProductI18nQuery::create()->filterByTitle($search, Criteria::LIKE)->limit(10);
+        $productsRef = ProductQuery::create()->filterByRef($search, Criteria::LIKE)->limit(10);
+
+        /** @var \Thelia\Model\CategoryI18n $categoryI18n */
+        foreach ($categoriesI18n as $categoryI18n) {
+            $category = $categoryI18n->getCategory();
+            $resultArray['category'][$category->getId()] = $categoryI18n->getTitle();
+        }
+
+        /** @var \Thelia\Model\ContentI18n $contentI18n */
+        foreach ($contentsI18n as $contentI18n) {
+            $content = $contentI18n->getContent();
+            $resultArray['content'][$content->getId()] = $contentI18n->getTitle();
+        }
+
+        /** @var \Thelia\Model\FolderI18n $folderI18n */
+        foreach ($foldersI18n as $folderI18n) {
+            $folder = $folderI18n->getFolder();
+            $resultArray['folder'][$folder->getId()] = $folderI18n->getTitle();
+        }
+
+        /** @var \Thelia\Model\BrandI18n $brandI18n */
+        foreach ($brandsI18n as $brandI18n) {
+            $brand = $brandI18n->getBrand();
+            $resultArray['brand'][$brand->getId()] = $brandI18n->getTitle();
+        }
+
+        /** @var \Thelia\Model\ProductI18n $productI18n */
+        foreach ($productsI18n as $productI18n) {
+            $product = $productI18n->getProduct();
+            $resultArray['product'][$product->getId()] = $product->getRef().' : '.$productI18n->getTitle();
+        }
+
+        /** @var \Thelia\Model\Product $product */
+        foreach ($productsRef as $product) {
+            $productI18n = ProductI18nQuery::create()->filterByProduct($product)->findOne();
+            $resultArray['product'][$product->getId()] = $productI18n->getTitle();
+        }
+
+        return $this->jsonResponse(json_encode($resultArray));
+    }
+
+    /**
+     * @param int $rewriteId
+     * @param string $newView
+     * @param int $newViewId
+     */
+    protected function allReassign(
+        EventDispatcherInterface $dispatcher,
+        $rewriteId,
+        $newView,
+        $newViewId
+    ) {
+        $origin = RewritingUrlQuery::create()->findOneById($rewriteId);
+
+        $rewrites = RewritingUrlQuery::create()
+            ->filterByView($origin->getView())
+            ->filterByViewId($origin->getViewId())
+            ->find();
+
+        /** @var RewritingUrl $rewrite */
+        foreach ($rewrites as $rewrite) {
+            $destination = RewritingUrlQuery::create()
+                ->filterByView($newView)
+                ->filterByViewId($newViewId)
+                ->filterByViewLocale($rewrite->getViewLocale())
+                ->filterByRedirected(null)
+                ->findOne();
+
+            $rewrite
+                ->setView($newView)
+                ->setViewId($newViewId)
+                ->setRedirected(($destination === null) ? null : $destination->getId());
+
+            $dispatcher->dispatch(
+                new RewriteUrlEvent($rewrite),
+                RewriteUrlEvents::REWRITEURL_UPDATE
+            );
+        }
+    }
+
+    /**
+     * @param int $rewriteId
+     * @param string $newView
+     * @param int $newViewId
+     */
+    protected function simpleReassign(
+        EventDispatcherInterface $dispatcher,
+        $rewriteId,
+        $newView,
+        $newViewId
+    ) {
+        $rewrite = RewritingUrlQuery::create()->findOneById($rewriteId);
+
+        // add new default url
+        if (null !== $newDefault = RewritingUrlQuery::create()->findOneByRedirected($rewrite->getId())) {
+            $dispatcher->dispatch(
+                new RewriteUrlEvent(
+                    $newDefault->setRedirected(null)
+                ),
+                RewriteUrlEvents::REWRITEURL_UPDATE
+            );
+        }
+
+        //Update urls who redirected to updated URL
+        if (null !== $isRedirection = RewritingUrlQuery::create()->findByRedirected($rewrite->getId())) {
+            /** @var \Thelia\Model\RewritingUrl $redirected */
+            foreach ($isRedirection as $redirected) {
+                $dispatcher->dispatch(
+                    new RewriteUrlEvent(
+                        $redirected->setRedirected(
+                            ($newDefault !== null) ? $newDefault->getId() : $rewrite->getRedirected()
+                        )
+                    ),
+                    RewriteUrlEvents::REWRITEURL_UPDATE
+                );
+            }
+        }
+
+        $rewrite->setView($newView)
+            ->setViewId($newViewId);
+
+        //Check if default url already exist for the view with the locale
+        $rewriteDefault = RewritingUrlQuery::create()
+            ->filterByView($newView)
+            ->filterByViewId($newViewId)
+            ->filterByViewLocale($rewrite->getViewLocale())
+            ->findOneByRedirected(null);
+
+        if ($rewriteDefault !== null) {
+            $rewrite->setRedirected($rewriteDefault->getId());
+        } else {
+            $rewrite->setRedirected(null);
+        }
+
+        $event = new RewriteUrlEvent($rewrite);
+        $dispatcher->dispatch($event,RewriteUrlEvents::REWRITEURL_UPDATE);
+    }
+
+    /**
+     * @param RewritingUrl $rewritingUrl
+     * @return null|string url
+     */
+    protected function generateUrlByRewritingUrl(RewritingUrl $rewritingUrl)
+    {
+        if (isset($this->correspondence[$rewritingUrl->getView()])) {
+            $route = $this->getRoute(
+                "admin.".$this->correspondence[$rewritingUrl->getView()] . ".update",
+                [$rewritingUrl->getView().'_id' => $rewritingUrl->getViewId()]
+            );
+            return URL::getInstance()->absoluteUrl(
+                $route,
+                [$rewritingUrl->getView().'_id' => $rewritingUrl->getViewId(), 'current_tab' => 'modules']
+            );
+        }
+
+        return null;
+    }
+}