/**
* Returns translation key (placeholder) by entity class name, field name and property code
* examples (for default scope which is 'entity'):
* [vendor].[bundle].[entity].[field].[config property]
* oro.user.group.name.label
*
* if [entity] == [bundle] -> skip it
* oro.user.first_name.label
*
* if NO fieldName -> add prefix 'entity_'
* oro.user.entity_label
* oro.user.group.entity_label
* examples (for other scopes, for instance 'test'):
* [vendor].[bundle].[entity].[field].[scope]_[config property]
* oro.user.group.name.test_label
*
* if [entity] == [bundle] -> skip it
* oro.user.first_name.test_label
*
* if NO fieldName -> add prefix 'entity_'
* oro.user.entity_test_label
* oro.user.group.entity_test_label
*
* @param string $scope
* @param string $propertyName property key: label, description, plural_label, etc.
* @param string $className
* @param string $fieldName
*
* @return string
*
* @throws \InvalidArgumentException
*/
public static function getTranslationKey($scope, $propertyName, $className, $fieldName = null)
{
if (empty($scope)) {
throw new \InvalidArgumentException('$scope must not be empty');
}
if (empty($propertyName)) {
throw new \InvalidArgumentException('$propertyName must not be empty');
}
if (empty($className)) {
throw new \InvalidArgumentException('$className must not be empty');
}
// handle 'entity' scope separately
if ($scope === 'entity') {
return EntityLabelBuilder::getTranslationKey($propertyName, $className, $fieldName);
}
$parts = EntityLabelBuilder::explodeClassName($className);
$propertyName = Inflector::tableize($scope) . '_' . $propertyName;
if ($fieldName) {
$parts[] = Inflector::tableize($fieldName);
$parts[] = $propertyName;
} else {
$parts[] = 'entity_' . $propertyName;
}
return implode('.', $parts);
}
/**
* @inheritdoc
*/
public static function tableize($word)
{
if (!isset(static::$cache['tableize'][$word])) {
static::$cache['tableize'][$word] = parent::tableize($word);
}
return static::$cache['tableize'][$word];
}
/**
* Return name
*
* @return string
*/
public function getName()
{
$classname = get_class($this);
if (preg_match('@\\\\([\\w]+)$@', $classname, $matches)) {
$classname = $matches[1];
}
return Inflector::tableize($classname);
}
/**
* Magic method to execute curl_xxx calls
*
* @param string $name Method name (should be camelized)
* @param array $arguments Method arguments
*
* @return mixed
* @throws \Exception
*/
public function __call($name, $arguments)
{
$name = Inflector::tableize($name);
if (function_exists("curl_{$name}")) {
array_unshift($arguments, $this->handle);
return call_user_func_array("curl_{$name}", $arguments);
}
throw new \Exception("Function 'curl_{$name}' do not exist, see PHP manual.");
}
public static function configureMigrationsForBundle(Application $application, $bundle, Configuration $configuration)
{
$bundle = $application->getKernel()->getBundle($bundle);
$dir = $bundle->getPath() . '/DoctrineMigrations';
$configuration->setMigrationsNamespace($bundle->getNamespace() . '\\DoctrineMigrations');
$configuration->setMigrationsDirectory($dir);
$configuration->registerMigrationsFromDirectory($dir);
$configuration->setName($bundle->getName() . ' Migrations');
$configuration->setMigrationsTableName(Inflector::tableize($bundle->getName()) . '_migration_versions');
}
/**
* Creates a name for a command that can be used throughout configuration files
*
* @return string
*/
public function getName()
{
$class = get_class($this);
$class = explode('\\', $class);
$class = $class[count($class) - 1];
$class = str_replace(array('Supra', 'Package'), '', $class);
$inflector = new Inflector();
$name = $inflector->tableize($class);
return $name;
}
/**
* Returns the translation key for the given entity property
*
* The result format for entity: [vendor].[bundle].[entity].entity_[property]
* Examples:
* label for Acme\Bundle\TestBundle\Entity\Product -> acme.test.product.entity_label
* description for Acme\Bundle\ProductBundle\Entity\Product -> acme.product.entity_label
*
* The result format for field: [vendor].[bundle].[entity].[field].[property]
* Examples:
* label for Acme\Bundle\TestBundle\Entity\Product::sellPrice -> acme.test.product.sell_price.label
* label for Acme\Bundle\ProductBundle\Entity\Product::sellPrice -> acme.product.sell_price.label
*
* @param string $propertyName
* @param string $className
* @param string|null $fieldName
*
* @return string
*/
public static function getTranslationKey($propertyName, $className, $fieldName = null)
{
$parts = self::explodeClassName($className);
if ($fieldName) {
$parts[] = Inflector::tableize($fieldName);
$parts[] = $propertyName;
} else {
$parts[] = 'entity_' . $propertyName;
}
return implode('.', $parts);
}
public static function configureMigrationsForBundle(Application $application, $bundle, Configuration $configuration)
{
$configuration->setMigrationsNamespace($bundle . '\\DoctrineMigrations');
$dirs = $application->getKernel()->getBundleDirs();
$tmp = str_replace('\\', '/', $bundle);
$namespace = str_replace('/', '\\', dirname($tmp));
$bundle = basename($tmp);
$dir = $dirs[$namespace] . '/' . $bundle . '/DoctrineMigrations';
$configuration->setMigrationsDirectory($dir);
$configuration->registerMigrationsFromDirectory($dir);
$configuration->setName($bundle . ' Migrations');
$configuration->setMigrationsTableName(Inflector::tableize($bundle) . '_migration_versions');
}
public function getDirname($model)
{
$className = get_class($model);
if (isset($this->basedirs[$className])) {
$basedir = $this->basedirs[$className];
} else {
$reflection = new \ReflectionClass($className);
$basedir = $this->basedirs[$className] = Inflector::tableize($reflection->getShortName());
}
$id = sprintf('%012s', $model->id);
// Format
// $basedir / id[0..4] / id[5..8] / id[9..12]
// $basedir / 0000 / 0000 / 0001
return sprintf('%s/%04s/%04s/%04s', $basedir, substr($id, 0, 4), substr($id, 5, 4), substr($id, 9, 4));
}
/**
* Map domain model to DTO.
*
* @param \Staffim\DTOBundle\Model\ModelInterface $model
* @return object $dto
*/
public function map(ModelInterface $model, $parentPropertyName = null)
{
$dto = $this->factory->create($model);
$properties = get_object_vars($dto);
// @todo trigger pre event
foreach ($properties as $propertyName => $property) {
$this->updateProperty($model, $dto, $propertyName, $parentPropertyName);
}
if ($this->eventDispatcher) {
$event = new PostMapEvent($model, $dto);
$modelClassParts = explode('\\', get_class($model));
$modelName = \Doctrine\Common\Util\Inflector::tableize(end($modelClassParts));
$this->eventDispatcher->dispatch('dto.' . $modelName . '.post_map', $event);
}
return $dto;
}
/**
* @param BundleInterface $bundle
* @param string $entity
* @param string $format
* @param array $fields
*
* @return EntityGeneratorResult
*
* @throws \Doctrine\ORM\Tools\Export\ExportException
*/
public function generate(BundleInterface $bundle, $entity, $format, array $fields)
{
// configure the bundle (needed if the bundle does not contain any Entities yet)
$config = $this->registry->getManager(null)->getConfiguration();
$config->setEntityNamespaces(array_merge(array($bundle->getName() => $bundle->getNamespace() . '\\Entity'), $config->getEntityNamespaces()));
$entityClass = $this->registry->getAliasNamespace($bundle->getName()) . '\\' . $entity;
$entityPath = $bundle->getPath() . '/Entity/' . str_replace('\\', '/', $entity) . '.php';
if (file_exists($entityPath)) {
throw new \RuntimeException(sprintf('Entity "%s" already exists.', $entityClass));
}
$class = new ClassMetadataInfo($entityClass);
$class->customRepositoryClassName = str_replace('\\Entity\\', '\\Repository\\', $entityClass) . 'Repository';
$class->mapField(array('fieldName' => 'id', 'type' => 'integer', 'id' => true));
$class->setIdGeneratorType(ClassMetadataInfo::GENERATOR_TYPE_AUTO);
foreach ($fields as $field) {
$class->mapField($field);
}
$entityGenerator = $this->getEntityGenerator();
if ('annotation' === $format) {
$entityGenerator->setGenerateAnnotations(true);
$class->setPrimaryTable(array('name' => Inflector::tableize($entity)));
$entityCode = $entityGenerator->generateEntityClass($class);
$mappingPath = $mappingCode = false;
} else {
$cme = new ClassMetadataExporter();
$exporter = $cme->getExporter('yml' == $format ? 'yaml' : $format);
$mappingPath = $bundle->getPath() . '/Resources/config/doctrine/' . str_replace('\\', '.', $entity) . '.orm.' . $format;
if (file_exists($mappingPath)) {
throw new \RuntimeException(sprintf('Cannot generate entity when mapping "%s" already exists.', $mappingPath));
}
$mappingCode = $exporter->exportClassMetadata($class);
$entityGenerator->setGenerateAnnotations(false);
$entityCode = $entityGenerator->generateEntityClass($class);
}
$entityCode = str_replace(array("@var integer\n", "@var boolean\n", "@param integer\n", "@param boolean\n", "@return integer\n", "@return boolean\n"), array("@var int\n", "@var bool\n", "@param int\n", "@param bool\n", "@return int\n", "@return bool\n"), $entityCode);
$this->filesystem->mkdir(dirname($entityPath));
file_put_contents($entityPath, $entityCode);
if ($mappingPath) {
$this->filesystem->mkdir(dirname($mappingPath));
file_put_contents($mappingPath, $mappingCode);
}
$path = $bundle->getPath() . str_repeat('/..', substr_count(get_class($bundle), '\\'));
$this->getRepositoryGenerator()->writeEntityRepositoryClass($class->customRepositoryClassName, $path);
$repositoryPath = $path . DIRECTORY_SEPARATOR . str_replace('\\', DIRECTORY_SEPARATOR, $class->customRepositoryClassName) . '.php';
return new EntityGeneratorResult($entityPath, $repositoryPath, $mappingPath);
}
protected function setUp()
{
$this->importProcessor = $this->getMockBuilder('Oro\\Bundle\\IntegrationBundle\\ImportExport\\Processor\\StepExecutionAwareImportProcessor')->disableOriginalConstructor()->getMock();
$this->exportProcessor = $this->getMockBuilder('Oro\\Bundle\\IntegrationBundle\\ImportExport\\Processor\\StepExecutionAwareExportProcessor')->disableOriginalConstructor()->getMock();
$this->importProcessor->expects($this->any())->method('process')->will($this->returnCallback(function ($item) {
$keys = array_map(function ($key) {
return Inflector::camelize($key);
}, array_keys($item));
return (object) array_combine($keys, array_values($item));
}));
$this->exportProcessor->expects($this->any())->method('process')->will($this->returnCallback(function ($item) {
$item = (array) $item;
$keys = array_map(function ($key) {
return Inflector::tableize($key);
}, array_keys($item));
return array_combine($keys, array_values($item));
}));
$this->strategy = new TwoWaySyncStrategy($this->importProcessor, $this->exportProcessor);
}
/**
* @param object $entity
* @return array|null
*/
protected function _serializeEntity($entity)
{
$className = get_class($entity);
$metadata = $this->_em->getClassMetadata($className);
$data = array();
foreach ($metadata->fieldMappings as $field => $mapping) {
$value = $metadata->reflFields[$field]->getValue($entity);
$field = Inflector::tableize($field);
if ($value instanceof \DateTime) {
// We cast DateTime to array to keep consistency with array result
$data[$field] = (array) $value;
} elseif (is_object($value)) {
$data[$field] = (string) $value;
} else {
$data[$field] = $value;
}
}
foreach ($metadata->associationMappings as $field => $mapping) {
$key = Inflector::tableize($field);
if ($mapping['isCascadeDetach']) {
$data[$key] = $metadata->reflFields[$field]->getValue($entity);
if (null !== $data[$key]) {
$data[$key] = $this->_serializeEntity($data[$key]);
}
} elseif ($mapping['isOwningSide'] && $mapping['type'] & ClassMetadata::TO_ONE) {
if (null !== $metadata->reflFields[$field]->getValue($entity)) {
if ($this->_recursionDepth < $this->_maxRecursionDepth) {
$this->_recursionDepth++;
$data[$key] = $this->_serializeEntity($metadata->reflFields[$field]->getValue($entity));
$this->_recursionDepth--;
} else {
$data[$key] = $this->getEntityManager()->getUnitOfWork()->getEntityIdentifier($metadata->reflFields[$field]->getValue($entity));
}
} else {
// In some case the relationship may not exist, but we want
// to know about it
$data[$key] = null;
}
}
}
return $data;
}
/**
* Convenient method that intercepts the find*By*() calls.
*
* @param string $method
* @param array $arguments
* @return method
* @throws RuntimeException
*/
public function __call($method, $arguments)
{
if (strpos($method, 'findOneBy') === 0) {
$property = substr($method, 9);
$method = 'findOneBy';
} elseif (strpos($method, 'findBy') === 0) {
$property = substr($method, 6);
$method = 'findBy';
} else {
throw new RuntimeException(sprintf("The %s repository class does not have a method %s", get_called_class(), $method));
}
$property = Inflector::tableize($property);
foreach ($arguments as $position => $argument) {
if (is_object($argument)) {
if (!method_exists($argument, 'getRid')) {
throw new RuntimeException("When calling \$repository->find*By*(), you can only pass, as arguments, objects that have the getRid() method (shortly, entitites)");
}
$arguments[$position] = $argument->getRid();
}
}
return $this->{$method}(array($property => $arguments[0]));
}
public function toDOMDocument()
{
$arrToXml = function ($node, $data) use(&$arrToXml) {
foreach ($data as $k => $v) {
$child = $node->ownerDocument->createElement($k);
$node->appendChild($child);
if (is_array($v)) {
$arrToXml($child, $v);
} else {
$child->appendChild($node->ownerDocument->createTextNode($v));
}
}
};
$className = get_class($this);
$em = ActiveEntityRegistry::getClassManager($className);
$class = $em->getClassMetadata($className);
$dom = new \DOMDocument('1.0', 'UTF-8');
$root = $dom->createElement(Inflector::tableize($class->reflClass->getShortName()));
$dom->appendChild($root);
$arrToXml($root, $this->toArray());
return $dom;
}
/**
* Reverse engineering of the model from the database structure.
* Write result to the entity folder
*
* WARNING THIS WILL OVERWRITE EXISTING MODEL.
*
* @return boolean
*/
public function generate_model()
{
if (!$this->is_dev()) {
return false;
}
$root = $this->get_entity_path();
$connection_parameters = $this->get_connection_parameters();
$connection = Doctrine\DBAL\DriverManager::getConnection($connection_parameters);
$platform = $connection->getDatabasePlatform();
$platform->registerDoctrineTypeMapping('enum', 'string');
$platform->registerDoctrineTypeMapping('set', 'string');
$config = Setup::createConfiguration($this->is_dev());
$config->setMetadataDriverImpl(new Doctrine\ORM\Mapping\Driver\DatabaseDriver(new Doctrine\DBAL\Schema\MySqlSchemaManager($connection)));
$em = EntityManager::create($connection, $config);
$cmf = new Doctrine\ORM\Tools\DisconnectedClassMetadataFactory();
$cmf->setEntityManager($em);
$metadatas = $cmf->getAllMetadata();
$repo_factory = new EntityRepositoryGenerator();
$course = null;
foreach ($metadatas as $metadata) {
$n = strtolower($metadata->name);
if ($n == 'course') {
$course = $metadata;
break;
}
}
foreach ($metadatas as $metadata) {
echo sprintf('Processing entity "<info>%s</info>"', $metadata->name) . '<br/>';
foreach ($metadata->identifier as $key => $value) {
//$mapping = $metadata->fieldMappings[$value];
$metadata->identifier[$key] = Inflector::tableize($value);
}
$fields = array();
foreach ($metadata->fieldMappings as $fieldMapping) {
$name = Inflector::tableize($fieldMapping['fieldName']);
$fieldMapping['fieldName'] = $name;
$fields[$name] = $fieldMapping;
}
$metadata->fieldMappings = $fields;
$n = $metadata->name;
if ($n == 'CDocument') {
$i = 1;
}
$name = $metadata->name;
$name = Inflector::tableize($name);
$is_course_table = strpos($name, 'c_') === 0;
if ($is_course_table) {
$name = substr($name, 2, strlen($name) - 2);
}
//$metadata->namespace = 'Entity';
$metadata->customRepositoryClassName = 'Entity\\Repository\\' . Inflector::classify($name) . 'Repository';
//if(is_course_table){
$metadata->name = 'Entity\\' . Inflector::classify($name);
$metadata->lifecycleCallbacks['prePersist'] = array('before_save');
//}
//$metadata->rootEntityName = Inflector::classify($name);
if ($is_course_table) {
foreach ($metadata->fieldMappings as $mapping) {
$name = $mapping['columnName'];
$is_id = isset($mapping['id']) ? $mapping['id'] : false;
if ($name != 'c_id' && $is_id) {
}
}
}
if ($is_course_table) {
$metadata->is_course_table = true;
// $mapping = array();
// $mapping['cascade'] = array();
// $mapping['joinColumns'][0] = array('name' => 'c_id', 'referencedColumnName' => 'id');
// $mapping['sourceToTargetKeyColumns']['c_id'] = 'id';
// $mapping['joinColumnFieldNames']['c_id'] = 'c_id';
// $mapping['targetToSourceKeyColumns']['id'] = 'c_id';
// $mapping['id'] = 1;
// $mapping['isOwningSide'] = 0;
// $mapping['isCascadeRemove'] = 0;
// $mapping['isCascadePersist'] = 0;
// $mapping['isCascadeRefresh'] = 0;
// $mapping['isCascadeMerge'] = 0;
// $mapping['isCascadeDetach'] = 0;
// $mapping['orphanRemoval'] = 0;
// $mapping['type'] = ClassMetadataInfo::MANY_TO_ONE;
// $mapping['fetch'] = ClassMetadataInfo::FETCH_LAZY;
// $mapping['fieldName'] = 'course';
// $mapping['targetEntity'] = 'Entity\\Course';
// $mapping['sourceEntity'] = $metadata->name;
//
// $metadata->associationMappings['course'] = $mapping;
// $metadata->identifier['course'];
// unset($metadata->identifier['c_id']);
// unset($metadata->fieldMappings['c_id']);
// $mapping = array();
// $mapping['cascade'] = array();
// $mapping['joinColumns'][0] = array('name' => 'id', 'referencedColumnName' => 'c_id');
// $mapping['sourceToTargetKeyColumns']['id'] = 'c_id';
// $mapping['joinColumnFieldNames']['id'] = 'id';
// $mapping['targetToSourceKeyColumns']['c_id'] = 'id';
// $mapping['id'] = 1;
// $mapping['isOwningSide'] = 1;
// $mapping['isCascadeRemove'] = 0;
// $mapping['isCascadePersist'] = 0;
// $mapping['isCascadeRefresh'] = 0;
// $mapping['isCascadeMerge'] = 0;
// $mapping['isCascadeDetach'] = 0;
// $mapping['orphanRemoval'] = 0;
// $mapping['type'] = ClassMetadataInfo::ONE_TO_MANY;
// $mapping['fetch'] = ClassMetadataInfo::FETCH_LAZY;
// $name = explode('\\' ,$metadata->name);
// $name = end($name);
// $name = Inflector::tableize($name);
// $mapping['fieldName'] = $name;
// $mapping['targetEntity'] = $metadata->name;
// $mapping['sourceEntity'] = 'Entity\\Course';
// $course->associationMappings[$name] = $mapping;
}
$metadata->class_to_extend = $is_course_table ? 'CourseEntity' : 'Entity';
$repo_factory->writeEntityRepositoryClass($metadata->name, $root . '\\repository\\');
}
$generator = new EntityGenerator();
$generator->setClassToExtend('Entity');
$generator->setGenerateAnnotations(false);
$generator->setGenerateStubMethods(true);
$generator->setRegenerateEntityIfExists(false);
$generator->setUpdateEntityIfExists(false);
$generator->setBackupExisting(false);
$generator->setExtension('.class.php');
$generator->setNumSpaces(4);
// Generating Entities
$generator->generate($metadatas, $root);
$exporter = new \Doctrine\ORM\Tools\Export\Driver\YamlExporter();
$exporter->setOutputDir($root . '/mapping');
foreach ($metadatas as $metadata) {
echo $metadata->name . '<br/>';
try {
$exporter->setMetadata(array($metadata));
$exporter->export();
} catch (Exception $e) {
echo $e->getMessage();
}
}
}
protected function getColumn($class, $property)
{
if (isset($this->cache[$class . '::' . $property])) {
return $this->cache[$class . '::' . $property];
}
$table = $this->getTable($class);
if ($table && $table->hasColumn($property)) {
return $this->cache[$class . '::' . $property] = $table->getColumn($property);
} else {
foreach ($table->getColumns() as $column) {
if (Inflector::tableize($column->getPhpName()) === $property) {
return $this->cache[$class . '::' . $property] = $column;
}
}
}
}
/**
* @return string
*/
protected function getAlias()
{
$name = basename(str_replace('\\', '/', $this->getClassName()));
return Inflector::tableize($name);
}
private function _generateEntityStubMethod(ClassMetadataInfo $metadata, $type, $fieldName, $typeHint = null, $defaultValue = null)
{
$fieldName = Inflector::tableize($fieldName);
if ($type == "add") {
$addMethod = explode("\\", $typeHint);
$addMethod = end($addMethod);
$methodName = $type . $addMethod;
} else {
//change
$methodName = $type . '_' . Inflector::tableize($fieldName);
//
}
if ($this->_hasMethod($methodName, $metadata)) {
return;
}
$this->_staticReflection[$metadata->name]['methods'][] = $methodName;
$var = sprintf('_%sMethodTemplate', $type);
$template = self::$$var;
$variableType = $typeHint ? $typeHint . ' ' : null;
$types = \Doctrine\DBAL\Types\Type::getTypesMap();
$methodTypeHint = $typeHint && !isset($types[$typeHint]) ? '\\' . $typeHint . ' ' : null;
$replacements = array(
'<description>' => ucfirst($type) . ' ' . $fieldName,
'<methodTypeHint>' => $methodTypeHint,
'<variableType>' => $variableType,
'<variableName>' => 'value',
'<methodName>' => $methodName,
'<fieldName>' => $fieldName,
'<variableDefault>' => ($defaultValue !== null ) ? (' = ' . $defaultValue) : '',
'<entity>' => $this->_getClassName($metadata)
);
$method = str_replace(
array_keys($replacements), array_values($replacements), $template
);
return $this->_prefixCodeWithSpaces($method);
}
/**
* Serialize an entity to an array
*
* @author Boris Guéry <*****@*****.**>
* @license http://sam.zoy.org/wtfpl/COPYING
* @link http://borisguery.github.com/bgylibrary
* @see https://gist.github.com/1034079#file_serializable_entity.php
* @param $entity
* @return array
*/
protected function serializeEntity($entity)
{
if ($entity instanceof \Doctrine\ORM\Proxy\Proxy) {
/** @var $entity \Doctrine\ORM\Proxy\Proxy */
$entity->__load();
$className = get_parent_class($entity);
} else {
$className = get_class($entity);
}
$metadata = $this->getClassMetadata($className);
$data = array();
foreach ($metadata->fieldMappings as $field => $mapping) {
$data[$field] = $metadata->reflFields[$field]->getValue($entity);
}
foreach ($metadata->associationMappings as $field => $mapping) {
$key = Inflector::tableize($field);
if ($mapping['isCascadeDetach']) {
$data[$key] = $metadata->reflFields[$field]->getValue($entity);
if (null !== $data[$key]) {
$data[$key] = $this->serializeEntity($data[$key]);
}
} elseif ($mapping['isOwningSide'] && $mapping['type'] & ClassMetadata::TO_ONE) {
if (null !== $metadata->reflFields[$field]->getValue($entity)) {
$data[$key] = $this->getUnitOfWork()->getEntityIdentifier($metadata->reflFields[$field]->getValue($entity));
} else {
// In some case the relationship may not exist, but we want
// to know about it
$data[$key] = null;
}
}
}
return $data;
}
/**
* return string@
*/
public function getTableName()
{
if (!isset($this->tableName)) {
return \Doctrine\Common\Util\Inflector::tableize($this->getEntityName()) . 's';
}
return $this->tableName;
}
/**
* Tries to guess block template name.
* @return string
*/
private function guessTemplateName()
{
if ($this->package === null) {
throw new \RuntimeException(sprintf('Block package is unknown, thus it is impossible to guess template name for block [%s].', $this->getTitle()));
}
$name = (new \ReflectionClass($this))->getShortName();
if (($pos = strpos($name, 'Config')) !== false && $pos === strlen($name) - 6) {
$name = substr($name, 0, -6);
}
return $this->package->getName() . ':blocks' . DIRECTORY_SEPARATOR . Inflector::tableize($name) . '.html.twig';
}
/**
* {@inheritdoc}
*/
public function loadMetadataForClass($className, ClassMetadataInfo $metadata)
{
$this->reverseEngineerMappingFromDatabase();
if (!isset($this->classes[$className])) {
throw new \InvalidArgumentException("Unknown class " . $className);
}
$tableName = Inflector::tableize($className);
$metadata->name = $className;
$metadata->table['name'] = $tableName;
$columns = $this->tables[$tableName]->getColumns();
$indexes = $this->tables[$tableName]->getIndexes();
if ($this->_sm->getDatabasePlatform()->supportsForeignKeyConstraints()) {
$foreignKeys = $this->tables[$tableName]->getForeignKeys();
} else {
$foreignKeys = array();
}
$allForeignKeyColumns = array();
foreach ($foreignKeys as $foreignKey) {
$allForeignKeyColumns = array_merge($allForeignKeyColumns, $foreignKey->getLocalColumns());
}
$ids = array();
$fieldMappings = array();
foreach ($columns as $column) {
$fieldMapping = array();
if (isset($indexes['primary']) && in_array($column->getName(), $indexes['primary']->getColumns())) {
$fieldMapping['id'] = true;
} else {
if (in_array($column->getName(), $allForeignKeyColumns)) {
continue;
}
}
$fieldMapping['fieldName'] = Inflector::camelize(strtolower($column->getName()));
$fieldMapping['columnName'] = $column->getName();
$fieldMapping['type'] = strtolower((string) $column->getType());
if ($column->getType() instanceof \Doctrine\DBAL\Types\StringType) {
$fieldMapping['length'] = $column->getLength();
$fieldMapping['fixed'] = $column->getFixed();
} else {
if ($column->getType() instanceof \Doctrine\DBAL\Types\IntegerType) {
$fieldMapping['unsigned'] = $column->getUnsigned();
}
}
$fieldMapping['nullable'] = $column->getNotNull() ? false : true;
if (isset($fieldMapping['id'])) {
$ids[] = $fieldMapping;
} else {
$fieldMappings[] = $fieldMapping;
}
}
if ($ids) {
if (count($ids) == 1) {
$metadata->setIdGeneratorType(ClassMetadataInfo::GENERATOR_TYPE_AUTO);
}
foreach ($ids as $id) {
$metadata->mapField($id);
}
}
foreach ($fieldMappings as $fieldMapping) {
$metadata->mapField($fieldMapping);
}
foreach ($this->manyToManyTables as $manyTable) {
foreach ($manyTable->getForeignKeys() as $foreignKey) {
if ($tableName == strtolower($foreignKey->getForeignTableName())) {
$myFk = $foreignKey;
foreach ($manyTable->getForeignKeys() as $foreignKey) {
if ($foreignKey != $myFk) {
$otherFk = $foreignKey;
break;
}
}
$localColumn = current($myFk->getColumns());
$associationMapping = array();
$associationMapping['fieldName'] = Inflector::camelize(str_replace('_id', '', strtolower(current($otherFk->getColumns()))));
$associationMapping['targetEntity'] = Inflector::classify(strtolower($otherFk->getForeignTableName()));
if (current($manyTable->getColumns())->getName() == $localColumn) {
$associationMapping['inversedBy'] = Inflector::camelize(str_replace('_id', '', strtolower(current($myFk->getColumns()))));
$associationMapping['joinTable'] = array('name' => strtolower($manyTable->getName()), 'joinColumns' => array(), 'inverseJoinColumns' => array());
$fkCols = $myFk->getForeignColumns();
$cols = $myFk->getColumns();
for ($i = 0; $i < count($cols); $i++) {
$associationMapping['joinTable']['joinColumns'][] = array('name' => $cols[$i], 'referencedColumnName' => $fkCols[$i]);
}
$fkCols = $otherFk->getForeignColumns();
$cols = $otherFk->getColumns();
for ($i = 0; $i < count($cols); $i++) {
$associationMapping['joinTable']['inverseJoinColumns'][] = array('name' => $cols[$i], 'referencedColumnName' => $fkCols[$i]);
}
} else {
$associationMapping['mappedBy'] = Inflector::camelize(str_replace('_id', '', strtolower(current($myFk->getColumns()))));
}
$metadata->mapManyToMany($associationMapping);
break;
}
}
}
foreach ($foreignKeys as $foreignKey) {
$foreignTable = $foreignKey->getForeignTableName();
$cols = $foreignKey->getColumns();
$fkCols = $foreignKey->getForeignColumns();
$localColumn = current($cols);
$associationMapping = array();
$associationMapping['fieldName'] = Inflector::camelize(str_replace('_id', '', strtolower($localColumn)));
$associationMapping['targetEntity'] = Inflector::classify($foreignTable);
for ($i = 0; $i < count($cols); $i++) {
$associationMapping['joinColumns'][] = array('name' => $cols[$i], 'referencedColumnName' => $fkCols[$i]);
}
$metadata->mapManyToOne($associationMapping);
}
}
/**
* @test
* @dataProvider routes
*
* @param $actionClass
*/
public function it_returns_the_correct_route_names($actionClass)
{
$refl = new \ReflectionClass($actionClass);
$name = Inflector::tableize($refl->getShortName());
$this->assertEquals($this->bundlePrefix . '.posts.' . $name, $this->config->getActions()->get($actionClass)->getRouteName());
}
/**
* @param string $className
* @param array $model
* @param ClassMetadataInfo $metadata
*
* @return void
*/
private function convertRelations($className, array $model, ClassMetadataInfo $metadata)
{
if (empty($model['relations'])) {
return;
}
foreach ($model['relations'] as $name => $relation) {
if (!isset($relation['alias'])) {
$relation['alias'] = $name;
}
if (!isset($relation['class'])) {
$relation['class'] = $name;
}
if (!isset($relation['local'])) {
$relation['local'] = Inflector::tableize($relation['class']);
}
if (!isset($relation['foreign'])) {
$relation['foreign'] = 'id';
}
if (!isset($relation['foreignAlias'])) {
$relation['foreignAlias'] = $className;
}
if (isset($relation['refClass'])) {
$type = 'many';
$foreignType = 'many';
$joinColumns = array();
} else {
$type = isset($relation['type']) ? $relation['type'] : 'one';
$foreignType = isset($relation['foreignType']) ? $relation['foreignType'] : 'many';
$joinColumns = array(array('name' => $relation['local'], 'referencedColumnName' => $relation['foreign'], 'onDelete' => isset($relation['onDelete']) ? $relation['onDelete'] : null));
}
if ($type == 'one' && $foreignType == 'one') {
$method = 'mapOneToOne';
} elseif ($type == 'many' && $foreignType == 'many') {
$method = 'mapManyToMany';
} else {
$method = 'mapOneToMany';
}
$associationMapping = array();
$associationMapping['fieldName'] = $relation['alias'];
$associationMapping['targetEntity'] = $relation['class'];
$associationMapping['mappedBy'] = $relation['foreignAlias'];
$associationMapping['joinColumns'] = $joinColumns;
$metadata->{$method}($associationMapping);
}
}
/**
*
* @param type $name
* @param type $outputDirectory
*/
public function writeEntityRepositoryClass($name, $outputDirectory)
{
$name = explode('\\', $name);
$name = end($name);
$name = Inflector::tableize($name);
$is_course_table = (strpos($name, 'c_') === 0);
if ($is_course_table) {
$name = substr($name, 2, strlen($name) - 2);
}
$name = Inflector::classify($name) . 'Repository';
$fullClassName = $name;
$file_name = Inflector::tableize($name);
$code = $this->generateEntityRepositoryClass($fullClassName);
$path = $outputDirectory . DIRECTORY_SEPARATOR
. str_replace('\\', \DIRECTORY_SEPARATOR, $file_name) . '.class.php';
$dir = dirname($path);
if (!is_dir($dir)) {
mkdir($dir, 0777, true);
}
if (!file_exists($path)) {
file_put_contents($path, $code);
}
}
public function __isset($field)
{
if ($this->_valueExists($field)) {
return true;
}
$_field = Inflector::tableize($field);
if ($_field != $field && $this->_valueExists($_field)) {
return true;
}
$_field = Inflector::camelize($field);
if ($_field != $field && $this->_valueExists($_field)) {
return true;
}
return false;
}
private function tableize($className)
{
return Inflector::tableize(str_replace('\\', '', $className));
}
/**
* @param Text $text
*
* @return Slug
*/
public function slugify(Text $text)
{
return new Slug(Inflector::tableize((string) $text));
}
public function fieldsAsArray()
{
$fields = array();
$refclass = new \ReflectionClass($this);
foreach ($refclass->getMethods(\ReflectionMethod::IS_PUBLIC) as $method) {
$name = $methodName = $method->getName();
if (preg_match('/^get/', $name)) {
$name = substr($name, 3);
$name = \Doctrine\Common\Util\Inflector::tableize($name);
$name = str_replace(array('t_v_a', 'h_t', 't_t_c'), array('TVA', 'HT', 'TTC'), $name);
$fields[$name] = $this->{$methodName}();
}
}
return $fields;
}
