Datatable110QueryParser::isArrayAndHasKey() - Code Metrics - Inspection of "Support Symphony 3.0" - OpenSkill/Datatable - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Branch — master (90ee88)

by Tim

created 2016-01-15 02:17 UTC

Datatable110QueryParser::isArrayAndHasKey() A

↳ Parent: Datatable110QueryParser

Complexity

Conditions	3
Paths	3

Size

Total Lines	12
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	12
rs	9.4285
cc	3
eloc	6
nc	3
nop	2

<?php

namespace OpenSkill\Datatable\Queries\Parser;


use OpenSkill\Datatable\Columns\ColumnConfiguration;
use OpenSkill\Datatable\Queries\QueryConfiguration;
use OpenSkill\Datatable\Queries\QueryConfigurationBuilder;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\HttpFoundation\ParameterBag;
use Symfony\Component\HttpFoundation\Request;

class Datatable110QueryParser extends QueryParser
{

    /**
     * Method to determine if this parser can handle the query parameters. If so then the parser should return true
     * and be able to return a DTQueryConfiguration
     *
     * @param Request $request The current request, that should be investigated
     * @return bool true if the parser is able to parse the query parameters and to return a DTQueryConfiguration
     */
    public function canParse(Request $request)
    {
        return $request->query->has("draw");
    }

    /**
     * Method that should parse the request and return a DTQueryConfiguration
     *
     * @param Request $request The current request that should be investigated
     * @param ColumnConfiguration[] $columnConfiguration The configuration of the columns
     * @return QueryConfiguration the configuration the provider can use to prepare the data
     */
    public function parse(Request $request, array $columnConfiguration)
    {
        $query = $request->query;
        $builder = QueryConfigurationBuilder::create();

        $this->getDrawCall($query, $builder);

        $this->getStart($query, $builder);

        $this->getLength($query, $builder);

        $this->getSearch($query, $builder);

        $this->getRegex($query, $builder);

        $this->getOrder($query, $builder, $columnConfiguration);

        $this->getSearchColumns($query, $builder, $columnConfiguration);

        return $builder->build();
    }

    /**
     * Helper function that will check if a variable is empty
     * @param mixed $string
     * @return bool true if empty, false otherwise
     */
    private function isEmpty($string)
    {
        return empty($string);
    }

    /**
     * Helper function that will check if an array key exists
     * @param mixed $array
     * @param string $key key to check
     * @return bool true if array & exists, false otherwise
     */
    private function isArrayAndHasKey($array, $key)
    {
        if (!is_array($array)) {
            return false;
        }

        if (array_key_exists($key, $array)) {
            return true;
        }

        return false;
    }

    /**
     * @param ParameterBag $query
     * @param QueryConfigurationBuilder $builder
     */
    public function getDrawCall($query, $builder)
    {
        if ($query->has('draw')) {
            $builder->drawCall($query->get('draw'));
        }
    }

    /**
     * @param ParameterBag $query
     * @param QueryConfigurationBuilder $builder
     */
    public function getStart($query, $builder)
    {
        if ($query->has('start')) {
            $builder->start($query->get('start'));
        }
    }

    /**
     * @param ParameterBag $query
     * @param QueryConfigurationBuilder $builder
     */
    public function getLength($query, $builder)
    {
        if ($query->has('length')) {
            $builder->length($query->get('length'));
        }
    }

    /**
     * @param ParameterBag $query
     * @param QueryConfigurationBuilder $builder
     */
    public function getSearch($query, $builder)
    {
        $search = $query->get('search');

        if ($this->isArrayAndHasKey($search, 'value')) {
            $builder->searchValue($search['value'], null, true);

        }
    }

    public function getSearchColumns($query, $builder, array $columnConfiguration)
    {
        // for each column we need to see if there is a search value
        $columns = $query->get('columns');

        foreach ($columnConfiguration as $i => $c) {
            // check if there is something search related
            if (!isset($columns[$i])) {
                continue;
            }

            if ($c->getSearch()->isSearchable()) {
                // search for this column is available
                $value = $columns[$i]['search']['value'];

                if (!$this->isEmpty($value)) {
                    $builder->columnSearch($c->getName(), $columns[$i]['search']['value'], null, true);
                }
            }
        }
    }

    /**
     * @param ParameterBag $query
     * @param QueryConfigurationBuilder $builder
     */
    public function getRegex($query, $builder)
    {
        $search = $query->get('search');

        if ($this->isArrayAndHasKey($search, 'regex')) {
            $builder->searchRegex($search['regex'], null, true);

        }
    }

    /**
     * @param ParameterBag $query
     * @param QueryConfigurationBuilder $builder
     * @param ColumnConfiguration[] $columnConfiguration
     */
    private function getOrder(ParameterBag $query, QueryConfigurationBuilder $builder, array $columnConfiguration)
    {
        //loop over the order
        if(($query->has('order'))) {
            $order = $query->get('order');
            foreach($order as $i => $config) {
                if(array_key_exists($config['column'], $columnConfiguration)) {
                    $column = $columnConfiguration[$config['column']];
                    if($column->getOrder()->isOrderable()) {
                        $builder->columnOrder($column->getName(), $config['dir']);
                    }
                }
            }
        }
    }
}

1			<?php
2
3			namespace OpenSkill\Datatable\Queries\Parser;
4
5
6			use OpenSkill\Datatable\Columns\ColumnConfiguration;
7			use OpenSkill\Datatable\Queries\QueryConfiguration;
8			use OpenSkill\Datatable\Queries\QueryConfigurationBuilder;
9			use Symfony\Component\HttpFoundation\JsonResponse;
10			use Symfony\Component\HttpFoundation\ParameterBag;
11			use Symfony\Component\HttpFoundation\Request;
12
13			class Datatable110QueryParser extends QueryParser
14			{
15
16			/**
17			* Method to determine if this parser can handle the query parameters. If so then the parser should return true
18			* and be able to return a DTQueryConfiguration
19			*
20			* @param Request $request The current request, that should be investigated
21			* @return bool true if the parser is able to parse the query parameters and to return a DTQueryConfiguration
22			*/
23			public function canParse(Request $request)
24			{
25			return $request->query->has("draw");
26			}
27
28			/**
29			* Method that should parse the request and return a DTQueryConfiguration
30			*
31			* @param Request $request The current request that should be investigated
32			* @param ColumnConfiguration[] $columnConfiguration The configuration of the columns
33			* @return QueryConfiguration the configuration the provider can use to prepare the data
34			*/
35			public function parse(Request $request, array $columnConfiguration)
36			{
37			$query = $request->query;
38			$builder = QueryConfigurationBuilder::create();
39
40			$this->getDrawCall($query, $builder);
41
42			$this->getStart($query, $builder);
43
44			$this->getLength($query, $builder);
45
46			$this->getSearch($query, $builder);
47
48			$this->getRegex($query, $builder);
49
50			$this->getOrder($query, $builder, $columnConfiguration);
51
52			$this->getSearchColumns($query, $builder, $columnConfiguration);
53
54			return $builder->build();
55			}
56
57			/**
58			* Helper function that will check if a variable is empty
59			* @param mixed $string
60			* @return bool true if empty, false otherwise
61			*/
62			private function isEmpty($string)
63			{
64			return empty($string);
65			}
66
67			/**
68			* Helper function that will check if an array key exists
69			* @param mixed $array
70			* @param string $key key to check
71			* @return bool true if array & exists, false otherwise
72			*/
73			private function isArrayAndHasKey($array, $key)
74			{
75			if (!is_array($array)) {
76			return false;
77			}
78
79			if (array_key_exists($key, $array)) {
80			return true;
81			}
82
83			return false;
84			}
85
86			/**
87			* @param ParameterBag $query
88			* @param QueryConfigurationBuilder $builder
89			*/
90			public function getDrawCall($query, $builder)
91			{
92			if ($query->has('draw')) {
93			$builder->drawCall($query->get('draw'));
94			}
95			}
96
97			/**
98			* @param ParameterBag $query
99			* @param QueryConfigurationBuilder $builder
100			*/
101			public function getStart($query, $builder)
102			{
103			if ($query->has('start')) {
104			$builder->start($query->get('start'));
105			}
106			}
107
108			/**
109			* @param ParameterBag $query
110			* @param QueryConfigurationBuilder $builder
111			*/
112			public function getLength($query, $builder)
113			{
114			if ($query->has('length')) {
115			$builder->length($query->get('length'));
116			}
117			}
118
119			/**
120			* @param ParameterBag $query
121			* @param QueryConfigurationBuilder $builder
122			*/
123			public function getSearch($query, $builder)
124			{
125			$search = $query->get('search');
126
127			if ($this->isArrayAndHasKey($search, 'value')) {
128			$builder->searchValue($search['value'], null, true);
			0 ignored issues – show Unused Code introduced 2016-01-15 02:19 UTC by Report Bug Copy Issue Report The call to `QueryConfigurationBuilder::searchValue()` has too many arguments starting with `null`. This check compares calls to functions or methods with their respective definitions. If the call has more arguments than are defined, it raises an issue. If a function is defined several times with a different number of parameters, the check may pick up the wrong definition and report false positives. One codebase where this has been known to happen is Wordpress. In this case you can add the `@ignore` PhpDoc annotation to the duplicate definition and it will be ignored. Loading history...
129			}
130			}
131
132			public function getSearchColumns($query, $builder, array $columnConfiguration)
133			{
134			// for each column we need to see if there is a search value
135			$columns = $query->get('columns');
136
137			foreach ($columnConfiguration as $i => $c) {
138			// check if there is something search related
139			if (!isset($columns[$i])) {
140			continue;
141			}
142
143			if ($c->getSearch()->isSearchable()) {
144			// search for this column is available
145			$value = $columns[$i]['search']['value'];
146
147			if (!$this->isEmpty($value)) {
148			$builder->columnSearch($c->getName(), $columns[$i]['search']['value'], null, true);
149			}
150			}
151			}
152			}
153
154			/**
155			* @param ParameterBag $query
156			* @param QueryConfigurationBuilder $builder
157			*/
158			public function getRegex($query, $builder)
159			{
160			$search = $query->get('search');
161
162			if ($this->isArrayAndHasKey($search, 'regex')) {
163			$builder->searchRegex($search['regex'], null, true);
			0 ignored issues – show Unused Code introduced 2016-01-15 02:19 UTC by Report Bug Copy Issue Report The call to `QueryConfigurationBuilder::searchRegex()` has too many arguments starting with `null`. This check compares calls to functions or methods with their respective definitions. If the call has more arguments than are defined, it raises an issue. If a function is defined several times with a different number of parameters, the check may pick up the wrong definition and report false positives. One codebase where this has been known to happen is Wordpress. In this case you can add the `@ignore` PhpDoc annotation to the duplicate definition and it will be ignored. Loading history...
164			}
165			}
166
167			/**
168			* @param ParameterBag $query
169			* @param QueryConfigurationBuilder $builder
170			* @param ColumnConfiguration[] $columnConfiguration
171			*/
172			private function getOrder(ParameterBag $query, QueryConfigurationBuilder $builder, array $columnConfiguration)
173			{
174			//loop over the order
175			if(($query->has('order'))) {
176			$order = $query->get('order');
177			foreach($order as $i => $config) {
178			if(array_key_exists($config['column'], $columnConfiguration)) {
179			$column = $columnConfiguration[$config['column']];
180			if($column->getOrder()->isOrderable()) {
181			$builder->columnOrder($column->getName(), $config['dir']);
182			}
183			}
184			}
185			}
186			}
187			}

OpenSkill / Datatable

Branch — master (90ee88)

Datatable110QueryParser::isArrayAndHasKey() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like