QuickInsertRepository::persist() - Code Metrics - Inspection of "bc fix" - ozo2003/HelperBundle - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Branch — master (a0cc06)

by Dāvis

created 2017-10-13 07:16 UTC

QuickInsertRepository::persist() F

↳ Parent: QuickInsertRepository

Complexity

Conditions	35
Paths	1008

Size

Total Lines	99
Code Lines	67

Duplication

Lines	34
Ratio	34.34 %

Importance

Changes

Metric	Value
cc	35
eloc	67
nc	1008
nop	6
dl	34
loc	99
rs	2
c	0
b	0
f	0

How to fix Long Method Complexity

<?php

namespace Sludio\HelperBundle\Script\Repository;

class QuickInsertRepository
{
    private static $mock = [];
    private static $metadata = [];
    private static $tableName;

    public static $em;

    public static $connection;
    public static $container;

    public static function init($noFkCheck = false, $manager = null)

    {
        global $kernel;

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

        $manager = $manager ?: self::$container->getParameter('sludio_helper.entity.manager');
        self::$em = self::$container->get('doctrine')->getManager($manager);
        self::$connection = self::$em->getConnection();

        if (!$noFkCheck) {
            $sth = self::$connection->prepare('SET FOREIGN_KEY_CHECKS = 0');
            $sth->execute();
        }
    }

    public static function close($noFkCheck = false)
    {
        if (!$noFkCheck) {
            $sth = self::$connection->prepare('SET FOREIGN_KEY_CHECKS = 1');
            $sth->execute();
        }
    }

    public static function isEmpty($variable)
    {
        $result = true;

        if (is_array($variable) && count($variable) > 0) {
            foreach ($variable as $value) {
                $result = $result && self::isEmpty($value);
            }
        } else {
            $result = empty($variable);
        }

        return $result;
    }

    private static function extract($object)
    {
        $data = self::extractExt($object, self::$em);

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

    public static function extractExt($object, $em)

    {
        $metadata = $em->getClassMetadata(get_class($object));

        $fields = $metadata->getFieldNames();
        $columns = $metadata->getColumnNames();
        $table = $metadata->getTableName();

        $result = [];
        foreach ($fields as $key => $field) {
            foreach ($columns as $key2 => $column) {
                if ($key === $key2) {
                    $result[$table][$field] = $column;
                }
            }
        }

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

        return $data;
    }

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

        foreach ($methods as $method) {
            if (isset($extra[$method])) {
                $sql .= ' '.$method.' ';
                if (is_array($extra[$method])) {
                    foreach ($extra[$method] as $group) {
                        $sql .= $group.' ';
                    }
                } else {
                    $sql .= $extra[$method].' ';
                }
            }
        }

        if (isset($extra['LIMIT'])) {
            if (is_array($extra['LIMIT'])) {
                if (isset($extra['LIMIT'][1])) {
                    $offset = $extra['LIMIT'][0];
                    $limit = $extra['LIMIT'][1];
                } else {
                    $offset = 0;
                    $limit = $extra['LIMIT'][0];
                }
                $sql .= 'LIMIT '.$offset.', '.$limit;
            }
        }

        $sql = str_replace('  ', ' ', $sql);

        return $sql;
    }

    private static function buildWhere($tableName, $where)
    {
        $whereSql = '';
        if ($where && is_array($where)) {
            $skip = false;
            foreach ($where as $key => $value) {
                $fk = $key;
                if (is_array($value)) {
                    $skip = true;
                    $f = trim($value[0]);
                } else {
                    $f = trim($value);
                }
                break;
            }
            if (!$skip && isset(self::$mock[$tableName][$fk])) {

                if (is_numeric($f)) {

                    $whereSql .= ' WHERE '.self::$mock[$tableName][$fk]." = $f";
                } else {
                    $whereSql .= ' WHERE '.self::$mock[$tableName][$fk]." = '".addslashes(trim($f))."'";
                }
            } else {
                if (!$skip && is_numeric($f)) {
                    $whereSql .= ' WHERE '.$fk." = $f";
                } elseif (!$skip && !is_numeric($f)) {
                    $whereSql .= ' WHERE '.$fk." = '".addslashes(trim($f))."'";
                } elseif ($skip && is_numeric($fk)) {
                    $whereSql .= " WHERE $f";
                }
            }
            unset($where[$fk]);
            if ($where && is_array($where)) {

                foreach ($where as $key => $value) {
                    $skip = is_array($value);
                    if (!$skip && isset(self::$mock[$tableName][$key])) {

                        if (is_numeric($value)) {
                            $whereSql .= ' AND '.self::$mock[$tableName][$key]." = $value";
                        } else {
                            $whereSql .= ' AND '.self::$mock[$tableName][$key]." = '".addslashes(trim($value))."'";
                        }
                    } else {
                        if (!$skip && is_numeric($value)) {
                            $whereSql .= ' AND '.$key." = $value";
                        } elseif (!$skip && !is_numeric($f)) {
                            $whereSql .= ' AND '.$key." = '".addslashes(trim($value))."'";
                        } elseif ($skip && is_numeric($key)) {
                            $whereSql .= " AND {$value[0]}";
                        }
                    }
                }
            }
        }

        return $whereSql;
    }

    public static function findNextId($tableName, &$out = null)

    {
        $sql = "
            SELECT
                AUTO_INCREMENT
            FROM
                information_schema.tables
            WHERE
                table_name = '".$tableName."'
            AND
                table_schema = DATABASE()
        ";
        if ($out) {
            $out = $sql;
        }
        $sth = self::$connection->prepare($sql);
        $sth->execute();
        $result = $sth->fetch();

        if (isset($result['AUTO_INCREMENT'])) {
            return (int)$result['AUTO_INCREMENT'];
        }

        return 1;
    }

    public static function get($object, $one = false, $where = [], $noFkCheck = true, $fields = [], $manager = null, $extra = [], &$out = null)

    {
        self::init($noFkCheck, $manager);
        if (is_object($object)) {
            self::extract($object);
            $tableName = self::$tableName;
        } else {
            $tableName = $object;
        }
        $whereSql = self::buildWhere($tableName, $where);
        $select = (isset($extra['MODE']) ? 'SELECT '.$extra['MODE'] : 'SELECT').' ';
        if (!$fields) {
            $sql = $select.'id FROM '.$tableName.' '.$whereSql;
        } else {
            $sql = $select.(implode(', ', $fields)).' FROM '.$tableName.' '.$whereSql;
        }
        if (!empty($extra)) {
            $extraSql = self::buildExtra($tableName, $extra);
            $sql .= $extraSql;
        }
        if ($out) {
            $out = $sql;
        }
        $sth = self::$connection->prepare($sql);
        $sth->execute();
        $result = $sth->fetchAll();
        if ($one && $result) {
            if (!$fields) {
                return intval($result[0]['id']);
            } else {
                if (count($fields) === 1 && $fields[0] !== '*') {
                    return $result[0][$fields[0]];
                } else {
                    return $result[0];
                }
            }
        }

        self::close($noFkCheck);
        if ($one || !$result) {
            return null;
        }

        $field = null;
        if (!$fields) {
            $field = 'id';
        } elseif (count($fields) === 1 && $fields[0] !== '*') {
            $field = $fields[0];
        }

        if ($field) {
            foreach ($result as &$res) {
                $res = $res[$field];
            }
        }

        return $result;
    }

    public static function persist($object, $full = false, $extraFields = [], $noFkCheck = false, $manager = null, &$out = null)
    {
        self::init($noFkCheck, $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) ?: [];
        }

        $id = self::findNextId($tableName);
        $keys = [];
        $values = [];

        if (!empty($extraFields) && isset($extraFields[$tableName])) {

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

        if ($type === 'object') {
            foreach ($columns as $value => $key) {
                $variable = null;
                if (!is_array($key) && !is_array($value)) {
                    if ($object->{'get'.ucfirst($value)}() instanceof \DateTime) {
                        $variable = "'".addslashes(trim($object->{'get'.ucfirst($value)}()->format('Y-m-d H:i:s')))."'";
                    } else {
                        $variable = "'".addslashes(trim($object->{'get'.ucfirst($value)}()))."'";
                    }
                    if (trim($variable) === '' || trim($variable) === "''" || (is_numeric($variable) && $variable === 0)) {

                        $variable = null;
                    }
                    if ($variable) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
                        $values[] = $variable;
                        $keys[] = $key;
                        if ($key === 'id') {
                            $idd = $object->{'get'.ucfirst($value)}();
                        }
                    }
                }
            }
        } else {
            foreach ($columns as $value => $key) {
                $variable = null;
                if (!is_array($key) && !is_array($value) && isset($object[$value])) {
                    if ($object[$value] instanceof \DateTime) {
                        $variable = "'".addslashes(trim($object[$value]->format('Y-m-d H:i:s')))."'";
                    } else {
                        $variable = "'".addslashes(trim($object[$value]))."'";
                    }
                    if (trim($variable) === '' || trim($variable) === "''" || (is_numeric($variable) && $variable === 0)) {

                        $variable = null;
                    }
                    if ($variable) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
                        $values[] = $variable;
                        $keys[] = $key;
                        if ($key === 'id') {
                            $idd = $object[$value];
                        }
                    }
                }
            }
        }

        $sql = null;
        if (!$full && !self::isEmpty($values)) {
            $sql = '
                INSERT INTO
                    '.$tableName.'
                        (id, '.implode(',', $keys).")
                VALUES
                    ({$id},".implode(',', $values).')
            ';
        } elseif ($full && !self::isEmpty($values)) {
            $id = $idd;

            $sql = '
                INSERT INTO
                    '.$tableName.'
                        ('.implode(',', $keys).")
                VALUES
                    (".implode(',', $values).')
            ';
        } else {
            $id = null;
        }
        if ($sql && $id) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
            if ($out) {
                $out = $sql;
            }
            $sth = self::$connection->prepare($sql);
            $sth->execute();
        }

        self::close($noFkCheck);

        return $id;
    }

    public static function update($id, $object, $extraFields = [], $noFkCheck = false, $manager = null, &$out = null)
    {
        self::init($noFkCheck, $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) ?: [];
        }

        $result = self::get($tableName, true, ['id' => $id], true, ['*']);
        unset($result['id']);

        $data = [];

        if (!empty($extraFields) && isset($extraFields[$tableName])) {

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

        $flip = array_flip($columns);
        if ($type === 'object') {
            if ($object->getId()) {
                foreach ($result as $key => $value) {
                    if ($object->{'get'.ucfirst($flip[$key])}() !== $value) {

                        $data[$columns[$flip[$key]]] = $object->{'get'.ucfirst($flip[$key])}();
                    }
                }
            } else {
                foreach ($result as $key => $value) {
                    if ($object->{'get'.ucfirst($flip[$key])}() !== null) {
                        if ($object->{'get'.ucfirst($flip[$key])}() !== $value) {

                            $data[$columns[$flip[$key]]] = $object->{'get'.ucfirst($flip[$key])}();
                        }
                    }
                }
            }
        } else {
            foreach ($result as $key => $value) {
                if (isset($object[$key]) && $object[$key] !== $value) {
                    $data[$key] = $extraFields[$key];
                }
            }

        }

        if ($data) {
            $sqlu = "
                UPDATE
                    ".$tableName."
                SET

            ";
            foreach ($data as $key => $value) {
                $meta = self::$metadata[$tableName]->getFieldMapping($flip[$key]);
                $meta = $meta['type'];
                if (in_array($meta, [
                    'boolean',
                    'integer',
                    'longint',
                ])) {
                    $value = intval($value);
                } else {
                    $value = "'".addslashes(trim($value))."'";
                }
                $sqlu .= " ".$key." = ".$value.",";
            }
            $sqlu = substr($sqlu, 0, -1);
            $sqlu .= " WHERE id = ".$id;
            if ($out) {
                $out = $sql;

            }

            $sthu = self::$connection->prepare($sqlu);
            $sthu->execute();
        }

        self::close($noFkCheck);
    }

    public static function delete($object, $where = [], $noFkCheck = false, $manager = null, &$out = null)
    {
        self::init($noFkCheck, $manager);
        if (is_object($object)) {
            self::extract($object);
            $tableName = self::$tableName;
        } else {
            $tableName = $object;
        }
        $whereSql = self::buildWhere($tableName, $where);
        $sql = 'DELETE FROM '.$tableName.' '.$whereSql;
        if ($out) {
            $out = $sql;
        }
        $sth = self::$connection->prepare($sql);
        $sth->execute();

        self::close($noFkCheck);
    }

    public static function link($object, $data, $noFkCheck = false, $manager = null, &$out = null)

    {
        self::init($noFkCheck, $manager);
        if (is_object($object)) {
            self::extract($object);
            $tableName = self::$tableName;
        } else {
            $tableName = $object;
        }
        if ($object && $data) {
            $keys = $values = [];
            foreach ($data as $key => $value) {
                $keys[] = $key;
                $values[] = $value;
            }
            $sql = "
                INSERT IGNORE INTO
                    ".$tableName."
                        (".implode(',', $keys).")
                VALUES
                    (".implode(',', $values).")
            ";
            if ($out) {
                $out = $sql;
            }
            $sth = self::$connection->prepare($sql);
            $sth->execute();
        }

        self::close($noFkCheck);
    }
}


1			<?php
2
3			namespace Sludio\HelperBundle\Script\Repository;
4
5			class QuickInsertRepository
6			{
7			private static $mock = [];
8			private static $metadata = [];
9			private static $tableName;
10
11			public static $em;
			0 ignored issues – show Comprehensibility introduced 2017-10-07 19:21 UTC by Report Bug Copy Issue Report Avoid variables with short names like $em. Configured minimum length is 3. Short variable names may make your code harder to understand. Variable names should be self-descriptive. This check looks for variable names who are shorter than a configured minimum. Loading history...
12			public static $connection;
13			public static $container;
14
15			public static function init($noFkCheck = false, $manager = null)
			0 ignored issues – show Coding Style introduced 2017-10-07 19:21 UTC by Report Bug Copy Issue Report This method's name is shorter than the configured minimum length of `5` characters. Even though PHP does not care about the name of your methods, it is generally a good practice to choose method names which can be easily understood by other human readers. Loading history...
16			{
17			global $kernel;
18
19			if ('AppCache' === get_class($kernel)) {
20			$kernel = $kernel->getKernel();
21			}
22			self::$container = $kernel->getContainer();
23
24			$manager = $manager ?: self::$container->getParameter('sludio_helper.entity.manager');
25			self::$em = self::$container->get('doctrine')->getManager($manager);
26			self::$connection = self::$em->getConnection();
27
28			if (!$noFkCheck) {
29			$sth = self::$connection->prepare('SET FOREIGN_KEY_CHECKS = 0');
30			$sth->execute();
31			}
32			}
33
34			public static function close($noFkCheck = false)
35			{
36			if (!$noFkCheck) {
37			$sth = self::$connection->prepare('SET FOREIGN_KEY_CHECKS = 1');
38			$sth->execute();

ozo2003 / HelperBundle

Branch — master (a0cc06)

QuickInsertRepository::persist() F

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like