/sbweb/sbweb_logica/lib/symfony/plugins/sfDoctrinePlugin/lib/vendor/doctrine/Doctrine/Data/Import.php

<?php

/*

 *  $Id: Import.php 2552 2007-09-19 19:33:00Z Jonathan.Wage $

 *

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 *

 * This software consists of voluntary contributions made by many individuals

 * and is licensed under the LGPL. For more information, see

 * <http://www.phpdoctrine.org>.

 */



/**

 * Doctrine_Data_Import

 *

 * @package     Doctrine

 * @package     Data

 * @author      Jonathan H. Wage <jwage@mac.com>

 * @license     http://www.opensource.org/licenses/lgpl-license.php LGPL

 * @link        www.phpdoctrine.org

 * @since       1.0

 * @version     $Revision: 2552 $

 */

class Doctrine_Data_Import extends Doctrine_Data

{

    /**

     * Array of imported objects for processing and saving

     *

     * @var array

     */

    protected $_importedObjects = array();



    /**

     * Array of the raw data parsed from yaml

     *

     * @var array

     */

    protected $_rows = array();



    /**

     * Optionally pass the directory/path to the yaml for importing

     *

     * @param string $directory

     * @return void

     */

    public function __construct($directory = null)

    {

        if ($directory !== null) {

            $this->setDirectory($directory);

        }

    }



    /**

     * Do the parsing of the yaml files and return the final parsed array

     *

     * @return array $array

     */

    public function doParsing()

    {

        $recursiveMerge = Doctrine_Manager::getInstance()->getAttribute('recursive_merge_fixtures');

        $mergeFunction = $recursiveMerge === true ? 'array_merge_recursive':'array_merge';

        $directory = $this->getDirectory();



        $array = array();



        if ($directory !== null) {

            foreach ((array) $directory as $dir) {

                $e = explode('.', $dir);



                // If they specified a specific yml file

                if (end($e) == 'yml') {

                    $array = $mergeFunction($array, Doctrine_Parser::load($dir, $this->getFormat()));

                // If they specified a directory

                } else if(is_dir($dir)) {

                    $it = new RecursiveIteratorIterator(new RecursiveDirectoryIterator($dir),

                                                            RecursiveIteratorIterator::LEAVES_ONLY);



                    foreach ($it as $file) {

                        $e = explode('.', $file->getFileName());

                        if (in_array(end($e), $this->getFormats())) {

                            $array = $mergeFunction($array, Doctrine_Parser::load($file->getPathName(), $this->getFormat()));

                        }

                    }

                }

            }

        }



        return $array;

    }



    /**

     * Do the importing of the data parsed from the fixtures

     *

     * @return void

     */

    public function doImport($append = false)

    {

        $array = $this->doParsing();



        if ( ! $append) {

            $this->purge(array_reverse(array_keys($array)));

        }



        $this->_loadData($array);

    }



    /**

     * Recursively loop over all data fixtures and build the array of className rows

     *

     * @return void

     */

    protected function _buildRows($className, $data)

    {

        foreach ($data as $rowKey => $row) {

            // do the same for the row information

            $this->_rows[$className][$rowKey] = $row;



            foreach ((array) $row as $key => $value) {

                if (Doctrine::getTable($className)->hasRelation($key) && is_array($value)) {

                    $keys = array_keys($value);



                    // Skip associative arrays defining keys to relationships

                    if ( ! isset($keys[0])) {

                        $this->_buildRows(Doctrine::getTable($className)->getRelation($key)->getTable()->getOption('name'), $value);

                    }

                }

            }

        }

    }



    /**

     * Build the rows for nested set models

     *

     * @return void

     */

    protected function _buildNestedSetRows($className, $data)

    {

        foreach ($data as $rowKey => $row) {

            $children = isset($row['children']) ? $row['children']:array();

            unset($row['children']);

            $this->_rows[$className][$rowKey] = $row;



            $this->_buildNestedSetRows($className, $children);

        }

    }



    /**

     * Get the unsaved object for a specified row key and validate that it is the valid object class

     * for the passed record and relation name

     *

     * @param  string $rowKey

     * @param  Doctrine_Record $record

     * @param  string $relationName

     * @param  string $referringRowKey

     * @return Doctrine_Record

     * @throws Doctrine_Data_Exception

     */

    protected function _getImportedObject($rowKey, Doctrine_Record $record, $relationName, $referringRowKey)

    {

        if ( ! isset($this->_importedObjects[$rowKey])) {

            throw new Doctrine_Data_Exception('Invalid row key specified: ' . $rowKey);

        }



        $relatedRowKeyObject = $this->_importedObjects[$rowKey];



        $relation = $record->getTable()->getRelation($relationName);

        if ($relation->getClass() !== get_class($relatedRowKeyObject)) {

            if ( ! is_subclass_of($relatedRowKeyObject, $relation->getClass())) {

                throw new Doctrine_Data_Exception(sprintf(

                    'Class referred to in "%s" is expected to be "%s" and "%s" was given',

                    $referringRowKey, $relation->getClass(), get_class($relatedRowKeyObject)));

            }

        }



        return $relatedRowKeyObject;

    }



    /**

     * Process a row and make all the appropriate relations between the imported data

     *

     * @param string $rowKey

     * @param string $row

     * @return void

     */

    protected function _processRow($rowKey, $row)

    {

        $obj = $this->_importedObjects[$rowKey];



        foreach ((array) $row as $key => $value) {

            if (method_exists($obj, 'set' . Doctrine_Inflector::classify($key))) {

                $func = 'set' . Doctrine_Inflector::classify($key);

                $obj->$func($value);

            } else if ($obj->getTable()->hasField($key)) {

                $obj->set($key, $value);

            } else if ($obj->getTable()->hasRelation($key)) {

                if (is_array($value)) {

                    if (isset($value[0]) && ! is_array($value[0])) {

                        foreach ($value as $link) {

                            if ($obj->getTable()->getRelation($key)->getType() === Doctrine_Relation::ONE) {

                                $obj->set($key, $this->_getImportedObject($link, $obj, $key, $rowKey));

                            } else if ($obj->getTable()->getRelation($key)->getType() === Doctrine_Relation::MANY) {

                                $relation = $obj->$key;



                                $relation[] = $this->_getImportedObject($link, $obj, $key, $rowKey);

                            }

                        }

                    } else {

                        $obj->$key->fromArray($value);

                    }

                } else {

                    $obj->set($key, $this->_getImportedObject($value, $obj, $key, $rowKey));

                }

            // used for Doctrine plugin methods (Doctrine_Template)

            } else if (is_callable(array($obj, 'set' . Doctrine_Inflector::classify($key)))) {

              $func = 'set' . Doctrine_Inflector::classify($key);

              $obj->$func($value);

            } else {

                throw new Doctrine_Data_Exception('Invalid fixture element "'. $key . '" under "' . $rowKey . '"');

            }

        }

    }



   /**

    * NestedSet fixtures may come in a 'natural' format with nested children listed under a 'children'

    * key or in a raw, non-nested format with lft/rgt values.

    *

    * This method returns true if the given $data is a nested set in 'natural' form.

    *

    * @param $className

    * @param $data

    * @return boolean

    */

    protected function _hasNaturalNestedSetFormat($className, array $data) {

		$first = current($data);

		return isset($first['children']) && Doctrine::getTable($className)->isTree();

    }

    /**

     * Perform the loading of the data from the passed array

     *

     * @param string $array

     * @return void

     */

    protected function _loadData(array $array)

    {

        $nestedSets = array();



        $specifiedModels = $this->getModels();

        $rows = array();



        foreach ($array as $className => $data) {

            if ( ! empty($specifiedModels) && !in_array($className, $specifiedModels)) {

                continue;

            }



            // if loaded data is a nested set in natural format, process through _buildNestedSetRows.

            // 'raw' nested sets and all other models are processed through _buildRows.

            if ($this->_hasNaturalNestedSetFormat($className, $data)) {

                $nestedSets[$className][] = $data;

                $this->_buildNestedSetRows($className, $data);

            } else {

                $this->_buildRows($className, $data);

            }

        }



        $buildRows = array();

        foreach ($this->_rows as $className => $classRows) {

            foreach ($classRows as $rowKey => $row) {

                $buildRows[$rowKey] = $row;

                $this->_importedObjects[$rowKey] = new $className();

                $this->_importedObjects[$rowKey]->state('TDIRTY');

            }

        }



        foreach($buildRows as $rowKey => $row) {

            $this->_processRow($rowKey, $row);

        }



        // save natural nested set fixture data and unset from _importedObjects

        foreach ($nestedSets as $className => $sets) {

            foreach ($sets as $data) {

                $this->_loadNestedSetData($className, $data);

            }

        }



        $objects = array();

        foreach ($this->_importedObjects as $object) {

            $className = get_class($object);

            $objects[$className] = $className;

        }



        $manager = Doctrine_Manager::getInstance();

        foreach ($manager as $connection) {

            $tree = $connection->unitOfWork->buildFlushTree($objects);



            foreach ($tree as $model) {

                foreach ($this->_importedObjects as $obj) {



                    if ($obj instanceof $model) {

                        $obj->save();

                    }

                }

            }

        }



    }



    /**

     * Load nested set data for models with nested set enabled

     *

     * @param string $model

     * @param string $nestedSetData

     * @param string $parent

     * @return void

     */

    protected function _loadNestedSetData($model, $nestedSetData, $parent = null)

    {

        foreach($nestedSetData AS $rowKey => $nestedSet) {

            $children = array();

            $data  = array();



            if (array_key_exists('children', $nestedSet)) {

                $children = $nestedSet['children'];

                $children = array_reverse($children, true);

                unset($nestedSet['children']);

            }



            $record = $this->_importedObjects[$rowKey];

            // remove this nested set from _importedObjects so it's not processed in the save routine for normal objects

            unset($this->_importedObjects[$rowKey]);



            if( ! $parent) {

                $record->save(); // save, so that createRoot can do: root id = id

                Doctrine::getTable($model)->getTree()->createRoot($record);

            } else {

                $parent->getNode()->addChild($record);

            }



            if (is_array($children) AND !empty($children)) {

                $this->_loadNestedSetData($model, $children, $record);

            }

        }

    }

}