QuickInsertFunctions::filterGetResult() - Code Metrics - Inspection of "fixes_0061" - ozo2003/HelperBundle - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 7ce289...8aaaed )

by Dāvis

created 2018-02-21 16:07 UTC

QuickInsertFunctions::filterGetResult() B

↳ Parent: QuickInsertFunctions

Complexity

Conditions	8
Paths	17

Size

Total Lines	18
Code Lines	11

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	8
eloc	11
nc	17
nop	3
dl	0
loc	18
rs	7.7777
c	0
b	0
f	0

<?php

namespace Sludio\HelperBundle\Script\Repository;

use AppCache;
filter:
    dependency_paths: ["lib/*"]
use Doctrine\Common\Persistence\Mapping\ClassMetadata;
use Sludio\HelperBundle\Script\Utils\Helper;

abstract class QuickInsertFunctions
{
    public static $entityManager;
    public static $connection;
    protected static $mock = [];
    protected static $metadata = [];
    protected static $tableName;
    protected static $identifier;

    protected static function buildExtra($extra)
    {
        $methods = [
            'GROUP BY',
            'HAVING',
            'ORDER BY',
        ];
        $sql = '';

        foreach ($methods as $method) {
            if (isset($extra[$method])) {
                $sql .= ' '.$method.' ';
                if (\is_array($extra[$method])) {
                    $sql .= implode(' ', $extra[$method]).' ';
                } else {
                    $sql .= $extra[$method].' ';
                }
            }
        }
        self::getLimit($extra, $sql);

        return Helper::oneSpace($sql);
    }

    private static function getLimit($extra = [], &$sql)
    {
        if (isset($extra['LIMIT']) && \is_array($extra['LIMIT'])) {
            if (isset($extra['LIMIT'][1])) {
                list($offset, $limit) = $extra['LIMIT'];
            } else {
                $offset = 0;
                $limit = $extra['LIMIT'][0];
            }
            $sql = sprintf('%sLIMIT %s, %s', $sql, $offset, $limit);
        }
    }

    protected static function buildWhere($tableName, array $where)
    {
        $whereSql = '';
        if (!empty($where)) {
            $path = ' WHERE ';
            foreach ($where as $key => $value) {
                if (!\is_array($value)) {
                    if (isset(self::$mock[$tableName][$key])) {
                        $whereSql .= $path.self::$mock[$tableName][$key].' = '.self::slashes($tableName, $key, $value);
                    } else {
                        $whereSql .= $path.$key.' = '.self::slashes($tableName, $key, $value);
                    }
                } else {
                    $whereSql .= $path.$value[0];
                }

                if ($value === reset($where)) {
                    $path = ' AND ';
                }
            }
        }

        return $whereSql;
    }

    protected static function slashes($tableName, $key, $value)
    {
        if ($value instanceof \DateTime) {
            $result = "'".addslashes(trim($value->format('Y-m-d H:i:s')))."'";
        } else {
            $result = self::numeric($tableName, $key, $value) ? (int)$value : "'".addslashes(trim($value))."'";
        }

        $trim = trim($result);
        if ($trim === '' || $trim === "''") {
            $result = null;
        }

        return $result;
    }

    protected static function numeric($tableName, $key, $value)
    {
        $intTypes = [
            'boolean',
            'integer',
            'longint',
        ];
        $flip = [];
        if (isset(self::$mock[$tableName])) {
            $flip = array_flip(self::$mock[$tableName]);
        }

        if (isset(self::$metadata[$tableName], $flip[$key])) {
            if (\in_array(self::$metadata[$tableName]->getFieldMapping($flip[$key])['type'], $intTypes, false)) {
                return true;
            }

            return false;
        }

        return \is_numeric($value) || \is_bool($value);
    }

    protected static function getTable(&$object, &$tableName, &$columns, &$type, $manager = null, array $extraFields = [])
    {
        self::init($manager);
        if (\is_object($object)) {
            self::extract($object);
            $tableName = self::$tableName;
            $columns = self::$mock[$tableName] ?: [];
            $type = 'object';
        } else {
            $tableName = $object['table_name'];
            unset($object['table_name']);
            $type = 'table';
            $columns = array_keys($object) ?: [];
        }

        if (isset($extraFields[$tableName])) {
            $columns = array_merge($columns, $extraFields[$tableName]);
        }
    }

    public static function init($manager = null)
    {
        if (self::$connection) {
            return;
        }
        global $kernel;

        if (AppCache::class === \get_class($kernel)) {
            $kernel = $kernel->getKernel();
        }
        $container = $kernel->getContainer();

        $manager = $manager ?: $container->getParameter('sludio_helper.entity.manager');
        if (\is_object($manager)) {
            self::$entityManager = $manager;
        } else {
            self::$entityManager = $container->get('doctrine')->getManager($manager);
        }
        self::$connection = self::$entityManager->getConnection();
    }

    protected static function extract($object)
    {
        self::init(false);
        $data = self::extractExt(self::$entityManager->getMetadataFactory()->getMetadataFor(\get_class($object)));

        self::$mock = $data['mock'];
        self::$tableName = $data['table'];
        self::$metadata[$data['table']] = $data['meta'];
        self::$identifier = $data['identifier'];
    }

    public static function extractExt(ClassMetadata $metadata)
    {
        $fields = $metadata->getFieldNames();
        $columns = $metadata->getColumnNames();
        $table = $metadata->getTableName();
        $identifier = null;

        $result = [];
        foreach ($fields as $key => $field) {
            /** @var $columns array */
            foreach ($columns as $key2 => $column) {
                if ($key === $key2) {
                    $result[$table][$field] = $column;
                    if ($field === $metadata->getIdentifier()[0]) {
                        $identifier = $column;
                    }
                }
            }
        }

        $data = [
            'mock' => $result,
            'table' => $table,
            'meta' => $metadata,
            'identifier' => $identifier,
        ];

        return $data;
    }

    protected static function parseUpdateResult($object, $type, $id, $tableName, array $result = null)
    {
        $data = [];
        if (!empty($result)) {
            foreach ($result as $key => $value) {
                $content = self::value($object, $key, $type, $tableName, false);
                if ($id && !\in_array($content, [
                        null,
                        $value,
                    ], true)) {
                    $data[$key] = $content;
                }
            }
        }

        return $data;
    }

    protected static function value($object, $variable, $type, $tableName, $check = true)
    {
        $value = null;
        if ($type === 'object') {
            $value = $object->{'get'.ucfirst(Helper::toCamelCase($variable))}();
        } else {
            if (isset($object[$variable])) {
                $value = $object[$variable];
            }
        }

        if ($check) {
            self::slashes($tableName, $variable, $value);
        }

        return $value;
    }

    protected static function makeValues($tableName, array $data = [])
    {
        $values = '';
        if (!empty($data)) {
            foreach ($data as $key => $value) {
                $values .= self::slashes($tableName, $key, $value).',';
            }
        }

        return \substr($values, 0, -1);
    }

    protected static function parsePersistColumns(array $columns = [], $object, $type, $tableName, &$idd)
    {
        $data = [];
        foreach ($columns as $value => $key) {
            $keys = [
                $key,
                $value,
            ];
            if (!Helper::multiple($keys)) {
                $value = self::value($object, $value, $type, $tableName);
                if ($value !== null) {
                    $data[$key] = $value;
                    if ($key === self::$identifier) {
                        $idd = $value;
                    }
                }
            }
        }

        return $data;
    }

    protected static function filterGetResult(array $result = null, array $fields = [], $one = false)
    {
        if ($result) {
            $field = (\count($fields) === 1 && $fields[0] !== '*') ? $fields[0] : null;
            if ($field !== null) {
                if (!$one) {
                    foreach ($result as &$res) {
                        $res = $res[$field];
                    }
                } else {
                    $result = $result[0][$field];
                }
            } elseif ($one) {
                $result = $result[0];
            }
        }

        return $result;
    }
}


1			<?php
2
3			namespace Sludio\HelperBundle\Script\Repository;
4
5			use AppCache;
			0 ignored issues – show Bug introduced 2018-01-11 20:06 UTC by Report Bug Copy Issue Report The type `AppCache` was not found. Maybe you did not declare it correctly or list all dependencies? The issue could also be caused by a filter entry in the build configuration. If the path has been excluded in your configuration, e.g. `excluded_paths: ["lib/"]`, you can move it to the dependency path list as follows: filter: dependency_paths: ["lib/"] For further information see https://scrutinizer-ci.com/docs/tools/php/php-scrutinizer/#list-dependency-paths Loading history...
6			use Doctrine\Common\Persistence\Mapping\ClassMetadata;
7			use Sludio\HelperBundle\Script\Utils\Helper;
8
9			abstract class QuickInsertFunctions
10			{
11			public static $entityManager;
12			public static $connection;
13			protected static $mock = [];
14			protected static $metadata = [];
15			protected static $tableName;
16			protected static $identifier;
17
18			protected static function buildExtra($extra)
19			{
20			$methods = [
21			'GROUP BY',
22			'HAVING',
23			'ORDER BY',
24			];
25			$sql = '';
26
27			foreach ($methods as $method) {
28			if (isset($extra[$method])) {
29			$sql .= ' '.$method.' ';
30			if (\is_array($extra[$method])) {
31			$sql .= implode(' ', $extra[$method]).' ';
32			} else {
33			$sql .= $extra[$method].' ';
34			}
35			}
36			}
37			self::getLimit($extra, $sql);
38
39			return Helper::oneSpace($sql);
40			}
41
42			private static function getLimit($extra = [], &$sql)
43			{
44			if (isset($extra['LIMIT']) && \is_array($extra['LIMIT'])) {
45			if (isset($extra['LIMIT'][1])) {
46			list($offset, $limit) = $extra['LIMIT'];
47			} else {
48			$offset = 0;
49			$limit = $extra['LIMIT'][0];
50			}
51			$sql = sprintf('%sLIMIT %s, %s', $sql, $offset, $limit);
52			}
53			}
54
55			protected static function buildWhere($tableName, array $where)
56			{
57			$whereSql = '';
58			if (!empty($where)) {
59			$path = ' WHERE ';
60			foreach ($where as $key => $value) {
61			if (!\is_array($value)) {
62			if (isset(self::$mock[$tableName][$key])) {
63			$whereSql .= $path.self::$mock[$tableName][$key].' = '.self::slashes($tableName, $key, $value);
64			} else {
65			$whereSql .= $path.$key.' = '.self::slashes($tableName, $key, $value);
66			}
67			} else {
68			$whereSql .= $path.$value[0];
69			}
70
71			if ($value === reset($where)) {
72			$path = ' AND ';
73			}
74			}
75			}
76
77			return $whereSql;
78			}
79
80			protected static function slashes($tableName, $key, $value)
81			{
82			if ($value instanceof \DateTime) {
83			$result = "'".addslashes(trim($value->format('Y-m-d H:i:s')))."'";
84			} else {
85			$result = self::numeric($tableName, $key, $value) ? (int)$value : "'".addslashes(trim($value))."'";
86			}
87
88			$trim = trim($result);
89			if ($trim === '' \|\| $trim === "''") {
90			$result = null;
91			}
92
93			return $result;
94			}
95
96			protected static function numeric($tableName, $key, $value)
97			{
98			$intTypes = [
99			'boolean',
100			'integer',
101			'longint',
102			];
103			$flip = [];
104			if (isset(self::$mock[$tableName])) {
105			$flip = array_flip(self::$mock[$tableName]);
106			}
107
108			if (isset(self::$metadata[$tableName], $flip[$key])) {
109			if (\in_array(self::$metadata[$tableName]->getFieldMapping($flip[$key])['type'], $intTypes, false)) {
110			return true;
111			}
112
113			return false;
114			}
115
116			return \is_numeric($value) \|\| \is_bool($value);
117			}
118
119			protected static function getTable(&$object, &$tableName, &$columns, &$type, $manager = null, array $extraFields = [])
120			{
121			self::init($manager);
122			if (\is_object($object)) {
123			self::extract($object);
124			$tableName = self::$tableName;
125			$columns = self::$mock[$tableName] ?: [];
126			$type = 'object';
127			} else {
128			$tableName = $object['table_name'];
129			unset($object['table_name']);
130			$type = 'table';
131			$columns = array_keys($object) ?: [];
132			}
133
134			if (isset($extraFields[$tableName])) {
135			$columns = array_merge($columns, $extraFields[$tableName]);
136			}
137			}
138
139			public static function init($manager = null)
140			{
141			if (self::$connection) {
142			return;
143			}
144			global $kernel;
145
146			if (AppCache::class === \get_class($kernel)) {
147			$kernel = $kernel->getKernel();
148			}
149			$container = $kernel->getContainer();
150
151			$manager = $manager ?: $container->getParameter('sludio_helper.entity.manager');
152			if (\is_object($manager)) {
153			self::$entityManager = $manager;
154			} else {
155			self::$entityManager = $container->get('doctrine')->getManager($manager);
156			}
157			self::$connection = self::$entityManager->getConnection();
158			}
159
160			protected static function extract($object)
161			{
162			self::init(false);
163			$data = self::extractExt(self::$entityManager->getMetadataFactory()->getMetadataFor(\get_class($object)));
164
165			self::$mock = $data['mock'];
166			self::$tableName = $data['table'];
167			self::$metadata[$data['table']] = $data['meta'];
168			self::$identifier = $data['identifier'];
169			}
170
171			public static function extractExt(ClassMetadata $metadata)
172			{
173			$fields = $metadata->getFieldNames();
174			$columns = $metadata->getColumnNames();
175			$table = $metadata->getTableName();
176			$identifier = null;
177
178			$result = [];
179			foreach ($fields as $key => $field) {
180			/** @var $columns array */
181			foreach ($columns as $key2 => $column) {
182			if ($key === $key2) {
183			$result[$table][$field] = $column;
184			if ($field === $metadata->getIdentifier()[0]) {
185			$identifier = $column;
186			}
187			}
188			}
189			}
190
191			$data = [
192			'mock' => $result,
193			'table' => $table,
194			'meta' => $metadata,
195			'identifier' => $identifier,
196			];
197
198			return $data;
199			}
200
201			protected static function parseUpdateResult($object, $type, $id, $tableName, array $result = null)
202			{
203			$data = [];
204			if (!empty($result)) {
205			foreach ($result as $key => $value) {
206			$content = self::value($object, $key, $type, $tableName, false);
207			if ($id && !\in_array($content, [
208			null,
209			$value,
210			], true)) {
211			$data[$key] = $content;
212			}
213			}
214			}
215
216			return $data;
217			}
218
219			protected static function value($object, $variable, $type, $tableName, $check = true)
220			{
221			$value = null;
222			if ($type === 'object') {
223			$value = $object->{'get'.ucfirst(Helper::toCamelCase($variable))}();
224			} else {
225			if (isset($object[$variable])) {
226			$value = $object[$variable];
227			}
228			}
229
230			if ($check) {
231			self::slashes($tableName, $variable, $value);
232			}
233
234			return $value;
235			}
236
237			protected static function makeValues($tableName, array $data = [])
238			{
239			$values = '';
240			if (!empty($data)) {
241			foreach ($data as $key => $value) {
242			$values .= self::slashes($tableName, $key, $value).',';
243			}
244			}
245
246			return \substr($values, 0, -1);
247			}
248
249			protected static function parsePersistColumns(array $columns = [], $object, $type, $tableName, &$idd)
250			{
251			$data = [];
252			foreach ($columns as $value => $key) {
253			$keys = [
254			$key,
255			$value,
256			];
257			if (!Helper::multiple($keys)) {
258			$value = self::value($object, $value, $type, $tableName);
259			if ($value !== null) {
260			$data[$key] = $value;
261			if ($key === self::$identifier) {
262			$idd = $value;
263			}
264			}
265			}
266			}
267
268			return $data;
269			}
270
271			protected static function filterGetResult(array $result = null, array $fields = [], $one = false)
272			{
273			if ($result) {
274			$field = (\count($fields) === 1 && $fields[0] !== '*') ? $fields[0] : null;
275			if ($field !== null) {
276			if (!$one) {
277			foreach ($result as &$res) {
278			$res = $res[$field];
279			}
280			} else {
281			$result = $result[0][$field];
282			}
283			} elseif ($one) {
284			$result = $result[0];
285			}
286			}
287
288			return $result;
289			}
290			}
291

ozo2003 / HelperBundle

Push — master ( 7ce289...8aaaed )

QuickInsertFunctions::filterGetResult() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like