ModuleConfigController::fillRuleObjectFields() - Code Metrics - Inspection of "Add redirect rules (Regex + GET params)" - thelia-modules/RewriteUrl - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#22)

unknown

created 2017-11-20 15:30 UTC

ModuleConfigController::fillRuleObjectFields() C

↳ Parent: ModuleConfigController

Complexity

Conditions	15
Paths	24

Size

Total Lines	66
Code Lines	39

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	66
rs	5.8663
cc	15
eloc	39
nc	24
nop	2

How to fix Long Method Complexity

<?php

namespace RewriteUrl\Controller\Admin;

use RewriteUrl\Model\RewriteurlRule;
use RewriteUrl\Model\RewriteurlRuleParam;
use RewriteUrl\Model\RewriteurlRuleQuery;
use RewriteUrl\RewriteUrl;
use Thelia\Controller\Admin\BaseAdminController;
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();
        $rewritingRules = RewriteurlRuleQuery::create()->orderByPosition()->find();

        return $this->render(
            "RewriteUrl/module-configuration",
            [
                "isRewritingEnabled" => $isRewritingEnabled,
                "rewritingRules" => $rewritingRules,
            ]
        );
    }

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

    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 RewriteUrl\Model\RewriteurlRule;
6			use RewriteUrl\Model\RewriteurlRuleParam;
7			use RewriteUrl\Model\RewriteurlRuleQuery;
8			use RewriteUrl\RewriteUrl;
9			use Thelia\Controller\Admin\BaseAdminController;
10			use Thelia\Core\Security\AccessManager;
11			use Thelia\Core\Security\Resource\AdminResources;
12			use Thelia\Core\Translation\Translator;
13			use Thelia\Model\ConfigQuery;
14
15			class ModuleConfigController extends BaseAdminController
16			{
17			public function viewConfigAction($params = array())
18			{
19			if (null !== $response = $this->checkAuth(array(AdminResources::MODULE), 'GoogleShoppingXml', AccessManager::VIEW)) {
20			return $response;
21			}
22
23			$isRewritingEnabled = ConfigQuery::isRewritingEnable();
24			$rewritingRules = RewriteurlRuleQuery::create()->orderByPosition()->find();
25
26			return $this->render(
27			"RewriteUrl/module-configuration",
28			[
29			"isRewritingEnabled" => $isRewritingEnabled,
30			"rewritingRules" => $rewritingRules,
31			]
32			);
33			}
34
35			public function setRewritingEnableAction()
36			{
37			$request = $this->getRequest()->request;
38			$isRewritingEnable = $request->get("rewriting_enable", null);
39
40			if ($isRewritingEnable !== null) {
41			ConfigQuery::write("rewriting_enable", $isRewritingEnable ? 1 : 0);
42			return $this->jsonResponse(json_encode(["state" => "Success"]), 200);
43			} else {
44			return $this->jsonResponse(Translator::getInstance()->trans(
45			"Unable to change the configuration variable.",
46			[],
47			RewriteUrl::MODULE_DOMAIN
48			), 500);
49			}
50			}
51
52			public function addRuleAction()
53			{
54			try {
55			$request = $this->getRequest()->request;
56
57			$rule = new RewriteurlRule();
58
59			$this->fillRuleObjectFields($rule, $request);
60			} catch (\Exception $ex) {
61			return $this->jsonResponse($ex->getMessage(), 500);
62			}
63			return $this->jsonResponse(json_encode(["state" => "Success"]), 200);
64			}
65
66
67			public function updateRuleAction()
68			{
69			try {
70			$request = $this->getRequest()->request;
71
72			$rule = RewriteurlRuleQuery::create()->findOneById($request->get("id"));
73			if ($rule == null) {
74			throw new \Exception(Translator::getInstance()->trans(
75			"Unable to find rule to update.",
76			[],
77			RewriteUrl::MODULE_DOMAIN
78			));
79			}
80
81			$this->fillRuleObjectFields($rule, $request);
82			} catch (\Exception $ex) {
83			return $this->jsonResponse($ex->getMessage(), 500);
84			}
85			return $this->jsonResponse(json_encode(["state" => "Success"]), 200);
86			}
87
88
89			public function removeRuleAction()
90			{
91			try {
92			$request = $this->getRequest()->request;
93
94			$rule = RewriteurlRuleQuery::create()->findOneById($request->get("id"));
95			if ($rule == null) {
96			throw new \Exception(Translator::getInstance()->trans(
97			"Unable to find rule to remove.",
98			[],
99			RewriteUrl::MODULE_DOMAIN
100			));
101			}
102
103			$rule->delete();
104			} catch (\Exception $ex) {
105			return $this->jsonResponse($ex->getMessage(), 500);
106			}
107			return $this->jsonResponse(json_encode(["state" => "Success"]), 200);
108			}
109
110
111			public function moveRulePositionAction()
112			{
113			try {
114			$request = $this->getRequest()->request;
115
116			$rule = RewriteurlRuleQuery::create()->findOneById($request->get("id"));
117			if ($rule == null) {
118			throw new \Exception(Translator::getInstance()->trans(
119			"Unable to find rule to change position.",
120			[],
121			RewriteUrl::MODULE_DOMAIN
122			));
123			}
124
125			$type = $request->get("type", null);
126			if ($type == "up") {
127			$rule->movePositionUp();
128			} elseif ($type == "down") {
129			$rule->movePositionDown();
130			} elseif ($type == "absolute") {
131			$position = $request->get("position", null);
132			if (!empty($position)) {
133			$rule->changeAbsolutePosition($position);
134			}
135			}
136			} catch (\Exception $ex) {
137			return $this->jsonResponse($ex->getMessage(), 500);
138			}
139			return $this->jsonResponse(json_encode(["state" => "Success"]), 200);
140			}
141
142
143
144			protected function fillRuleObjectFields(RewriteurlRule $rule, $request)
145			{
146			$ruleType = $request->get("ruleType", null);
147			if ($ruleType !== "regex" && $ruleType !== "params") {
148			throw new \Exception(Translator::getInstance()->trans("Unknown rule type.", [], RewriteUrl::MODULE_DOMAIN));
149			}
150
151			$regexValue = $request->get("value", null);
152			if ($ruleType == "regex" && empty($regexValue)) {
153			throw new \Exception(Translator::getInstance()->trans("Regex value cannot be empty.", [], RewriteUrl::MODULE_DOMAIN));
154			}
155
156			$redirectUrl = $request->get("redirectUrl", null);
157			if (empty($redirectUrl)) {
158			throw new \Exception(Translator::getInstance()->trans("Redirect url cannot be empty.", [], RewriteUrl::MODULE_DOMAIN));
159			}
160
161			$paramRuleArray = array();
162			if ($ruleType == "params") {
163			$paramRuleArray = $request->get("paramRules", null);
164			if (empty($paramRuleArray)) {
165			throw new \Exception(Translator::getInstance()->trans("At least one GET parameter is required.", [], RewriteUrl::MODULE_DOMAIN));
166			}
167			}
168
169
170
171			$rule->setRuleType($ruleType);
172			$rule->setValue($regexValue);
173			$rule->setOnly404($request->get("only404", 1));
174			$rule->setRedirectUrl($redirectUrl);
175			if (empty($rule->getPosition())) {
176			$rule->setPosition($rule->getNextPosition());
177			}
178
179
180			$rule->deleteAllRelatedParam();
181
182			$rule->save();
183
184			if ($ruleType == "params") {
185			foreach ($paramRuleArray as $paramRule) {
186			if (!array_key_exists("paramName", $paramRule) \|\| empty($paramRule["paramName"])) {
187			throw new \Exception(Translator::getInstance()->trans(
188			"Param name is empty.",
189			[],
190			RewriteUrl::MODULE_DOMAIN
191			));
192			}
193			if (!array_key_exists("condition", $paramRule) \|\| empty($paramRule["condition"])) {
194			throw new \Exception(Translator::getInstance()->trans(
195			"Param condition is empty.",
196			[],
197			RewriteUrl::MODULE_DOMAIN
198			));
199			}
200
201			$paramRuleObject = new RewriteurlRuleParam();
202			$paramRuleObject->setParamName($paramRule["paramName"]);
203			$paramRuleObject->setParamCondition($paramRule["condition"]);
204			$paramRuleObject->setParamValue($paramRule["paramValue"]);
205			$paramRuleObject->setIdRule($rule->getId());
206			$paramRuleObject->save();
207			}
208			}
209			}
210			}
211

thelia-modules / RewriteUrl

Pull Request — master (#22)

ModuleConfigController::fillRuleObjectFields() C

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like