public function generate($jsonSchema) { $schema = json_decode($jsonSchema, true); if (!isset($schema['type']) && $schema['type'] !== 'object') { throw new \RuntimeException("Unable to process the schema"); } if (!isset($schema['title'])) { throw new \RuntimeException("title property must be defined"); } // TODO investigate implementation via ClassMetadataBuilder $className = $schema['title']; $medatadata = new ClassMetadata($this->getNamespace() . '\\' . $className); if (isset($schema['properties'])) { foreach ($schema['properties'] as $name => $definition) { $type = $definition['type']; $nullable = isset($schema['required']) ? !in_array($name, $schema['required']) : true; $medatadata->mapField(['fieldName' => $name, 'type' => $type, 'nullable' => $nullable, 'options' => []]); } } $filename = sprintf("%s/%s/%s.php", $this->getPath(), join('/', explode('\\', $this->getNamespace())), $className); mkdir(dirname($filename), 0777, true); $generator = new EntityGenerator(); $generator->setGenerateAnnotations(true); file_put_contents($filename, $generator->generateEntityClass($medatadata)); }
protected function getEntityGenerator() { $entityGenerator = new EntityGenerator(); $entityGenerator->setGenerateAnnotations(false); $entityGenerator->setGenerateStubMethods(true); $entityGenerator->setRegenerateEntityIfExists(false); $entityGenerator->setUpdateEntityIfExists(true); $entityGenerator->setNumSpaces(4); $entityGenerator->setAnnotationPrefix('ORM\\'); return $entityGenerator; }
/** * generate entity objects automatically from mysql db tables * @return none */ function generate_classes() { $this->em->getConfiguration()->setMetadataDriverImpl(new DatabaseDriver($this->em->getConnection()->getSchemaManager())); $cmf = new DisconnectedClassMetadataFactory(); $cmf->setEntityManager($this->em); $metadata = $cmf->getAllMetadata(); $generator = new EntityGenerator(); $generator->setUpdateEntityIfExists(true); $generator->setGenerateStubMethods(true); $generator->setGenerateAnnotations(true); $generator->generate($metadata, APPPATH . "models/Entities"); }
/** * @inheritdoc */ public function run() { $printer = $this->getPrinter(); $arguments = $this->getArguments(); $from = $arguments['from']; $dest = realpath($arguments['dest']); $entityGenerator = new EntityGenerator(); $entityGenerator->setGenerateAnnotations(false); $entityGenerator->setGenerateStubMethods(true); $entityGenerator->setRegenerateEntityIfExists(false); $entityGenerator->setUpdateEntityIfExists(true); if (isset($arguments['extend']) && $arguments['extend']) { $entityGenerator->setClassToExtend($arguments['extend']); } if (isset($arguments['num-spaces']) && $arguments['extend']) { $entityGenerator->setNumSpaces($arguments['num-spaces']); } $reader = new ClassMetadataReader(); $reader->setEntityManager($this->getConfiguration()->getAttribute('em')); $reader->addMappingSource($from); $metadatas = $reader->getMetadatas(); foreach ($metadatas as $metadata) { $printer->writeln(sprintf('Processing entity "%s"', $printer->format($metadata->name, 'KEYWORD'))); } $entityGenerator->generate($metadatas, $dest); $printer->write(PHP_EOL); $printer->writeln(sprintf('Entity classes generated to "%s"', $printer->format($dest, 'KEYWORD'))); }
/** * @see Console\Command\Command */ protected function execute(Console\Input\InputInterface $input, Console\Output\OutputInterface $output) { $em = $this->getHelper('em')->getEntityManager(); if (\Zend_Registry::isRegistered(\LoSo_Zend_Application_Bootstrap_SymfonyContainerBootstrap::getRegistryIndex()) && ($container = \Zend_Registry::get(\LoSo_Zend_Application_Bootstrap_SymfonyContainerBootstrap::getRegistryIndex())) instanceof \Symfony\Component\DependencyInjection\ContainerInterface) { $mappingPaths = $container->getParameter('doctrine.orm.mapping_paths'); $entitiesPaths = $container->getParameter('doctrine.orm.entities_paths'); } else { $doctrineConfig = \Zend_Registry::get('doctrine.config'); $mappingPaths = $doctrineConfig['doctrine.orm.mapping_paths']; $entitiesPaths = $doctrineConfig['doctrine.orm.entities_paths']; } $cmf = new DisconnectedClassMetadataFactory($em); $metadatas = $cmf->getAllMetadata(); foreach ($mappingPaths as $namespace => $mappingPath) { // Process destination directory $destPath = realpath($entitiesPaths[$namespace]); if (!file_exists($destPath)) { throw new \InvalidArgumentException(sprintf("Entities destination directory '<info>%s</info>' does not exist.", $destPath)); } else { if (!is_writable($destPath)) { throw new \InvalidArgumentException(sprintf("Entities destination directory '<info>%s</info>' does not have write permissions.", $destPath)); } } $moduleMetadatas = MetadataFilter::filter($metadatas, $namespace); if (count($moduleMetadatas)) { // Create EntityGenerator $entityGenerator = new EntityGenerator(); $entityGenerator->setGenerateAnnotations($input->getOption('generate-annotations')); $entityGenerator->setGenerateStubMethods($input->getOption('generate-methods')); $entityGenerator->setRegenerateEntityIfExists($input->getOption('regenerate-entities')); $entityGenerator->setUpdateEntityIfExists($input->getOption('update-entities')); $entityGenerator->setNumSpaces($input->getOption('num-spaces')); if (($extend = $input->getOption('extend')) !== null) { $entityGenerator->setClassToExtend($extend); } foreach ($moduleMetadatas as $metadata) { $output->write(sprintf('Processing entity "<info>%s</info>"', $metadata->name) . PHP_EOL); } // Generating Entities $entityGenerator->generate($moduleMetadatas, $destPath); $this->_processNamespaces($destPath, $namespace); // Outputting information message $output->write(sprintf('Entity classes generated to "<info>%s</INFO>"', $destPath) . PHP_EOL); } else { $output->write('No Metadata Classes to process.' . PHP_EOL); } } /*$output->write(PHP_EOL . 'Reset database.' . PHP_EOL); $metadatas = $em->getMetadataFactory()->getAllMetadata(); $schemaTool = new \Doctrine\ORM\Tools\SchemaTool($em); $output->write('Dropping database schema...' . PHP_EOL); $schemaTool->dropSchema($metadatas); $output->write('Database schema dropped successfully!' . PHP_EOL); $output->write('Creating database schema...' . PHP_EOL); $schemaTool->createSchema($metadatas); $output->write('Database schema created successfully!' . PHP_EOL);*/ }
function testCreateSchema() { /* @var $em \Doctrine\ORM\EntityManager */ $em = $this->app["orm.em"]; $tool = new SchemaTool($em); //@note @doctrine générer les fichiers de classe à partir de métadonnées /* generate entity classes */ $dmf = new DisconnectedClassMetadataFactory(); $dmf->setEntityManager($em); $metadatas = $dmf->getAllMetadata(); //print_r($metadatas); $generator = new EntityGenerator(); $generator->setGenerateAnnotations(TRUE); $generator->setGenerateStubMethods(TRUE); $generator->setRegenerateEntityIfExists(TRUE); $generator->setUpdateEntityIfExists(TRUE); $generator->generate($metadatas, ROOT_TEST_DIR); $generator->setNumSpaces(4); $this->assertFileExists(ROOT_TEST_DIR . "/Entity/Post.php"); /* @note @doctrine générer la base de donnée à partir des métadonnées */ /* @see Doctrine\ORM\Tools\Console\Command\SchemaTool\CreateCommand */ /* generate database */ $tool->dropSchema($metadatas); $tool->createSchema($metadatas); $post = new \Entity\Post(); $post->setTitle("the title"); $em->persist($post); $em->flush(); $this->assertInternalType("int", $post->getId()); }
/** * @return bool * @throws \Exception */ public function generateClass() { $metadata = $this->getMetaData(); $this->setClassName($metadata->name); // setting the namespace $metadata->name = $this->getNamespace() . '\\' . $metadata->name; //generate the basic class-code if (!($this->generatedCode = $this->entityGenerator->generateEntityClass($metadata))) { throw new \Exception('Entity class could not be created'); } // TableAnnotation-Update if a Database is given if (isset($this->database)) { $this->updateTableAnnotation(); } $this->generateUseStatements(); $this->generateMethods(); $this->writeFile(); return true; }
protected function getEntityGenerator() { $entityGenerator = new EntityGenerator(); if (version_compare(DoctrineVersion::VERSION, "2.0.2-DEV") >= 0) { $entityGenerator->setAnnotationPrefix("orm:"); } $entityGenerator->setGenerateAnnotations(false); $entityGenerator->setGenerateStubMethods(true); $entityGenerator->setRegenerateEntityIfExists(false); $entityGenerator->setUpdateEntityIfExists(true); $entityGenerator->setNumSpaces(4); return $entityGenerator; }
/** * @param string $className * @param string $newClassName * @return string */ private function writeEntityClass($className, $newClassName) { $cmf = new ClassMetadataFactory(); $em = $this->_getTestEntityManager(); $cmf->setEntityManager($em); $metadata = $cmf->getMetadataFor($className); $metadata->namespace = $this->_namespace; $metadata->name = $newClassName; $metadata->customRepositoryClassName = $newClassName . "Repository"; $this->_generator->writeEntityClass($metadata, $this->_tmpDir); require $this->_tmpDir . DIRECTORY_SEPARATOR . str_replace('\\', DIRECTORY_SEPARATOR, $newClassName) . ".php"; }
public function __construct() { try { $conn = array("driver" => "pdo_mysql", "host" => "localhost", "port" => "3306", "user" => "root", "password" => "", "dbname" => "controle_gastos"); /* var_dump(__DIR__); var_dump(PP); exit; */ $loader = new \Doctrine\Common\ClassLoader("Entities", __DIR__); $loader->register(); $config = Setup::createAnnotationMetadataConfiguration(array("../../" . __DIR__ . "/app/models"), false); $em = EntityManager::create($conn, $config); $cmf = new DisconnectedClassMetadataFactory(); $cmf->setEntityManager($em); $em->getConnection()->getDatabasePlatform()->registerDoctrineTypeMapping('set', 'string'); $em->getConnection()->getDatabasePlatform()->registerDoctrineTypeMapping('enum', 'string'); $driver = new DatabaseDriver($em->getConnection()->getSchemaManager()); $em->getConfiguration()->setMetadataDriverImpl($driver); $metadata = $cmf->getAllMetadata(); $generator = new EntityGenerator(); $generator->setGenerateAnnotations(true); $generator->setGenerateStubMethods(true); $generator->setRegenerateEntityIfExists(true); $generator->setUpdateEntityIfExists(true); $generator->generate($metadata, "../../" . __DIR__ . "/app/models"); } catch (\Exception $e) { throw $e; } }
public function testRegenerateEntityClass() { $metadata = $this->generateBookEntityFixture(); $this->loadEntityClass($metadata); $className = basename(str_replace('\\', '/', $metadata->name)); $path = $this->_tmpDir . '/' . $this->_namespace . '/' . $className . '.php'; $classTest = file_get_contents($path); $this->_generator->setRegenerateEntityIfExists(true); $this->_generator->setBackupExisting(false); $this->_generator->writeEntityClass($metadata, $this->_tmpDir); $classNew = file_get_contents($path); $this->assertSame($classTest, $classNew); }
/** * @see Console\Command\Command */ protected function execute(Console\Input\InputInterface $input, Console\Output\OutputInterface $output) { $em = $this->getHelper('em')->getEntityManager(); $cmf = new DisconnectedClassMetadataFactory(); $cmf->setEntityManager($em); $metadatas = $cmf->getAllMetadata(); $metadatas = MetadataFilter::filter($metadatas, $input->getOption('filter')); // Process destination directory $destPath = realpath($input->getArgument('dest-path')); if (!file_exists($destPath)) { throw new \InvalidArgumentException(sprintf("Entities destination directory '<info>%s</info>' does not exist.", $input->getArgument('dest-path'))); } else { if (!is_writable($destPath)) { throw new \InvalidArgumentException(sprintf("Entities destination directory '<info>%s</info>' does not have write permissions.", $destPath)); } } if (count($metadatas)) { // Create EntityGenerator $entityGenerator = new EntityGenerator(); $entityGenerator->setGenerateAnnotations($input->getOption('generate-annotations')); $entityGenerator->setGenerateStubMethods($input->getOption('generate-methods')); $entityGenerator->setRegenerateEntityIfExists($input->getOption('regenerate-entities')); $entityGenerator->setUpdateEntityIfExists($input->getOption('update-entities')); $entityGenerator->setNumSpaces($input->getOption('num-spaces')); if (($extend = $input->getOption('extend')) !== null) { $entityGenerator->setClassToExtend($extend); } foreach ($metadatas as $metadata) { $output->write(sprintf('Processing entity "<info>%s</info>"', $metadata->name) . PHP_EOL); } // Generating Entities $entityGenerator->generate($metadatas, $destPath); // Outputting information message $output->write(PHP_EOL . sprintf('Entity classes generated to "<info>%s</INFO>"', $destPath) . PHP_EOL); } else { $output->write('No Metadata Classes to process.' . PHP_EOL); } }
/** * Get entity generator. * * @return EntityGenerator */ protected static function getEntityGenerator() { $entityGenerator = new EntityGenerator(); $entityGenerator->setGenerateAnnotations(true); $entityGenerator->setGenerateStubMethods(true); $entityGenerator->setRegenerateEntityIfExists(true); $entityGenerator->setUpdateEntityIfExists(true); $entityGenerator->setNumSpaces(4); $entityGenerator->setAnnotationPrefix(self::$annotationPrefix); return $entityGenerator; }
/** * {@inheritdoc} */ public function exportClassMetadata(ClassMetadataInfo $metadata) { if (!$this->_entityGenerator) { throw new \RuntimeException('For the AnnotationExporter you must set an EntityGenerator instance with the setEntityGenerator() method.'); } $this->_entityGenerator->setGenerateAnnotations(true); $this->_entityGenerator->setGenerateStubMethods(false); $this->_entityGenerator->setRegenerateEntityIfExists(false); $this->_entityGenerator->setUpdateEntityIfExists(false); return $this->_entityGenerator->generateEntityClass($metadata); }
public function fire() { $this->info('Starting entities generation....'); // flush all generated and cached entities, etc \D2Cache::flushAll(); $cmf = new DisconnectedClassMetadataFactory(); $cmf->setEntityManager($this->d2em); $metadata = $cmf->getAllMetadata(); if (empty($metadata)) { $this->error('No metadata found to generate entities.'); return -1; } $directory = Config::get('d2doctrine.paths.entities'); if (!$directory) { $this->error('The entity directory has not been set.'); return -1; } $entityGenerator = new EntityGenerator(); $entityGenerator->setGenerateAnnotations($this->option('generate-annotations')); $entityGenerator->setGenerateStubMethods($this->option('generate-methods')); $entityGenerator->setRegenerateEntityIfExists($this->option('regenerate-entities')); $entityGenerator->setUpdateEntityIfExists($this->option('update-entities')); $entityGenerator->setNumSpaces($this->option('num-spaces')); $entityGenerator->setBackupExisting(!$this->option('no-backup')); $this->info('Processing entities:'); foreach ($metadata as $item) { $this->line($item->name); } try { $entityGenerator->generate($metadata, $directory); $this->info('Entities have been created.'); } catch (\ErrorException $e) { if ($this->option('verbose') == 3) { throw $e; } $this->error("Caught ErrorException: " . $e->getMessage()); $this->info("Re-optimizing:"); $this->call('optimize'); $this->comment("*** You must now rerun this artisan command ***"); exit(-1); } }
/** * @group DDC-1784 */ public function testGenerateEntityWithSequenceGenerator() { $metadata = new ClassMetadataInfo($this->_namespace . '\\DDC1784Entity'); $metadata->namespace = $this->_namespace; $metadata->mapField(array('fieldName' => 'id', 'type' => 'integer', 'id' => true)); $metadata->setIdGeneratorType(ClassMetadataInfo::GENERATOR_TYPE_SEQUENCE); $metadata->setSequenceGeneratorDefinition(array('sequenceName' => 'DDC1784_ID_SEQ', 'allocationSize' => 1, 'initialValue' => 2)); $this->_generator->writeEntityClass($metadata, $this->_tmpDir); $filename = $this->_tmpDir . DIRECTORY_SEPARATOR . $this->_namespace . DIRECTORY_SEPARATOR . 'DDC1784Entity.php'; $this->assertFileExists($filename); require_once $filename; $reflection = new \ReflectionProperty($metadata->name, 'id'); $docComment = $reflection->getDocComment(); $this->assertContains('@Id', $docComment); $this->assertContains('@Column(name="id", type="integer")', $docComment); $this->assertContains('@GeneratedValue(strategy="SEQUENCE")', $docComment); $this->assertContains('@SequenceGenerator(sequenceName="DDC1784_ID_SEQ", allocationSize=1, initialValue=2)', $docComment); }
/** * @group DDC-2079 */ public function testGenerateEntityWithMultipleInverseJoinColumns() { $metadata = new ClassMetadataInfo($this->_namespace . '\\DDC2079Entity'); $metadata->namespace = $this->_namespace; $metadata->mapField(array('fieldName' => 'id', 'type' => 'integer', 'id' => true)); $metadata->setIdGeneratorType(ClassMetadataInfo::GENERATOR_TYPE_SEQUENCE); $metadata->mapManyToMany(array('fieldName' => 'centroCustos', 'targetEntity' => 'DDC2079CentroCusto', 'joinTable' => array('name' => 'unidade_centro_custo', 'joinColumns' => array(array('name' => 'idorcamento', 'referencedColumnName' => 'idorcamento'), array('name' => 'idunidade', 'referencedColumnName' => 'idunidade')), 'inverseJoinColumns' => array(array('name' => 'idcentrocusto', 'referencedColumnName' => 'idcentrocusto'), array('name' => 'idpais', 'referencedColumnName' => 'idpais'))))); $this->_generator->writeEntityClass($metadata, $this->_tmpDir); $filename = $this->_tmpDir . DIRECTORY_SEPARATOR . $this->_namespace . DIRECTORY_SEPARATOR . 'DDC2079Entity.php'; $this->assertFileExists($filename); require_once $filename; $property = new \ReflectionProperty($metadata->name, 'centroCustos'); $docComment = $property->getDocComment(); //joinColumns $this->assertContains('@JoinColumn(name="idorcamento", referencedColumnName="idorcamento"),', $docComment); $this->assertContains('@JoinColumn(name="idunidade", referencedColumnName="idunidade")', $docComment); //inverseJoinColumns $this->assertContains('@JoinColumn(name="idcentrocusto", referencedColumnName="idcentrocusto"),', $docComment); $this->assertContains('@JoinColumn(name="idpais", referencedColumnName="idpais")', $docComment); }
public function generate($parameters) { if (!$this->isInitialized) { throw new \RuntimeException('Entity generator needs to be initialized first in order to generate'); } $moduleName = $this->moduleName; $parentClassName = $this->parentClassName; $this->classNames = $parameters->classNames; $classNames = $this->classNames; $outputList = array(); $metadatas = array(); foreach ($classNames as $className) { if (in_array($className, $this->driver->getAllClassNames())) { $classNameWithNamespace = $this->getNamespacedClassName($className); $this->namespacedClassNames[$className] = $classNameWithNamespace; $realClassNameWithNamespace = $this->composeFullClassName($classNameWithNamespace); $realClassName = $this->getClassNameFromNamespacedClassName($classNameWithNamespace); $namespace = $this->getNamespaceFromNamespacedClassName($realClassNameWithNamespace, $realClassName); $metadata = new \Doctrine\ORM\Mapping\ClassMetadataInfo($className); $this->driver->loadMetadataForClass($className, $metadata); $metadata = $this->fixMetadata($metadata); $outputList[] = array('outputDirectory' => $this->generatedEntityOutputDirectory, 'entityNamespace' => $this->entityNamespace, 'entityName' => $className, 'className' => $realClassName); $metadata->name = $realClassNameWithNamespace; $metadata->namespace = $namespace; $metadatas[] = $metadata; echo $namespace . '\\' . $realClassName . '<br>'; } } if (count($metadatas) > 0) { $this->initGenerator(); if ($this->parentClassName != null) { if (!file_exists($this->generatedEntityOutputDirectory . '/' . $this->parentClassName . '.php')) { $parentMetadata = new \Doctrine\ORM\Mapping\ClassMetadataInfo($this->parentClassName); $parentMetadata->name = $this->composeFullClassName($this->parentClassName); $this->generator->writeEntityClass($parentMetadata, $this->generatedEntityOutputDirectory); } } $this->generator->generate($metadatas, $this->generatedEntityOutputDirectory); } return $outputList; }
protected function generateEntityStubMethod(ClassMetadataInfo $metadata, $type, $fieldName, $typeHint = null, $defaultValue = null) { if (strtolower($fieldName) === 'id') { return ''; } else { return parent::generateEntityStubMethod($metadata, $type, $fieldName, $typeHint, $defaultValue); } }
/** * main method * * @return void */ public function main() { static $em; if ($em === null) { $wd = getcwd(); $zf = $this->project->getProperty('zf'); $application = (require $zf); if (!$application instanceof Application) { throw new BuildException(sprintf('zf bootstrap file "%s" should return an instance of Zend\\Mvc\\Application', $zf)); } chdir($wd); $em = $application->getServiceManager()->get($this->em); } $cmf = new DisconnectedClassMetadataFactory(); $cmf->setEntityManager($em); $metadatas = $cmf->getAllMetadata(); if (!empty($this->filter)) { $metadatas = MetadataFilter::filter($metadatas, $this->filter); } if (count($metadatas)) { // Create EntityGenerator $entityGenerator = new EntityGenerator(); $entityGenerator->setGenerateAnnotations(true); $entityGenerator->setGenerateStubMethods(true); $entityGenerator->setRegenerateEntityIfExists(true); $entityGenerator->setUpdateEntityIfExists(true); $entityGenerator->setNumSpaces(4); foreach ($metadatas as $metadata) { $this->log(sprintf('Processing entity %s', $metadata->name)); } // Generating Entities $entityGenerator->generate($metadatas, $this->output); // Outputting information message $this->log(sprintf('Entity classes generated to %s', $this->output)); } else { $this->log('No metadata classes to process'); } }
/** * {@inheritdoc} */ public function generateEntityClass(ClassMetadataInfo $metadata) { $code = parent::generateEntityClass($metadata); $class = new \ReflectionClass('Doctrine\\ORM\\Tools\\EntityGenerator'); $spacesProperty = $class->getProperty('spaces'); $spacesProperty->setAccessible(true); $prefixCodeWithSpacesMethod = $class->getMethod('prefixCodeWithSpaces'); $prefixCodeWithSpacesMethod->setAccessible(true); $code = str_replace(array('<constants>'), array($prefixCodeWithSpacesMethod->invoke($this, $this->generateConstant($metadata))), $code); return str_replace('<spaces>', $spacesProperty->getValue($this), $code); }
/** * Get a Doctrine EntityGenerator instance. * * @param string|null $classToExtend * * @return EntityGenerator */ protected function getEntityGenerator($classToExtend = null) { $entityGenerator = new EntityGenerator(); if (!is_null($classToExtend)) { $entityGenerator->setClassToExtend($classToExtend); } $entityGenerator->setGenerateAnnotations(true); $entityGenerator->setGenerateStubMethods(true); $entityGenerator->setRegenerateEntityIfExists(false); $entityGenerator->setUpdateEntityIfExists(true); $entityGenerator->setNumSpaces(4); $entityGenerator->setAnnotationPrefix('ORM\\'); return $entityGenerator; }
/** * Entidades::generador() * * Genera el proceso correspondiente * @param array $metadata * @return void */ private function generador($metadata = false) { $generator = new EntityGenerator(); $generator->setAnnotationPrefix(''); // edit: quick fix for No Metadata Classes to process $generator->setUpdateEntityIfExists(true); // only update if class already exists $generator->setRegenerateEntityIfExists(true); // this will overwrite the existing classes $generator->setGenerateStubMethods(true); $generator->setGenerateAnnotations(true); $generator->generate($metadata, dirname($this->dirEntidades)); }
public function testExportDirectoryAndFilesAreCreated() { $this->_deleteDirectory(__DIR__ . '/export/' . $this->_getType()); $type = $this->_getType(); $metadataDriver = $this->_createMetadataDriver($type, __DIR__ . '/' . $type); $em = $this->_createEntityManager($metadataDriver); $cmf = $this->_createClassMetadataFactory($em, $type); $metadata = $cmf->getAllMetadata(); $metadata[0]->name = 'Doctrine\\Tests\\ORM\\Tools\\Export\\ExportedUser'; $this->assertEquals('Doctrine\\Tests\\ORM\\Tools\\Export\\ExportedUser', $metadata[0]->name); $type = $this->_getType(); $cme = new ClassMetadataExporter(); $exporter = $cme->getExporter($type, __DIR__ . '/export/' . $type); if ($type === 'annotation') { $entityGenerator = new EntityGenerator(); $entityGenerator->setAnnotationPrefix(""); $exporter->setEntityGenerator($entityGenerator); } $this->_extension = $exporter->getExtension(); $exporter->setMetadata($metadata); $exporter->export(); if ($type == 'annotation') { $this->assertTrue(file_exists(__DIR__ . '/export/' . $type . '/' . str_replace('\\', '/', 'Doctrine\\Tests\\ORM\\Tools\\Export\\ExportedUser') . $this->_extension)); } else { $this->assertTrue(file_exists(__DIR__ . '/export/' . $type . '/Doctrine.Tests.ORM.Tools.Export.ExportedUser' . $this->_extension)); } }
$classLoader = new \Doctrine\Common\ClassLoader('Symfony', realpath(__DIR__ . "/Doctrine/Symfony/")); $classLoader->register(); $classLoader = new \Doctrine\Common\ClassLoader('Entities', realpath(__DIR__)); $classLoader->register(); $classLoader = new \Doctrine\Common\ClassLoader('Proxies', realpath(__DIR__)); $classLoader->register(); $config = new \Doctrine\ORM\Configuration(); $config->setMetadataCacheImpl(new \Doctrine\Common\Cache\ArrayCache()); $annotationDriver = $config->newDefaultAnnotationDriver(array(__DIR__ . "/Entities")); $config->setMetadataDriverImpl($annotationDriver); $config->setAutoGenerateProxyClasses(true); $config->setProxyDir(__DIR__ . '/Proxies'); $config->setProxyNamespace('Proxies'); $connectionOptions = array('dbname' => 'application', 'user' => 'root', 'password' => '', 'host' => 'localhost', 'driver' => 'pdo_mysql'); $em = \Doctrine\ORM\EntityManager::create($connectionOptions, $config); $databaseDriver = new \Doctrine\ORM\Mapping\Driver\DatabaseDriver($em->getConnection()->getSchemaManager()); $em->getConfiguration()->setMetadataDriverImpl($databaseDriver); $cmf = new \Doctrine\ORM\Tools\DisconnectedClassMetadataFactory($em); $cmf->setEntityManager($em); $conn = $em->getConnection(); $conn->getDatabasePlatform()->registerDoctrineTypeMapping('enum', 'string'); $conn->getDatabasePlatform()->registerDoctrineTypeMapping('longblob', 'text'); $conn->getDatabasePlatform()->registerDoctrineTypeMapping('blob', 'text'); $conn->getDatabasePlatform()->registerDoctrineTypeMapping('varbinary', 'text'); $metadatas = $cmf->getAllMetadata(); $helperSet = new \Symfony\Component\Console\Helper\HelperSet(array('db' => new \Doctrine\DBAL\Tools\Console\Helper\ConnectionHelper($em->getConnection()), 'em' => new \Doctrine\ORM\Tools\Console\Helper\EntityManagerHelper($em))); $generator = new EntityGenerator(); $generator->setUpdateEntityIfExists(true); $generator->setGenerateStubMethods(true); $generator->setGenerateAnnotations(true); $generator->generate($metadatas, __DIR__ . '../application/Entities');
protected function getEntityGenerator() { $entityGenerator = new EntityGenerator(); $entityGenerator->setGenerateStubMethods(true); $entityGenerator->setRegenerateEntityIfExists(true); $entityGenerator->setBackupExisting(true); return $entityGenerator; }
/** * @return \Doctrine\ORM\Tools\EntityGenerator */ protected function getEntityGenerator() { $entityGenerator = new EntityGenerator(); $entityGenerator->setClassToExtend('Kunstmaan\\AdminBundle\\Entity\\AbstractEntity'); $entityGenerator->setGenerateAnnotations(true); $entityGenerator->setGenerateStubMethods(true); $entityGenerator->setRegenerateEntityIfExists(false); $entityGenerator->setUpdateEntityIfExists(true); $entityGenerator->setNumSpaces(4); $entityGenerator->setAnnotationPrefix('ORM\\'); return $entityGenerator; }
/** * Generate the model class for Raptor * Genera las clases modelos para las clases schema especificadas * Los modelos seran generados en el namespace especificado * Tenga en cuenta que un SchemaClass no es lo mismo que los nombres * de las tablas, es una representacion que brinda doctrine para tablas en la base de datos * * $this->getStore()->generateClasses('\example\exampleBundle','Persona'); * * @param string $namespace el namespace del bundle donde seran creados los modelos * @param array $schemaClass un array con todos los schemaClass que seran generados los modelos */ public function generateClasses($namespace, $schemaClass) { $clases = $schemaClass; // custom datatypes (not mapped for reverse engineering) $this->entityManager->getConnection()->getDatabasePlatform()->registerDoctrineTypeMapping('set', 'string'); $this->entityManager->getConnection()->getDatabasePlatform()->registerDoctrineTypeMapping('enum', 'string'); // fetch metadata $driver = new \Doctrine\ORM\Mapping\Driver\DatabaseDriver($this->entityManager->getConnection()->getSchemaManager()); $this->entityManager->getConfiguration()->setMetadataDriverImpl($driver); $cmf = new \Doctrine\ORM\Tools\DisconnectedClassMetadataFactory(); $cmf->setEntityManager($this->entityManager); // we must set the EntityManager $classes = $driver->getAllClassNames(); $metadata = array(); $rep = new EntityRepositoryGenerator(); foreach ($clases as $class) { //any unsupported table/schema could be handled here to exclude some classes if (true) { $meta = $cmf->getMetadataFor($class); $association = new ItemList($meta->associationMappings); $me = $this; $association->each(function ($k, $v, $l) use(&$me) { $v['targetEntity'] = $me->translateSchemas($v['targetEntity']); $v['sourceEntity'] = $me->translateSchemas($v['sourceEntity']); $l->set($k, $v); }); $meta->associationMappings = $association->getArray(); $real = $this->translateSchemas($class); $meta->name = $namespace . $this->namespaceSeparator . 'Model' . $this->namespaceSeparator . 'Entity' . $this->namespaceSeparator . $real; $meta->namespace = $namespace . $this->namespaceSeparator . 'Model' . $this->namespaceSeparator . 'Entity'; // $meta->namespace='Entities\\'.$class; $meta->customRepositoryClassName = $namespace . $this->namespaceSeparator . 'Model' . $this->namespaceSeparator . 'Repository' . $this->namespaceSeparator . $real . 'Repository'; //TODO buscar entidades ya creadas foreach ($meta->associationMappings as $key => $value) { $names = $this->entityManager->getConfiguration()->getEntityNamespaces(); $target = $meta->associationMappings[$key]['targetEntity']; $found = false; foreach ($names as $routes) { if ($routes[0] == '\\') { $bundleRoute = substr($routes, 1); } else { $bundleRoute = $routes; } $fileroute = __DIR__ . "/../../../src/" . str_replace('\\', DIRECTORY_SEPARATOR, $bundleRoute); $fileroute .= DIRECTORY_SEPARATOR . $target . ".php"; if (file_exists($fileroute)) { $found = true; $target = $bundleRoute . $this->namespaceSeparator . $value['targetEntity']; } } if ($found) { //$target = $namespace . $this->namespaceSeparator . 'Entity' . $this->namespaceSeparator . $value['targetEntity']; $meta->associationMappings[$key]['targetEntity'] = $target; } else { $meta->associationMappings[$key]['targetEntity'] = $namespace . $this->namespaceSeparator . 'Model' . $this->namespaceSeparator . 'Entity' . $this->namespaceSeparator . $value['targetEntity']; } } $metadata[] = $meta; $rep->writeEntityRepositoryClass($namespace . $this->namespaceSeparator . 'Model' . $this->namespaceSeparator . 'Repository' . $this->namespaceSeparator . $real . 'Repository', \Raptor\Core\Location::get(\Raptor\Core\Location::SRC)); } } $generator = new EntityGenerator(); $generator->setAnnotationPrefix(''); // edit: quick fix for No Metadata Classes to process $generator->setUpdateEntityIfExists(true); // only update if class already exists $generator->setRegenerateEntityIfExists(true); // this will overwrite the existing classes $generator->setGenerateStubMethods(true); $generator->setGenerateAnnotations(true); //$y=new Doctrine\ORM\Tools\Export\Driver\YamlExporter(__DIR__ . '/Entities/yml'); //$y->setMetadata($metadata); //$y->export(); $generator->generate($metadata, \Raptor\Core\Location::get(\Raptor\Core\Location::SRC)); }
/** * @param ClassMetadataInfo $metadata * * @return string */ protected function generateEntityBody(ClassMetadataInfo $metadata) { $code = []; $code[] = $this->generateTraits($metadata); $code[] = parent::generateEntityBody($metadata); return implode("\n", $code); }
/** * Generate entity classes * * @param array $metadata */ protected function generateEntities(array $metadata) { $generator = new EntityGenerator(); $generator->setGenerateAnnotations(true); $generator->setGenerateStubMethods(true); $generator->setRegenerateEntityIfExists(false); $generator->setUpdateEntityIfExists(true); $generator->setBackupExisting(false); if (null !== ($superclass = $this->getSuperclass())) { $generator->setClassToExtend($superclass); } /* @var $classMetadata \Doctrine\ORM\Mapping\ClassMetadata */ foreach ($metadata as $classMetadata) { $className = end(explode('\\', $classMetadata->getName())); $classMetadata->setCustomRepositoryClass($this->getNsRepository() . $className); if (null !== ($prefix = $this->getSequencePrefix())) { $classMetadata->setSequenceGeneratorDefinition(array('sequenceName' => strtoupper($prefix . '_' . $className))); } } $generator->generate($metadata, $this->getDirectory()); }