ModuleConfigController::setHttpsRedirectionEnableAction() - Code Metrics - Inspection of "autoindex.php" - thelia-modules/RewriteUrl - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#34)

unknown

created 2021-06-01 14:44 UTC

setHttpsRedirectionEnableAction() A

↳ Parent: ModuleConfigController

Complexity

Conditions	3
Paths	2

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	16
rs	9.7333
c	0
b	0
f	0
cc	3
nc	2
nop	0

<?php

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\Security\AccessManager;
use Thelia\Core\Security\Resource\AdminResources;
use Thelia\Core\Translation\Translator;
use Thelia\Model\ConfigQuery;

class ModuleConfigController extends BaseAdminController
{
    public function viewConfigAction($params = array())
    {
        if (null !== $response = $this->checkAuth(array(AdminResources::MODULE), 'GoogleShoppingXml', AccessManager::VIEW)) {
            return $response;
        }

        $isRewritingEnabled = ConfigQuery::isRewritingEnable();
        $isIndexRedirectionEnabled = ConfigQuery::isIndexRedirectionEnable();
        $isHttpsRedirectionEnabled = ConfigQuery::isHttpsRedirectionEnable();

        return $this->render(
            "RewriteUrl/module-configuration",
            [
                "isRewritingEnabled" => $isRewritingEnabled,
                "isIndexRedirectionEnabled" => $isIndexRedirectionEnabled,
                "isHttpsRedirectionEnabled" => $isHttpsRedirectionEnabled,

            ]
        );
    }

    public function getDatatableRules()
    {
        $request = $this->getRequest();

        $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'] === 'regex' ? 'selected' : '';
            $isParamsSelected = $row['RuleType'] === 'params' ? '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="regex" ' . $isRegexSelected . '>' . Translator::getInstance()->trans("Regex", [], RewriteUrl::MODULE_DOMAIN) . '</option>
                                <option value="params" ' . $isParamsSelected . '>' . Translator::getInstance()->trans("Get Params", [], RewriteUrl::MODULE_DOMAIN) . '</option>
                               </select>',
                'Value' => $this->renderRaw(
                    "RewriteUrl/tab-value-render",
                    [
                        "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 = $this->getRequest()->request;
        $isRewritingEnable = $request->get("rewriting_enable", null);

        if ($isRewritingEnable !== null) {
            ConfigQuery::write("rewriting_enable", $isRewritingEnable ? 1 : 0);
            return $this->jsonResponse(json_encode(["state" => "Success"]), 200);
        } else {
            return $this->jsonResponse(Translator::getInstance()->trans(
                "Unable to change the configuration variable.",
                [],
                RewriteUrl::MODULE_DOMAIN
            ), 500);
        }
    }

    // check index_redirection_enable status & write an entry if there is none //
    
    public function setIndexRedirectionEnableAction()
    {
        $request = $this->getRequest()->request;
        $isIndexRedirectionEnable = $request->get("index_redirection_enable", null);

        if ($isIndexRedirectionEnable !== null) {
            ConfigQuery::write("index_redirection_enable", $isIndexRedirectionEnable ? 1 : 0);
            return $this->jsonResponse(json_encode(["state" => "Success"]), 200);
        } else {
            return $this->jsonResponse(Translator::getInstance()->trans(
                "Unable to change the configuration variable.",
                [],
                RewriteUrl::MODULE_DOMAIN
            ), 500);
        }
    }
    // ############################## //

    // check https_redirection_enable status & write an entry if there is none //

    public function setHttpsRedirectionEnableAction()
    {
        $request = $this->getRequest()->request;
        $isHttpsRedirectionEnable = $request->get("https_redirection_enable", null);

        if ($isHttpsRedirectionEnable !== null) {
            ConfigQuery::write("https_redirection_enable", $isHttpsRedirectionEnable ? 1 : 0);
            return $this->jsonResponse(json_encode(["state" => "Success"]), 200);
        } else {
            return $this->jsonResponse(Translator::getInstance()->trans(
                "Unable to change the configuration variable.",
                [],
                RewriteUrl::MODULE_DOMAIN
            ), 500);
        }
    }
    // ############################## //

    public function addRuleAction()
    {
        try {
            $request = $this->getRequest()->request;

            $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()
    {
        try {
            $request = $this->getRequest()->request;

            $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()
    {
        try {
            $request = $this->getRequest()->request;

            $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()
    {
        try {
            $request = $this->getRequest()->request;

            $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);
    }

    protected function fillRuleObjectFields(RewriteurlRule $rule, $request)
    {
        $ruleType = $request->get("ruleType", null);
        if ($ruleType !== "regex" && $ruleType !== "params") {
            throw new \Exception(Translator::getInstance()->trans("Unknown rule type.", [], RewriteUrl::MODULE_DOMAIN));
        }

        $regexValue = $request->get("value", null);
        if ($ruleType == "regex" && empty($regexValue)) {
            throw new \Exception(Translator::getInstance()->trans("Regex value cannot be empty.", [], RewriteUrl::MODULE_DOMAIN));
        }

        $redirectUrl = $request->get("redirectUrl", null);
        if (empty($redirectUrl)) {
            throw new \Exception(Translator::getInstance()->trans("Redirect url cannot be empty.", [], RewriteUrl::MODULE_DOMAIN));
        }

        $paramRuleArray = array();
        if ($ruleType == "params") {
            $paramRuleArray = $request->get("paramRules", null);
            if (empty($paramRuleArray)) {
                throw new \Exception(Translator::getInstance()->trans("At least one GET parameter is required.", [], RewriteUrl::MODULE_DOMAIN));
            }
        }

        $rule->setRuleType($ruleType);
        $rule->setValue($regexValue);
        $rule->setOnly404($request->get("only404", 1));
        $rule->setRedirectUrl($redirectUrl);
        if (empty($rule->getPosition())) {
            $rule->setPosition($rule->getNextPosition());
        }

        $rule->deleteAllRelatedParam();

        $rule->save();

        if ($ruleType == "params") {
            foreach ($paramRuleArray as $paramRule) {
                if (!array_key_exists("paramName", $paramRule) || empty($paramRule["paramName"])) {
                    throw new \Exception(Translator::getInstance()->trans(
                        "Param name is empty.",
                        [],
                        RewriteUrl::MODULE_DOMAIN
                    ));
                }
                if (!array_key_exists("condition", $paramRule) || empty($paramRule["condition"])) {
                    throw new \Exception(Translator::getInstance()->trans(
                        "Param condition is empty.",
                        [],
                        RewriteUrl::MODULE_DOMAIN
                    ));
                }

                $paramRuleObject = new RewriteurlRuleParam();
                $paramRuleObject->setParamName($paramRule["paramName"]);
                $paramRuleObject->setParamCondition($paramRule["condition"]);
                $paramRuleObject->setParamValue($paramRule["paramValue"]);
                $paramRuleObject->setIdRule($rule->getId());
                $paramRuleObject->save();
            }
        }
    }
}


1			<?php
2
3			namespace RewriteUrl\Controller\Admin;
4
5			use Propel\Runtime\ActiveQuery\Criteria;
6			use RewriteUrl\Model\RewriteurlRule;
7			use RewriteUrl\Model\RewriteurlRuleParam;
8			use RewriteUrl\Model\RewriteurlRuleQuery;
9			use RewriteUrl\RewriteUrl;
10			use Thelia\Controller\Admin\BaseAdminController;
11			use Thelia\Core\HttpFoundation\JsonResponse;
12			use Thelia\Core\Security\AccessManager;
13			use Thelia\Core\Security\Resource\AdminResources;
14			use Thelia\Core\Translation\Translator;
15			use Thelia\Model\ConfigQuery;
16
17			class ModuleConfigController extends BaseAdminController
18			{
19			public function viewConfigAction($params = array())
20			{
21			if (null !== $response = $this->checkAuth(array(AdminResources::MODULE), 'GoogleShoppingXml', AccessManager::VIEW)) {
22			return $response;
23			}
24
25			$isRewritingEnabled = ConfigQuery::isRewritingEnable();
26			$isIndexRedirectionEnabled = ConfigQuery::isIndexRedirectionEnable();
27			$isHttpsRedirectionEnabled = ConfigQuery::isHttpsRedirectionEnable();
28
29			return $this->render(
30			"RewriteUrl/module-configuration",
31			[
32			"isRewritingEnabled" => $isRewritingEnabled,
33			"isIndexRedirectionEnabled" => $isIndexRedirectionEnabled,
34			"isHttpsRedirectionEnabled" => $isHttpsRedirectionEnabled,
35
36			]
37			);
38			}
39
40			public function getDatatableRules()
41			{
42			$request = $this->getRequest();
43
44			$requestSearchValue = $request->get('search') ? '%' . $request->get('search')['value'] . '%' : "";
45			$recordsTotal = RewriteurlRuleQuery::create()->count();
46			$search = RewriteurlRuleQuery::create();
47			if ("" !== $requestSearchValue) {
48			$search
49			->filterByValue($requestSearchValue, Criteria::LIKE)
50			->_or()
51			->filterByRedirectUrl($requestSearchValue)
52			;
53			}
54
55			$recordsFiltered = $search->count();
56
57			$orderColumn = $request->get('order')[0]['column'];
58			$orderDirection = $request->get('order')[0]['dir'];
59			switch ($orderColumn) {
60			case '0':
61			$search->orderByRuleType($orderDirection);
62			break;
63			case '1':
64			$search->orderByValue($orderDirection);
65			break;
66			case '2':
67			$search->orderByOnly404($orderDirection);
68			break;
69			case '3':
70			$search->orderByRedirectUrl($orderDirection);
71			break;
72			case '4':
73			$search->orderByPosition($orderDirection);
74			break;
75			default:
76			$search->orderByPosition();
77			break;
78			}
79
80			$search
81			->offset($request->get('start'))
82			->limit($request->get('length'))
83			;
84			$searchArray = $search->find()->toArray();
85
86			$resultsArray = [];
87			foreach ($searchArray as $row) {
88			$id = $row['Id'];
89			$isRegexSelected = $row['RuleType'] === 'regex' ? 'selected' : '';
90			$isParamsSelected = $row['RuleType'] === 'params' ? 'selected' : '';
91			$isOnly404Checked = $row['Only404'] ? 'checked' : '';
92			$rewriteUrlRuleParams = RewriteurlRuleQuery::create()->findPk($row['Id'])->getRewriteUrlParamCollection();
93			$resultsArray[] = [
94			'Id' => $row['Id'],
95			'RuleType' => '<select class="js_rule_type form-control" data-idrule="' . $id . '" required>
96			<option value="regex" ' . $isRegexSelected . '>' . Translator::getInstance()->trans("Regex", [], RewriteUrl::MODULE_DOMAIN) . '</option>
97			<option value="params" ' . $isParamsSelected . '>' . Translator::getInstance()->trans("Get Params", [], RewriteUrl::MODULE_DOMAIN) . '</option>
98			</select>',
99			'Value' => $this->renderRaw(
100			"RewriteUrl/tab-value-render",
101			[
102			"REWRITE_URL_PARAMS" => $rewriteUrlRuleParams,
103			"VALUE" => $row['Value'],
104			]
105			),
106			'Only404' => '<input class="js_only404 form-control" type="checkbox" style="width: 100%!important;" ' . $isOnly404Checked . '/>',
107			'RedirectUrl' => '<div class="col-md-12 input-group">
108			<input class="js_url_to_redirect form-control" type="text" placeholder="/path/mypage.html" value="' . $row['RedirectUrl'] . '"/>
109			</div>',
110			'Position' => '<a href="#" class="u-position-up js_move_rule_position_up" data-idrule="' . $id . '"><i class="glyphicon glyphicon-arrow-up"></i></a>
111			<span class="js_editable_rule_position editable editable-click" data-idrule="' . $id . '">' . $row['Position'] . '</span>
112			<a href="#" class="u-position-down js_move_rule_position_down" data-idrule="' . $id . '"><i class="glyphicon glyphicon-arrow-down"></i></a>',
113			'Actions' => '<a href="#" class="js_btn_update_rule btn btn-success" data-idrule="' . $id . '"><span class="glyphicon glyphicon-check"></span></a>
114			<a href="#" class="js_btn_remove_rule btn btn-danger" data-idrule="' . $id . '"><span class="glyphicon glyphicon-remove"></span></a>
115			',
116			];
117			}
118
119			return new JsonResponse([
120			'draw' => $request->get('draw'),
121			'recordsTotal' => $recordsTotal,
122			'recordsFiltered' => $recordsFiltered,
123			'data' => $resultsArray
124			]);
125			}
126
127			public function setRewritingEnableAction()
128			{
129			$request = $this->getRequest()->request;
130			$isRewritingEnable = $request->get("rewriting_enable", null);
131
132			if ($isRewritingEnable !== null) {
133			ConfigQuery::write("rewriting_enable", $isRewritingEnable ? 1 : 0);
134			return $this->jsonResponse(json_encode(["state" => "Success"]), 200);
135			} else {
136			return $this->jsonResponse(Translator::getInstance()->trans(
137			"Unable to change the configuration variable.",
138			[],
139			RewriteUrl::MODULE_DOMAIN
140			), 500);
141			}
142			}
143
144			// check index_redirection_enable status & write an entry if there is none //
145
146			public function setIndexRedirectionEnableAction()
147			{
148			$request = $this->getRequest()->request;
149			$isIndexRedirectionEnable = $request->get("index_redirection_enable", null);
150
151			if ($isIndexRedirectionEnable !== null) {
152			ConfigQuery::write("index_redirection_enable", $isIndexRedirectionEnable ? 1 : 0);
153			return $this->jsonResponse(json_encode(["state" => "Success"]), 200);
154			} else {
155			return $this->jsonResponse(Translator::getInstance()->trans(
156			"Unable to change the configuration variable.",
157			[],
158			RewriteUrl::MODULE_DOMAIN
159			), 500);
160			}
161			}
162			// ############################## //
163
164			// check https_redirection_enable status & write an entry if there is none //
165
166			public function setHttpsRedirectionEnableAction()
167			{
168			$request = $this->getRequest()->request;
169			$isHttpsRedirectionEnable = $request->get("https_redirection_enable", null);
170
171			if ($isHttpsRedirectionEnable !== null) {
172			ConfigQuery::write("https_redirection_enable", $isHttpsRedirectionEnable ? 1 : 0);
173			return $this->jsonResponse(json_encode(["state" => "Success"]), 200);
174			} else {
175			return $this->jsonResponse(Translator::getInstance()->trans(
176			"Unable to change the configuration variable.",
177			[],
178			RewriteUrl::MODULE_DOMAIN
179			), 500);
180			}
181			}
182			// ############################## //
183
184			public function addRuleAction()
185			{
186			try {
187			$request = $this->getRequest()->request;
188
189			$rule = new RewriteurlRule();
190
191			$this->fillRuleObjectFields($rule, $request);
192			} catch (\Exception $ex) {
193			return $this->jsonResponse($ex->getMessage(), 500);
194			}
195			return $this->jsonResponse(json_encode(["state" => "Success"]), 200);
196			}
197
198			public function updateRuleAction()
199			{
200			try {
201			$request = $this->getRequest()->request;
202
203			$rule = RewriteurlRuleQuery::create()->findOneById($request->get("id"));
204			if ($rule == null) {
205			throw new \Exception(Translator::getInstance()->trans(
206			"Unable to find rule to update.",
207			[],
208			RewriteUrl::MODULE_DOMAIN
209			));
210			}
211
212			$this->fillRuleObjectFields($rule, $request);
213			} catch (\Exception $ex) {
214			return $this->jsonResponse($ex->getMessage(), 500);
215			}
216			return $this->jsonResponse(json_encode(["state" => "Success"]), 200);
217			}
218
219
220			public function removeRuleAction()
221			{
222			try {
223			$request = $this->getRequest()->request;
224
225			$rule = RewriteurlRuleQuery::create()->findOneById($request->get("id"));
226			if ($rule == null) {
227			throw new \Exception(Translator::getInstance()->trans(
228			"Unable to find rule to remove.",
229			[],
230			RewriteUrl::MODULE_DOMAIN
231			));
232			}
233
234			$rule->delete();
235			} catch (\Exception $ex) {
236			return $this->jsonResponse($ex->getMessage(), 500);
237			}
238			return $this->jsonResponse(json_encode(["state" => "Success"]), 200);
239			}
240
241			public function moveRulePositionAction()
242			{
243			try {
244			$request = $this->getRequest()->request;
245
246			$rule = RewriteurlRuleQuery::create()->findOneById($request->get("id"));
247			if ($rule == null) {
248			throw new \Exception(Translator::getInstance()->trans(
249			"Unable to find rule to change position.",
250			[],
251			RewriteUrl::MODULE_DOMAIN
252			));
253			}
254
255			$type = $request->get("type", null);
256			if ($type == "up") {
257			$rule->movePositionUp();
258			} elseif ($type == "down") {
259			$rule->movePositionDown();
260			} elseif ($type == "absolute") {
261			$position = $request->get("position", null);
262			if (!empty($position)) {
263			$rule->changeAbsolutePosition($position);
264			}
265			}
266			} catch (\Exception $ex) {
267			return $this->jsonResponse($ex->getMessage(), 500);
268			}
269			return $this->jsonResponse(json_encode(["state" => "Success"]), 200);
270			}
271
272			protected function fillRuleObjectFields(RewriteurlRule $rule, $request)
273			{
274			$ruleType = $request->get("ruleType", null);
275			if ($ruleType !== "regex" && $ruleType !== "params") {
276			throw new \Exception(Translator::getInstance()->trans("Unknown rule type.", [], RewriteUrl::MODULE_DOMAIN));
277			}
278
279			$regexValue = $request->get("value", null);
280			if ($ruleType == "regex" && empty($regexValue)) {
281			throw new \Exception(Translator::getInstance()->trans("Regex value cannot be empty.", [], RewriteUrl::MODULE_DOMAIN));
282			}
283
284			$redirectUrl = $request->get("redirectUrl", null);
285			if (empty($redirectUrl)) {
286			throw new \Exception(Translator::getInstance()->trans("Redirect url cannot be empty.", [], RewriteUrl::MODULE_DOMAIN));
287			}
288
289			$paramRuleArray = array();
290			if ($ruleType == "params") {
291			$paramRuleArray = $request->get("paramRules", null);
292			if (empty($paramRuleArray)) {
293			throw new \Exception(Translator::getInstance()->trans("At least one GET parameter is required.", [], RewriteUrl::MODULE_DOMAIN));
294			}
295			}
296
297			$rule->setRuleType($ruleType);
298			$rule->setValue($regexValue);
299			$rule->setOnly404($request->get("only404", 1));
300			$rule->setRedirectUrl($redirectUrl);
301			if (empty($rule->getPosition())) {
302			$rule->setPosition($rule->getNextPosition());
303			}
304
305			$rule->deleteAllRelatedParam();
306
307			$rule->save();
308
309			if ($ruleType == "params") {
310			foreach ($paramRuleArray as $paramRule) {
311			if (!array_key_exists("paramName", $paramRule) \|\| empty($paramRule["paramName"])) {
312			throw new \Exception(Translator::getInstance()->trans(
313			"Param name is empty.",
314			[],
315			RewriteUrl::MODULE_DOMAIN
316			));
317			}
318			if (!array_key_exists("condition", $paramRule) \|\| empty($paramRule["condition"])) {
319			throw new \Exception(Translator::getInstance()->trans(
320			"Param condition is empty.",
321			[],
322			RewriteUrl::MODULE_DOMAIN
323			));
324			}
325
326			$paramRuleObject = new RewriteurlRuleParam();
327			$paramRuleObject->setParamName($paramRule["paramName"]);
328			$paramRuleObject->setParamCondition($paramRule["condition"]);
329			$paramRuleObject->setParamValue($paramRule["paramValue"]);
330			$paramRuleObject->setIdRule($rule->getId());
331			$paramRuleObject->save();
332			}
333			}
334			}
335			}
336

thelia-modules / RewriteUrl

Pull Request — master (#34)

setHttpsRedirectionEnableAction() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like