objectmanager::undelete() - Code Metrics - Inspection of "Add support for result iteration" - flack/midgard-portable - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 5ddfed...8c3fc7 )

by Andreas

created 2017-10-08 16:44 UTC

objectmanager::undelete() A

↳ Parent: objectmanager

Complexity

Conditions	1
Paths	1

Size

Total Lines	9
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	7
CRAP Score	1

Importance

Changes

Metric	Value
cc	1
eloc	6
nc	1
nop	1
dl	0
loc	9
ccs	7
cts	7
cp	1
crap	1
rs	9.6666
c	0
b	0
f	0

<?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
 */

namespace midgard\portable\storage;

use midgard\portable\api\dbobject;
use midgard\portable\api\error\exception;
use midgard\portable\storage\interfaces\metadata;
use Doctrine\ORM\EntityManager;
use Doctrine\ORM\Proxy\Proxy;
use Doctrine\ORM\UnitOfWork;
use Doctrine\Common\Util\ClassUtils;
use midgard_datetime;

class objectmanager
{
    private $em;

    public function __construct(EntityManager $em)
function someFunction(ManagerRegistry $registry) {
    $em = $registry->getManager();
    $em->getConnection()->beginTransaction();
    try {
        // Do something.
        $em->getConnection()->commit();
    } catch (\Exception $ex) {
        $em->getConnection()->rollback();
        $em->close();

        throw $ex;
    }
}
    {
        $this->em = $em;
    }

    public function create(dbobject $entity)
    {
        foreach ($this->em->getClassMetadata(get_class($entity))->getAssociationNames() as $name) {
            if (!empty($entity->$name)) {
                //This makes sure that we don't have stale references
                $entity->$name = $entity->$name;
            }
        }

        //workaround for possible oid collisions in UnitOfWork
        //see http://www.doctrine-project.org/jira/browse/DDC-2785
        if ($this->em->getUnitOfWork()->getEntityState($entity) != UnitOfWork::STATE_NEW) {

            connection::log()->warning('oid collision during create detected, detaching ' . spl_object_hash($entity));
            $this->em->detach($entity);
        }

        $this->em->persist($entity);
        $this->em->flush($entity);
        $this->em->detach($entity);
    }

    public function update(dbobject $entity)
    {
        // if entities are loaded by querybuilder, they are managed at this point already,
        // which can in very rare (and very unreproducable) circumstances lead to the update
        // getting lost silently (because originalEntityData somehow is empty), so we detach
        // before doing anything else
        $this->em->detach($entity);
        $merged = $this->em->merge($entity);
        $this->copy_associations($entity, $merged);
        $this->em->persist($merged);
        $this->em->flush($merged);
        $this->em->detach($merged);
        $this->copy_metadata($merged, $entity);
    }

    /**
     * This is basically a workaround for some quirks when merging detached entities with changed associations
     *
     * @todo: This may or may not be a bug in Doctrine
     */
    private function copy_associations($source, $target)
    {
        foreach ($this->em->getClassMetadata(get_class($source))->getAssociationNames() as $name) {
            $target->$name = $source->$name;
        }
    }

    private function kill_potential_proxies($entity)
    {
        $classname = ClassUtils::getRealClass(get_class($entity));
        $cm = $this->em->getClassMetadata($classname);
        $changed_associations = $entity->__get_changed_associations();

        foreach ($cm->getAssociationNames() as $name) {
            if ($entity->$name === 0) {
                //This is necessary to kill potential proxy objects pointing to purged entities
                $entity->$name = 0;
            } elseif (!array_key_exists($name, $changed_associations)) {
                $value = $cm->getReflectionProperty($name)->getValue($entity);
                if ($value instanceof Proxy) {
                    //This makes sure that the associated entity doesn't end up in the changeset calculation
                    $value->__isInitialized__ = false;
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
                    continue;
                }
            }
        }
    }

    public function delete(dbobject $entity)
    {
        //we might deal with a proxy here, so we translate the classname
        $classname = ClassUtils::getRealClass(get_class($entity));
        $copy = new $classname($entity->id);
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}

        //workaround for possible oid collisions in UnitOfWork
        //see http://www.doctrine-project.org/jira/browse/DDC-2785
        if ($this->em->getUnitOfWork()->getEntityState($copy) != UnitOfWork::STATE_DETACHED) {

            connection::log()->warning('oid collision during delete detected, detaching ' . spl_object_hash($copy));
            $this->em->detach($copy);
        }

        $copy = $this->em->merge($copy);
        $this->kill_potential_proxies($copy);
        $copy->metadata_deleted = true;

        $this->em->persist($copy);
        $this->em->flush($copy);
        $this->em->detach($copy);
        $this->em->detach($entity);
        $this->copy_metadata($copy, $entity, 'delete');
    }

    public function undelete(dbobject $entity)
    {
        $entity->metadata_deleted = false;
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
        $this->kill_potential_proxies($entity);

        $this->em->persist($entity);
        $this->em->flush($entity);
        $this->em->detach($entity);
    }

    public function purge(dbobject $entity)
    {
        $this->em->getFilters()->disable('softdelete');
        try {
            $entity = $this->em->merge($entity);
        } finally {
            $this->em->getFilters()->enable('softdelete');
        }
        $this->em->remove($entity);
        $this->em->flush($entity);
        $this->em->detach($entity);
    }

    public function approve(dbobject $entity)

    {
        $user = connection::get_user();
        $ref = $this->em->getReference(get_class($entity), $entity->id);
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
        $ref->metadata_isapproved = true;
        $ref->metadata_approver = $user->person;
        $ref->metadata_approved = new midgard_datetime;

        $this->em->persist($ref);
        $this->em->flush($ref);
        $this->em->detach($entity);
        $this->copy_metadata($ref, $entity, 'approve');
    }

    public function unapprove(dbobject $entity)

    {
        $user = connection::get_user();
        $ref = $this->em->getReference(get_class($entity), $entity->id);
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
        $ref->metadata_isapproved = false;
        $ref->metadata_approver = $user->person;
        $ref->metadata_approved = new midgard_datetime;

        $this->em->persist($ref);
        $this->em->flush($ref);
        $this->em->detach($entity);
        $this->copy_metadata($ref, $entity, 'approve');
    }

    public function lock(dbobject $entity)

    {
        $user = connection::get_user();
        $ref = $this->em->getReference(get_class($entity), $entity->id);
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
        $ref->metadata_islocked = true;
        $ref->metadata_locker = $user->person;
        $ref->metadata_locked = new midgard_datetime;

        $this->em->persist($ref);
        $this->em->flush($ref);
        $this->em->detach($entity);
        $this->copy_metadata($ref, $entity, 'lock');
    }

    public function unlock(dbobject $entity)
    {
        $ref = $this->em->getReference(get_class($entity), $entity->id);
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
        $ref->metadata_islocked = false;

        $this->em->persist($ref);
        $this->em->flush($ref);
        $this->em->detach($entity);
        $this->copy_metadata($ref, $entity, 'lock');
    }

    /**
     * @param string $classname
     * @return dbobject
     */
    public function new_instance($classname)
    {
        //workaround for possible oid collisions in UnitOfWork
        //see http://www.doctrine-project.org/jira/browse/DDC-2785
        $counter = 0;
        $candidates = [];
        do {
            $entity = new $classname;
            if ($counter++ > 100) {
                throw new exception('Failed to create fresh ' . $classname . ' instance (all tried oids are already known to UoW)');
            }
            //we keep the entity in memory to make sure we get a different oid during the next iteration
            $candidates[] = $entity;
        } while ($this->em->getUnitOfWork()->getEntityState($entity) !== UnitOfWork::STATE_NEW);
        // TODO: Calling $em->getUnitOfWork()->isInIdentityMap($entity) returns false in the same situation. Why?
        return $entity;
    }

    private function copy_metadata($source, $target, $action = 'update')
    {
        if (!$source instanceof metadata) {
            return;
        }

        $target->metadata_revised = $source->metadata_revised;
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
        $target->metadata_revisor = $source->metadata_revisor;
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
        $target->metadata_revision = $source->metadata_revision;
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}

        if ($action == 'lock') {
            $target->metadata_islocked = $source->metadata_islocked;
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            $target->metadata_locker = $source->metadata_locker;
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            $target->metadata_locked = $source->metadata_locked;
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
        } elseif ($action == 'approve') {
            $target->metadata_isapproved = $source->metadata_isapproved;
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            $target->metadata_approver = $source->metadata_approver;
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            $target->metadata_approved = $source->metadata_approved;
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
        } elseif ($action == 'delete') {
            $target->metadata_deleted = $source->metadata_deleted;
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
        }
    }
}


Push — master ( 5ddfed...8c3fc7 )

objectmanager::undelete() A

Complexity

Size

Duplication

Code Coverage

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

1			<?php
2			/**
3			* @author CONTENT CONTROL http://www.contentcontrol-berlin.de/
4			* @copyright CONTENT CONTROL http://www.contentcontrol-berlin.de/
5			* @license http://www.gnu.org/licenses/gpl.html GNU General Public License
6			*/
7
8			namespace midgard\portable\storage;
9
10			use midgard\portable\api\dbobject;
11			use midgard\portable\api\error\exception;
12			use midgard\portable\storage\interfaces\metadata;
13			use Doctrine\ORM\EntityManager;
14			use Doctrine\ORM\Proxy\Proxy;
15			use Doctrine\ORM\UnitOfWork;
16			use Doctrine\Common\Util\ClassUtils;
17			use midgard_datetime;
18
19			class objectmanager
20			{
21			private $em;
22
23	114		public function __construct(EntityManager $em)
			0 ignored issues – show Bug introduced 2017-09-12 12:48 UTC by Report Bug Copy Issue Report You have injected the EntityManager via parameter `$em`. This is generally not recommended as it might get closed and become unusable. Instead, it is recommended to inject the ManagerRegistry and retrieve the EntityManager via `getManager()` each time you need it. The `EntityManager` might become unusable for example if a transaction is rolled back and it gets closed. Let’s assume that somewhere in your application, or in a third-party library, there is code such as the following: function someFunction(ManagerRegistry $registry) { $em = $registry->getManager(); $em->getConnection()->beginTransaction(); try { // Do something. $em->getConnection()->commit(); } catch (\Exception $ex) { $em->getConnection()->rollback(); $em->close(); throw $ex; } } If that code throws an exception and the `EntityManager` is closed. Any other code which depends on the same instance of the `EntityManager` during this request will fail. On the other hand, if you instead inject the `ManagerRegistry`, the `getManager()` method guarantees that you will always get a usable manager instance. Loading history...
24			{
25	114		$this->em = $em;
26	114		}
27
28	114		public function create(dbobject $entity)
29			{
30	114		foreach ($this->em->getClassMetadata(get_class($entity))->getAssociationNames() as $name) {
31	101		if (!empty($entity->$name)) {
32			//This makes sure that we don't have stale references
33	30		$entity->$name = $entity->$name;
34	30		}
35	114		}
36
37			//workaround for possible oid collisions in UnitOfWork
38			//see http://www.doctrine-project.org/jira/browse/DDC-2785
39	114	View Code Duplication	if ($this->em->getUnitOfWork()->getEntityState($entity) != UnitOfWork::STATE_NEW) {

flack / midgard-portable

Push — master ( 5ddfed...8c3fc7 )

objectmanager::undelete() A

Complexity

Size

Duplication

Code Coverage

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like