{

/**

protected $language;

/**

protected $languages = array();

/**

protected $cache_xml_entity = array();

/**

protected $errors = array();

protected $data_path;

protected $lang_path;

protected $img_path;

public $path_type;

protected $ids = array();

protected $primaries = array();

protected $delayed_inserts = array();

public function __construct()

{

$this->language = InstallLanguages::getInstance();

$this->setDefaultPath();

}

/**

public function setLanguages(array $languages)

{

$this->languages = $languages;

}

public function setDefaultPath()

{

$this->path_type = 'common';

$this->data_path = _PS_INSTALL_DATA_PATH_.'xml/';

$this->lang_path = _PS_INSTALL_LANGS_PATH_;

$this->img_path = _PS_INSTALL_DATA_PATH_.'img/';

}

public function setFixturesPath($path = null)

{

if ($path === null) {

$path = _PS_INSTALL_FIXTURES_PATH_.'fashion/';

}

$this->path_type = 'fixture';

$this->data_path = $path.'data/';

$this->lang_path = $path.'langs/';

$this->img_path = $path.'img/';

}

/**

public function getErrors()

{

return $this->errors;

}

/**

public function setError($error)

{

$this->errors[] = $error;

}

/**

public function storeId($entity, $identifier, $id)

{

$this->ids[$entity.':'.$identifier] = $id;

}

/**

public function retrieveId($entity, $identifier)

{

return isset($this->ids[$entity.':'.$identifier]) ? $this->ids[$entity.':'.$identifier] : 0;

}

public function getIds()

{

return $this->ids;

}

public function setIds($ids)

{

$this->ids = $ids;

}

public function getSortedEntities()

{

// Browse all XML files from data/xml directory

$entities = array();

$dependencies = array();

$fd = opendir($this->data_path);

while ($file = readdir($fd)) {

if (preg_match('#^(.+)\.xml$#', $file, $m)) {

$entity = $m[1];

$xml = $this->loadEntity($entity);

// Store entities dependencies (with field type="relation")

if ($xml->fields) {

foreach ($xml->fields->field as $field) {

if ($field['relation'] && $field['relation'] != $entity) {

if (!isset($dependencies[(string)$field['relation']])) {

$dependencies[(string)$field['relation']] = array();

}

$dependencies[(string)$field['relation']][] = $entity;

}

}

}

$entities[] = $entity;

}

}

closedir($fd);

// Sort entities to populate database in good order (E.g. zones before countries)

do {

$current = (isset($sort_entities)) ? $sort_entities : array();

$sort_entities = array();

foreach ($entities as $key => $entity) {

if (isset($dependencies[$entity])) {

$min = count($entities) - 1;

foreach ($dependencies[$entity] as $item) {

if (($key = array_search($item, $sort_entities)) !== false) {

$min = min($min, $key);

}

}

if ($min == 0) {

array_unshift($sort_entities, $entity);

} else {

array_splice($sort_entities, $min, 0, array($entity));

}

} else {

$sort_entities[] = $entity;

}

}

$entities = $sort_entities;

} while ($current != $sort_entities);

return $sort_entities;

}

/**

public function populateFromXmlFiles()

{

$entities = $this->getSortedEntities();

// Populate entities

foreach ($entities as $entity) {

$this->populateEntity($entity);

}

}

/**

public function populateEntity($entity)

{

if (method_exists($this, 'populateEntity'.Tools::toCamelCase($entity))) {

$this->{'populateEntity'.Tools::toCamelCase($entity)}();

return;

}

if (substr($entity, 0, 1) == '.' || substr($entity, 0, 1) == '_') {

return;

}

$xml = $this->loadEntity($entity);

// Read list of fields

if (!is_object($xml) || !$xml->fields) {

throw new PrestashopInstallerException('List of fields not found for entity '.$entity);

}

if ($this->isMultilang($entity)) {

$multilang_columns = $this->getColumns($entity, true);

$xml_langs = array();

$default_lang = null;

foreach ($this->languages as $id_lang => $iso) {

if ($iso == $this->language->getLanguageIso()) {

$default_lang = $id_lang;

}

try {

$xml_langs[$id_lang] = $this->loadEntity($entity, $iso);

} catch (PrestashopInstallerException $e) {

$xml_langs[$id_lang] = null;

}

}

}

// Load all row for current entity and prepare data to be populated

foreach ($xml->entities->$entity as $node) {

$data = array();

$identifier = (string)$node['id'];

// Read attributes

foreach ($node->attributes() as $k => $v) {

if ($k != 'id') {

$data[$k] = (string)$v;

}

}

// Read cdatas

foreach ($node->children() as $child) {

$data[$child->getName()] = (string)$child;

}

// Load multilang data

$data_lang = array();

if ($this->isMultilang($entity)) {

$xpath_query = $entity.'[@id="'.$identifier.'"]';

foreach ($xml_langs as $id_lang => $xml_lang) {

if (!$xml_lang) {

continue;

}

if (($node_lang = $xml_lang->xpath($xpath_query)) || ($node_lang = $xml_langs[$default_lang]->xpath($xpath_query))) {

$node_lang = $node_lang[0];

foreach ($multilang_columns as $column => $is_text) {

$value = '';

if ($node_lang[$column]) {

$value = (string)$node_lang[$column];

}

if ($node_lang->$column) {

$value = (string)$node_lang->$column;

}

$data_lang[$column][$id_lang] = $value;

}

}

}

}

$data = $this->rewriteRelationedData($entity, $data);

if (method_exists($this, 'createEntity'.Tools::toCamelCase($entity))) {

// Create entity with custom method in current class

$method = 'createEntity'.Tools::toCamelCase($entity);

$this->$method($identifier, $data, $data_lang);

} else {

$this->createEntity($entity, $identifier, (string)$xml->fields['class'], $data, $data_lang);

}

if ($xml->fields['image']) {

if (method_exists($this, 'copyImages'.Tools::toCamelCase($entity))) {

$this->{'copyImages'.Tools::toCamelCase($entity)}($identifier, $data);

} else {

$this->copyImages($entity, $identifier, (string)$xml->fields['image'], $data);

}

}

}

$this->flushDelayedInserts();

unset($this->cache_xml_entity[$this->path_type][$entity]);

}

protected function getFallBackToDefaultLanguage($iso)

{

return file_exists($this->lang_path.$iso.'/data/') ? $iso : 'en';

}

/**

public function populateEntityTag()

{

foreach ($this->languages as $id_lang => $iso) {

if (!file_exists($this->lang_path.$this->getFallBackToDefaultLanguage($iso).'/data/tag.xml')) {

continue;

}

$xml = $this->loadEntity('tag', $this->getFallBackToDefaultLanguage($iso));

$tags = array();

foreach ($xml->tag as $tag_node) {

$products = trim((string)$tag_node['products']);

if (!$products) {

continue;

}

foreach (explode(',', $products) as $product) {

$product = trim($product);

$product_id = $this->retrieveId('product', $product);

if (!isset($tags[$product_id])) {

$tags[$product_id] = array();

}

$tags[$product_id][] = trim((string)$tag_node['name']);

}

}

foreach ($tags as $id_product => $tag_list) {

Tag::addTags($id_lang, $id_product, $tag_list);

}

}

}

/**

protected function loadEntity($entity, $iso = null)

{

if (!isset($this->cache_xml_entity[$this->path_type][$entity][$iso])) {

if (substr($entity, 0, 1) == '.' || substr($entity, 0, 1) == '_') {

return;

}

$path = $this->data_path.$entity.'.xml';

if ($iso) {

$path = $this->lang_path.$this->getFallBackToDefaultLanguage($iso).'/data/'.$entity.'.xml';

}

if (!file_exists($path)) {

throw new PrestashopInstallerException('XML data file '.$entity.'.xml not found');

}

$this->cache_xml_entity[$this->path_type][$entity][$iso] = @simplexml_load_file($path, 'InstallSimplexmlElement');

if (!$this->cache_xml_entity[$this->path_type][$entity][$iso]) {

throw new PrestashopInstallerException('XML data file '.$entity.'.xml invalid');

}

}

return $this->cache_xml_entity[$this->path_type][$entity][$iso];

}

/**

protected function rewriteRelationedData($entity, array $data)

{

$xml = $this->loadEntity($entity);

foreach ($xml->fields->field as $field) {

if ($field['relation']) {

$id = $this->retrieveId((string)$field['relation'], $data[(string)$field['name']]);

if (!$id && $data[(string)$field['name']] && is_numeric($data[(string)$field['name']])) {

$id = $data[(string)$field['name']];

}

$data[(string)$field['name']] = $id;

}

}

return $data;

}

public function flushDelayedInserts()

{

foreach ($this->delayed_inserts as $entity => $queries) {

$type = Db::INSERT_IGNORE;

if ($entity == 'access') {

$type = Db::REPLACE;

}

if (!Db::getInstance()->insert($entity, $queries, false, true, $type)) {

$this->setError($this->language->l('An SQL error occurred for entity <i>%1$s</i>: <i>%2$s</i>', $entity, Db::getInstance()->getMsgError()));

}

unset($this->delayed_inserts[$entity]);

}

}

/**

public function createEntity($entity, $identifier, $classname, array $data, array $data_lang = array())

{

$xml = $this->loadEntity($entity);

if ($classname) {

// Create entity with ObjectModel class

$object = new $classname();

$object->hydrate($data);

if ($data_lang) {

$object->hydrate($data_lang);

}

$object->add(true, (isset($xml->fields['null'])) ? true : false);

$entity_id = $object->id;

unset($object);

} else {

// Generate primary key manually

$primary = '';

$entity_id = 0;

if (!$xml->fields['primary']) {

$primary = 'id_'.$entity;

} elseif (strpos((string)$xml->fields['primary'], ',') === false) {

$primary = (string)$xml->fields['primary'];

}

unset($xml);

if ($primary) {

$entity_id = $this->generatePrimary($entity, $primary);

$data[$primary] = $entity_id;

}

// Store INSERT queries in order to optimize install with grouped inserts

$this->delayed_inserts[$entity][] = array_map('pSQL', $data);

if ($data_lang) {

$real_data_lang = array();

foreach ($data_lang as $field => $list) {

foreach ($list as $id_lang => $value) {

$real_data_lang[$id_lang][$field] = $value;

}

}

foreach ($real_data_lang as $id_lang => $insert_data_lang) {

$insert_data_lang['id_'.$entity] = $entity_id;

$insert_data_lang['id_lang'] = $id_lang;

$this->delayed_inserts[$entity.'_lang'][] = array_map('pSQL', $insert_data_lang);

}

// Store INSERT queries for _shop associations

$entity_asso = Shop::getAssoTable($entity);

if ($entity_asso !== false && $entity_asso['type'] == 'shop') {

$this->delayed_inserts[$entity.'_shop'][] = array(

'id_shop' => 1,

'id_'.$entity => $entity_id,

);

}

}

}

$this->storeId($entity, $identifier, $entity_id);

}

public function createEntityConfiguration($identifier, array $data, array $data_lang)

{

if (Db::getInstance()->getValue('SELECT id_configuration FROM '._DB_PREFIX_.'configuration WHERE name = \''.pSQL($data['name']).'\'')) {

return;

}

$entity = 'configuration';

$entity_id = $this->generatePrimary($entity, 'id_configuration');

$data['id_configuration'] = $entity_id;

// Store INSERT queries in order to optimize install with grouped inserts

$this->delayed_inserts[$entity][] = array_map('pSQL', $data);

if ($data_lang) {

$real_data_lang = array();

foreach ($data_lang as $field => $list) {

foreach ($list as $id_lang => $value) {

$real_data_lang[$id_lang][$field] = $value;

}

}

foreach ($real_data_lang as $id_lang => $insert_data_lang) {

$insert_data_lang['id_'.$entity] = $entity_id;

$insert_data_lang['id_lang'] = $id_lang;

$this->delayed_inserts[$entity.'_lang'][] = array_map('pSQL', $insert_data_lang);

}

}

$this->storeId($entity, $identifier, $entity_id);

}

public function createEntityStockAvailable($identifier, array $data, array $data_lang)

{

$stock_available = new StockAvailable();

$stock_available->updateQuantity($data['id_product'], $data['id_product_attribute'], $data['quantity'], $data['id_shop']);

}

public function createEntityTab($identifier, array $data, array $data_lang)

{

static $position = array();

$entity = 'tab';

$xml = $this->loadEntity($entity);

if (!isset($position[$data['id_parent']])) {

$position[$data['id_parent']] = 0;

}

$data['position'] = $position[$data['id_parent']]++;

// Generate primary key manually

$primary = '';

$entity_id = 0;

if (!$xml->fields['primary']) {

$primary = 'id_'.$entity;

} elseif (strpos((string)$xml->fields['primary'], ',') === false) {

$primary = (string)$xml->fields['primary'];

}

if ($primary) {

$entity_id = $this->generatePrimary($entity, $primary);

$data[$primary] = $entity_id;

}

// Store INSERT queries in order to optimize install with grouped inserts

$this->delayed_inserts[$entity][] = array_map('pSQL', $data);

if ($data_lang) {

$real_data_lang = array();

foreach ($data_lang as $field => $list) {

foreach ($list as $id_lang => $value) {

$real_data_lang[$id_lang][$field] = $value;

}

}

foreach ($real_data_lang as $id_lang => $insert_data_lang) {

$insert_data_lang['id_'.$entity] = $entity_id;

$insert_data_lang['id_lang'] = $id_lang;

$this->delayed_inserts[$entity.'_lang'][] = array_map('pSQL', $insert_data_lang);

}

}

$this->storeId($entity, $identifier, $entity_id);

}

public function generatePrimary($entity, $primary)

{

if (!isset($this->primaries[$entity])) {

$this->primaries[$entity] = (int)Db::getInstance()->getValue('SELECT '.$primary.' FROM '._DB_PREFIX_.$entity.' ORDER BY '.$primary.' DESC');

}

return ++$this->primaries[$entity];

}

public function copyImages($entity, $identifier, $path, array $data, $extension = 'jpg')

{

// Get list of image types

$reference = array(

'product' => 'products',

'category' => 'categories',

'manufacturer' => 'manufacturers',

'supplier' => 'suppliers',

'scene' => 'scenes',

'store' => 'stores',

);

$types = array();

if (isset($reference[$entity])) {

$types = ImageType::getImagesTypes($reference[$entity]);

}

// For each path copy images

$path = array_map('trim', explode(',', $path));

foreach ($path as $p) {

$from_path = $this->img_path.$p.'/';

$dst_path = _PS_IMG_DIR_.$p.'/';

$entity_id = $this->retrieveId($entity, $identifier);

if (!@copy($from_path.$identifier.'.'.$extension, $dst_path.$entity_id.'.'.$extension)) {

$this->setError($this->language->l('Cannot create image "%1$s" for entity "%2$s"', $identifier, $entity));

return;

}

foreach ($types as $type) {

$origin_file = $from_path.$identifier.'-'.$type['name'].'.'.$extension;

$target_file = $dst_path.$entity_id.'-'.$type['name'].'.'.$extension;

// Test if dest folder is writable

if (!is_writable(dirname($target_file))) {

$this->setError($this->language->l('Cannot create image "%1$s" (bad permissions on folder "%2$s")', $identifier.'-'.$type['name'], dirname($target_file)));

}

// If a file named folder/entity-type.extension exists just copy it, this is an optimisation in order to prevent to much resize

elseif (file_exists($origin_file)) {

if (!@copy($origin_file, $target_file)) {

$this->setError($this->language->l('Cannot create image "%s"', $identifier.'-'.$type['name']));

}

@chmod($target_file, 0644);

}

// Resize the image if no cache was prepared in fixtures

elseif (!ImageManager::resize($from_path.$identifier.'.'.$extension, $target_file, $type['width'], $type['height'])) {

$this->setError($this->language->l('Cannot create image "%1$s" for entity "%2$s"', $identifier.'-'.$type['name'], $entity));

}

}

}

Image::moveToNewFileSystem();

}

public function copyImagesScene($identifier, array $data)

{

$this->copyImages('scene', $identifier, 'scenes', $data);

$from_path = $this->img_path.'scenes/thumbs/';

$dst_path = _PS_IMG_DIR_.'scenes/thumbs/';

$entity_id = $this->retrieveId('scene', $identifier);

if (!@copy($from_path.$identifier.'-m_scene_default.jpg', $dst_path.$entity_id.'-m_scene_default.jpg')) {

$this->setError($this->language->l('Cannot create image "%1$s" for entity "%2$s"', $identifier, 'scene'));

return;

}

}

public function copyImagesOrderState($identifier, array $data)

{

$this->copyImages('order_state', $identifier, 'os', $data, 'gif');

}

public function copyImagesTab($identifier, array $data)

{

$from_path = $this->img_path.'t/';

$dst_path = _PS_IMG_DIR_.'t/';

if (file_exists($from_path.$data['class_name'].'.gif') && !file_exists($dst_path.$data['class_name'].'.gif')) {

//test if file exist in install dir and if do not exist in dest folder.

if (!@copy($from_path.$data['class_name'].'.gif', $dst_path.$data['class_name'].'.gif')) {

$this->setError($this->language->l('Cannot create image "%1$s" for entity "%2$s"', $identifier, 'tab'));

return;

}

}

}

public function copyImagesImage($identifier)

{

$path = $this->img_path.'p/';

$image = new Image($this->retrieveId('image', $identifier));

$dst_path = $image->getPathForCreation();

if (!@copy($path.$identifier.'.jpg', $dst_path.'.'.$image->image_format)) {

$this->setError($this->language->l('Cannot create image "%1$s" for entity "%2$s"', $identifier, 'product'));

return;

}

@chmod($dst_path.'.'.$image->image_format, 0644);

$types = ImageType::getImagesTypes('products');

foreach ($types as $type) {

$origin_file = $path.$identifier.'-'.$type['name'].'.jpg';

$target_file = $dst_path.'-'.$type['name'].'.'.$image->image_format;

// Test if dest folder is writable

if (!is_writable(dirname($target_file))) {

$this->setError($this->language->l('Cannot create image "%1$s" (bad permissions on folder "%2$s")', $identifier.'-'.$type['name'], dirname($target_file)));

}

// If a file named folder/entity-type.jpg exists just copy it, this is an optimisation in order to prevent to much resize

elseif (file_exists($origin_file)) {

if (!@copy($origin_file, $target_file)) {

$this->setError($this->language->l('Cannot create image "%1$s" for entity "%2$s"', $identifier.'-'.$type['name'], 'product'));

}

@chmod($target_file, 0644);

}

// Resize the image if no cache was prepared in fixtures

elseif (!ImageManager::resize($path.$identifier.'.jpg', $target_file, $type['width'], $type['height'])) {

$this->setError($this->language->l('Cannot create image "%1$s" for entity "%2$s"', $identifier.'-'.$type['name'], 'product'));

}

}

}

public function getTables()

{

static $tables = null;

if (is_null($tables)) {

$tables = array();

foreach (Db::getInstance()->executeS('SHOW TABLES') as $row) {

$table = current($row);

if (preg_match('#^'._DB_PREFIX_.'(.+?)(_lang)?$#i', $table, $m)) {

$tables[$m[1]] = (isset($m[2]) && $m[2]) ? true : false;

}

}

}

return $tables;

}

public function hasElements($table)

{

return (bool)Db::getInstance()->getValue('SELECT COUNT(*) FROM '._DB_PREFIX_.$table);

}

public function getColumns($table, $multilang = false, array $exclude = array())

{

static $columns = array();

if ($multilang) {

return ($this->isMultilang($table)) ? $this->getColumns($table.'_lang', false, array('id_'.$table)) : array();

}

if (!isset($columns[$table])) {

$columns[$table] = array();

$sql = 'SHOW COLUMNS FROM `'._DB_PREFIX_.bqSQL($table).'`';

foreach (Db::getInstance()->executeS($sql) as $row) {

$columns[$table][$row['Field']] = $this->checkIfTypeIsText($row['Type']);

}

}

$exclude = array_merge(array('id_'.$table, 'date_add', 'date_upd', 'deleted', 'id_lang'), $exclude);

$list = array();

foreach ($columns[$table] as $k => $v) {

if (!in_array($k, $exclude)) {

$list[$k] = $v;

}

}

return $list;

}

public function getClasses($path = null)

{

static $cache = null;

if (!is_null($cache)) {

return $cache;

}

$dir = $path;

if (is_null($dir)) {

$dir = _PS_CLASS_DIR_;

}

$classes = array();

foreach (scandir($dir) as $file) {

if ($file[0] != '.' && $file != 'index.php') {

if (is_dir($dir.$file)) {

$classes = array_merge($classes, $this->getClasses($dir.$file.'/'));

} elseif (preg_match('#^(.+)\.php$#', $file, $m)) {

$classes[] = $m[1];

}

}

}

sort($classes);

if (is_null($path)) {

$cache = $classes;

}

return $classes;

}

public function checkIfTypeIsText($type)

{

if (preg_match('#^(longtext|text|tinytext)#i', $type)) {

return true;

}

if (preg_match('#^varchar\(([0-9]+)\)$#i', $type, $m)) {

return intval($m[1]) >= 64 ? true : false;

}

return false;

}

public function isMultilang($entity)

{

$tables = $this->getTables();

return isset($tables[$entity]) && $tables[$entity];

}

public function entityExists($entity)

{

return file_exists($this->data_path.$entity.'.xml');

}

public function getEntitiesList()

{

$entities = array();

foreach (scandir($this->data_path) as $file) {

if ($file[0] != '.' && preg_match('#^(.+)\.xml$#', $file, $m)) {

$entities[] = $m[1];

}

}

return $entities;

}

public function getEntityInfo($entity)

{

$info = array(

'config' => array(

'id' => '',

'primary' => '',

'class' => '',

'sql' => '',

'ordersql' => '',

'image' => '',

'null' => '',

),

'fields' => array(),

);

if (!$this->entityExists($entity)) {

return $info;

}

$xml = @simplexml_load_file($this->data_path.$entity.'.xml', 'InstallSimplexmlElement');

if (!$xml) {

return $info;

}

if ($xml->fields['id']) {

$info['config']['id'] = (string)$xml->fields['id'];

}

if ($xml->fields['primary']) {

$info['config']['primary'] = (string)$xml->fields['primary'];

}

if ($xml->fields['class']) {

$info['config']['class'] = (string)$xml->fields['class'];

}

if ($xml->fields['sql']) {

$info['config']['sql'] = (string)$xml->fields['sql'];

}

if ($xml->fields['ordersql']) {

$info['config']['ordersql'] = (string)$xml->fields['ordersql'];

}

if ($xml->fields['null']) {

$info['config']['null'] = (string)$xml->fields['null'];

}

if ($xml->fields['image']) {

$info['config']['image'] = (string)$xml->fields['image'];

}

foreach ($xml->fields->field as $field) {

$column = (string)$field['name'];

$info['fields'][$column] = array();

if (isset($field['relation'])) {

$info['fields'][$column]['relation'] = (string)$field['relation'];

}

}

return $info;

}

public function getDependencies()

{

$entities = array();

foreach ($this->getEntitiesList() as $entity) {

$entities[$entity] = $this->getEntityInfo($entity);

}

$dependencies = array();

foreach ($entities as $entity => $info) {

foreach ($info['fields'] as $field => $info_field) {

if (isset($info_field['relation']) && $info_field['relation'] != $entity) {

if (!isset($dependencies[$info_field['relation']])) {

$dependencies[$info_field['relation']] = array();

}

$dependencies[$info_field['relation']][] = $entity;

}

}

}

return $dependencies;

}

public function generateEntitySchema($entity, array $fields, array $config)

{

if ($this->entityExists($entity)) {

$xml = $this->loadEntity($entity);

} else {

$xml = new InstallSimplexmlElement('<entity_'.$entity.' />');

}

unset($xml->fields);

// Fill <fields> attributes (config)

$xml_fields = $xml->addChild('fields');

foreach ($config as $k => $v) {

if ($v) {

$xml_fields[$k] = $v;

}

}

// Create list of fields

foreach ($fields as $column => $info) {

$field = $xml_fields->addChild('field');

$field['name'] = $column;

if (isset($info['relation'])) {

$field['relation'] = $info['relation'];

}

}

// Recreate entities nodes, in order to have the <entities> node after the <fields> node

$store_entities = clone $xml->entities;

unset($xml->entities);

$xml->addChild('entities', $store_entities);

$xml->asXML($this->data_path.$entity.'.xml');

}

/**

public function generateAllEntityFiles()

{

$entities = array();

foreach ($this->getEntitiesList() as $entity) {

$entities[$entity] = $this->getEntityInfo($entity);

}

$this->generateEntityFiles($entities);

}

/**

public function generateEntityFiles($entities)

{

$dependencies = $this->getDependencies();

// Sort entities to populate database in good order (E.g. zones before countries)

do {

$current = (isset($sort_entities)) ? $sort_entities : array();

$sort_entities = array();

foreach ($entities as $entity) {

if (isset($dependencies[$entity])) {

$min = count($entities) - 1;

foreach ($dependencies[$entity] as $item) {

if (($key = array_search($item, $sort_entities)) !== false) {

$min = min($min, $key);

}

}

if ($min == 0) {

array_unshift($sort_entities, $entity);

} else {

array_splice($sort_entities, $min, 0, array($entity));

}

} else {

$sort_entities[] = $entity;

}

}

$entities = $sort_entities;

} while ($current != $sort_entities);

foreach ($sort_entities as $entity) {

$this->generateEntityContent($entity);

}

}

public function generateEntityContent($entity)

{

$xml = $this->loadEntity($entity);

if (method_exists($this, 'getEntityContents'.Tools::toCamelCase($entity))) {

$content = $this->{'getEntityContents'.Tools::toCamelCase($entity)}($entity);

} else {

$content = $this->getEntityContents($entity);

}

unset($xml->entities);

$entities = $xml->addChild('entities');