midgard_storage

Complexity

Total Complexity

22

Size/Duplication

Total Lines	156
Duplicated Lines	7.69 %

Coupling/Cohesion

Components	1
Dependencies	12

Test Coverage

Coverage

90.53%

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	get_cm()	0	19	4
A	delete_class_storage()	0	3	1
A	create_class_storage()	0	17	3
A	generate_proxyfile()	0	10	2
B	create_base_storage()	0	40	5
A	class_storage_exists()	0	10	2
B	update_class_storage()	0	31	5

<?php
/**
 * @author CONTENT CONTROL http://www.contentcontrol-berlin.de/
 * @copyright CONTENT CONTROL http://www.contentcontrol-berlin.de/
 * @license http://www.gnu.org/licenses/gpl.html GNU General Public License
 */

use Doctrine\Common\Persistence\Mapping\ClassMetadata;
use Doctrine\Common\Proxy\ProxyGenerator;
use Doctrine\DBAL\Schema\Comparator;
use Doctrine\ORM\Tools\SchemaTool;
use Doctrine\ORM\Mapping\MappingException;
use midgard\portable\storage\connection;

class midgard_storage
{
    public static function create_base_storage()
    {
        $em = connection::get_em();
        $ns = $em->getConfiguration()->getEntityNamespace("midgard");

        $cm_repligard = $em->getClassMetadata($ns . '\\midgard_repligard');
        if (!self::create_class_storage($cm_repligard->getName())) {
            return false;
        }
        $cm_person = $em->getClassMetadata($ns . '\\midgard_person');
        if (!self::create_class_storage($cm_person->getName())) {
            return false;
        }
        $cm_user = $em->getClassMetadata($ns . '\\midgard_user');
        if (!self::create_class_storage($cm_user->getName())) {
            return false;
        }

        $admin = $em->find('midgard:midgard_user', 1);

        if ($admin === null) {
            $fqcn = $cm_person->getName();
            $person = new $fqcn;
            $person->firstname = 'Midgard';
            $person->lastname = 'Administrator';
            $person->create();

            $fqcn = $cm_user->getName();
            $admin = new $fqcn;
            $admin->authtype = 'Plaintext';
            $admin->authtypeid = 2;
            $admin->login = 'admin';
            $admin->password = 'password';
            $admin->active = true;
            $admin->usertype = 2;
            $admin->set_person($person);
            $admin->create();
        }

        return true;
    }

    public static function create_class_storage($classname)
    {
        $em = connection::get_em();

        $cm = self::get_cm($em, $classname);
        if ($cm === false) {
            return false;
        }

        if (!$em->getConnection()->getSchemaManager()->tablesExist([$cm->getTableName()])) {
            $tool = new SchemaTool($em);
            $tool->createSchema([$cm]);
        }

        self::generate_proxyfile($cm);

        return true;
    }

    private static function generate_proxyfile(ClassMetadata $cm)
    {
        $em = connection::get_em();
        $generator = new ProxyGenerator($em->getConfiguration()->getProxyDir(), $em->getConfiguration()->getProxyNamespace());
        $generator->setPlaceholder('baseProxyInterface', 'Doctrine\ORM\Proxy\Proxy');
        $filename = $generator->getProxyFileName($cm->getName());
        if (file_exists($filename)) {
            unlink($filename);
        }
        $generator->generateProxyClass($cm, $filename);
    }

    private static function get_cm($em, $classname)
    {
        if (!class_exists($classname)) {
            // if the class doesn't exist (e.g. for some_random_string), there is really nothing we could do
            return false;
        }

        $factory = $em->getMetadataFactory();
        try {
            return $factory->getMetadataFor($classname);
        } catch (MappingException $e) {
            // add namespace
            $classname = $em->getConfiguration()->getEntityNamespace("midgard") . '\\' . $classname;
            try {
                return $factory->getMetadataFor($classname);
            } catch (MappingException $e) {
                // check for merged classes (duplicate tablenames)
                $classname = get_class(new $classname);
                return $factory->getMetadataFor($classname);
            }
        }
    }

    /**
     * Update DB table according to MgdSchema information.
     *
     * this does not use SchemaTool's updateSchema, since this would delete columns that are no longer
     * in the MgdSchema definition
     *
     * @param string $classname The MgdSchema class to work on
     */
    public static function update_class_storage($classname)
    {
        $em = connection::get_em();
        $cm = self::get_cm($em, $classname);
        if ($cm === false) {
            return false;
        }
        $sm = $em->getConnection()->getSchemaManager();
        if ($sm->tablesExist([$cm->getTableName()])) {
            $tool = new SchemaTool($em);
            $conn = $em->getConnection();
            $from = $sm->createSchema();
            $to = $tool->getSchemaFromMetadata([$cm]);

            $comparator = new Comparator;
            $diff = $comparator->compare($from, $to);
            if (!empty($diff->changedTables[$cm->getTableName()]->removedColumns)) {
                $diff->changedTables[$cm->getTableName()]->removedColumns = [];
            }
            $sql = $diff->toSaveSql($conn->getDatabasePlatform());


            foreach ($sql as $sql_line) {
                $conn->executeQuery($sql_line);
            }

            self::generate_proxyfile($cm);

            return true;
        }
        return false;
    }

    public static function delete_class_storage($classname)

The parameter $classname is not used and could be removed.

    {
        return false;
    }

    public static function class_storage_exists($classname)
    {
        $em = connection::get_em();

        $cm = self::get_cm($em, $classname);
        if ($cm === false) {
            return false;
        }

        return $em->getConnection()->getSchemaManager()->tablesExist([$cm->getTableName()]);
    }
}