DoctrineExtensions/lib/Gedmo/Tree/Strategy/ORM/Closure.php

<?php

namespace Gedmo\Tree\Strategy\ORM;

use Gedmo\Tree\Strategy,
    Doctrine\ORM\EntityManager,
    Doctrine\ORM\Proxy\Proxy,
    Gedmo\Tree\AbstractTreeListener;

/**
 * This strategy makes tree act like
 * a closure table.
 * 
 * Some Tree logic is copied from -
 * CakePHP: Rapid Development Framework (http://cakephp.org)
 * 
 * @author Gustavo Adrian <comfortablynumb84@gmail.com>
 * @author Gediminas Morkevicius <gediminas.morkevicius@gmail.com>
 * @package Gedmo.Tree.Strategy.ORM
 * @subpackage Closure
 * @link http://www.gediminasm.org
 * @license MIT License (http://www.opensource.org/licenses/mit-license.php)
 */
class Closure implements Strategy
{   
    /**
     * TreeListener
     * 
     * @var AbstractTreeListener
     */
    protected $listener = null;
    
    /**
     * List of pending Nodes, which needs to
     * be post processed because of having a parent Node
     * which requires some additional calculations
     * 
     * @var array
     */
    protected $pendingChildNodeInserts = array();
	
	/**
     * List of pending Nodes to remove
     * 
     * @var array
     */
    protected $pendingNodesForRemove = array();
    
    /**
     * {@inheritdoc}
     */
    public function __construct(AbstractTreeListener $listener)
    {
        $this->listener = $listener;
    }
    
    /**
     * {@inheritdoc}
     */
    public function getName()
    {
        return Strategy::CLOSURE;
    }
	
	/**
     * {@inheritdoc}
     */
    public function processPrePersist($em, $entity)
    {
        $this->pendingChildNodeInserts[] = $entity;
    }
    
    /**
     * {@inheritdoc}
     */
    public function processPostPersist($em, $entity)
    {        
        if (count($this->pendingChildNodeInserts)) 
		{
            while ($entity = array_shift($this->pendingChildNodeInserts)) 
            {
                $this->insertNode($em, $entity);
            }
        }
    }
    
    public function insertNode(EntityManager $em, $entity, $addNodeChildrenToAncestors = false)
    {
        $meta = $em->getClassMetadata(get_class($entity));
        $config = $this->listener->getConfiguration($em, $meta->name);
        $identifier = $meta->getSingleIdentifierFieldName();
        $id = $meta->getReflectionProperty($identifier)->getValue($entity);
        $closureMeta = $em->getClassMetadata($config['closure']);
        $entries = array();
		
		// If node has children it means it already has a self referencing row, so we skip its insertion
		if ($addNodeChildrenToAncestors === false) {
            $entries[] = array(
                'ancestor'		=> $id,
                'descendant' 	=> $id,
                'depth' 		=> 0
            );
        }
		
        $parent = $meta->getReflectionProperty($config['parent'])->getValue($entity);
		
        if ( $parent ) {
            $parentId = $meta->getReflectionProperty($identifier)->getValue($parent);
            $dql = "SELECT c.ancestor, c.depth FROM {$closureMeta->name} c";
            $dql .= " WHERE c.descendant = {$parentId}";
            $ancestors = $em->createQuery($dql)->getArrayResult();
            //echo count($ancestors);
            foreach ($ancestors as $ancestor) {
                $entries[] = array(
                    'ancestor' => $ancestor['ancestor'],
                    'descendant' => $id,
                    'depth' => $ancestor['depth'] + 1
                );
				
                if ($addNodeChildrenToAncestors === true) {
                    $dql 		= "SELECT c.descendant, c.depth FROM {$closureMeta->name} c";
                    $dql 		.= " WHERE c.ancestor = {$id} AND c.ancestor != c.descendant";
                    $children 	= $em->createQuery($dql)
                        ->getArrayResult();
                    
                    foreach ($children as $child)
                    {
                        $entries[] = array(
                            'ancestor'		=> $ancestor['ancestor'],
                            'descendant'	=> $child['descendant'],
                            'depth'			=> $child['depth'] + 1
                        );
                    }
                }
            }	
        }
        
        $table = $closureMeta->getTableName();
        foreach ($entries as $closure) {
            if (!$em->getConnection()->insert($table, $closure)) {
                throw new \Gedmo\Exception\RuntimeException('Failed to insert new Closure record');
            }
        }
    }
    
    /**
     * {@inheritdoc}
     */
    public function processScheduledUpdate($em, $entity)
    {
        $entityClass = get_class($entity);
        $config = $this->listener->getConfiguration($em, $entityClass);
        $meta = $em->getClassMetadata($entityClass);
        $uow = $em->getUnitOfWork();
        $changeSet = $uow->getEntityChangeSet($entity);
        if (array_key_exists($config['parent'], $changeSet)) {
            $this->updateNode($em, $entity, $changeSet[$config['parent']]);
        }
    }
    
    public function updateNode(EntityManager $em, $entity, array $change)
    {
        $meta = $em->getClassMetadata(get_class($entity));
        $config = $this->listener->getConfiguration($em, $meta->name);
        $closureMeta = $em->getClassMetadata($config['closure']);
        $oldParent = $change[0];
        $nodeId = $this->extractIdentifier($em, $entity);
        $table = $closureMeta->getTableName();
		
        if ($oldParent) 
		{
            $this->removeClosurePathsOfNodeID($em, $table, $nodeId);
            
            $this->insertNode($em, $entity, true);
        }
        
        //\Doctrine\Common\Util\Debug::dump($oldParent);
        //die();
    }
	
	/**
     * {@inheritdoc}
     */
    public function processScheduledDelete($em, $entity)
    {
        $this->removeNode($em, $entity);
    }
	
    public function removeNode(EntityManager $em, $entity, $maintainSelfReferencingRow = false, $maintainSelfReferencingRowOfChildren = false)
	{
        $meta = $em->getClassMetadata(get_class($entity));
        $config = $this->listener->getConfiguration($em, $meta->name);
        $closureMeta = $em->getClassMetadata($config['closure']);
        
        $this->removeClosurePathsOfNodeID($em, $closureMeta->getTableName(), $entity->getId(), $maintainSelfReferencingRow, $maintainSelfReferencingRowOfChildren);
	}
    
	public function removeClosurePathsOfNodeID(EntityManager $em, $table, $nodeId, $maintainSelfReferencingRow = true, $maintainSelfReferencingRowOfChildren = true)
	{
        $subquery = "SELECT c1.id FROM {$table} c1 ";
        $subquery .= "WHERE c1.descendant IN ( SELECT c2.descendant FROM {$table} c2 WHERE c2.ancestor = :id ) ";
        $subquery .= "AND ( c1.ancestor IN ( SELECT c3.ancestor FROM {$table} c3 WHERE c3.descendant = :id ";
        
		if ($maintainSelfReferencingRow === true)
        {
            $subquery .= "AND c3.descendant != c3.ancestor ";
        }
        
        if ( $maintainSelfReferencingRowOfChildren === false )
        {
            $subquery .= " OR c1.descendant = c1.ancestor ";
        }
        
        $subquery .= " ) ) ";
		
        $subquery = "DELETE FROM {$table} WHERE {$table}.id IN ( SELECT temp_table.id FROM ( {$subquery} ) temp_table )";
		
        if (!$em->getConnection()->executeQuery($subquery, array('id' => $nodeId))) {
            throw new \Gedmo\Exception\RuntimeException('Failed to delete old Closure records');
        }
    }
    
    private function extractIdentifier($em, $entity, $single = true)
    {
        if ($entity instanceof Proxy) {
            $id = $em->getUnitOfWork()->getEntityIdentifier($entity);
        } else {
            $meta = $em->getClassMetadata(get_class($entity));
            $id = array();
            foreach ($meta->identifier as $name) {
                $id[$name] = $meta->getReflectionProperty($name)->getValue($entity);
            }
        }
        if ($single) {
            $id = current($id);
        }
        return $id;
    }
    
    /**
     * {@inheritdoc}
     */
    public function onFlushEnd($em)
    {}
}