/**
* {@inheritdoc}
*/
protected function execute(InputInterface $input, OutputInterface $output)
{
$em = $this->getHelper('em')->getEntityManager();
$metadatas = $em->getMetadataFactory()->getAllMetadata();
$metadatas = MetadataFilter::filter($metadatas, $input->getOption('filter'));
$repositoryName = $em->getConfiguration()->getDefaultRepositoryClassName();
// 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')));
}
if (!is_writable($destPath)) {
throw new \InvalidArgumentException(sprintf("Entities destination directory '<info>%s</info>' does not have write permissions.", $destPath));
}
if (count($metadatas)) {
$numRepositories = 0;
$generator = new EntityRepositoryGenerator();
$generator->setDefaultRepositoryName($repositoryName);
foreach ($metadatas as $metadata) {
if ($metadata->customRepositoryClassName) {
$output->writeln(sprintf('Processing repository "<info>%s</info>"', $metadata->customRepositoryClassName));
$generator->writeEntityRepositoryClass($metadata->customRepositoryClassName, $destPath);
$numRepositories++;
}
}
if ($numRepositories) {
// Outputting information message
$output->writeln(PHP_EOL . sprintf('Repository classes generated to "<info>%s</INFO>"', $destPath));
} else {
$output->writeln('No Repository classes were found to be processed.');
}
} else {
$output->writeln('No Metadata Classes to process.');
}
}
/**
* @see Console\Command\Command
*/
protected function execute(Console\Input\InputInterface $input, Console\Output\OutputInterface $output)
{
$em = $this->getHelper('em')->getEntityManager();
$metadatas = $em->getMetadataFactory()->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.", $destPath));
} 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 AS3EntityGenerator($em);
$entityGenerator->setGenerateAssociationHelperMethods($input->getOption('generate-helper-methods'));
$entityGenerator->setRegenerateEntityIfExists($input->getOption('regenerate-entities'));
$entityGenerator->setUpdateEntityIfExists($input->getOption('update-entities'));
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('AS3 entity classes generated to "<info>%s</INFO>"', $destPath) . PHP_EOL);
} else {
$output->write('No Metadata Classes to process.' . PHP_EOL);
}
}
/**
* {@inheritdoc}
*/
protected function execute(InputInterface $input, OutputInterface $output)
{
$em = $this->getHelper('em')->getEntityManager();
$metadatas = $em->getMetadataFactory()->getAllMetadata();
$metadatas = MetadataFilter::filter($metadatas, $input->getOption('filter'));
// Process destination directory
if (($destPath = $input->getArgument('dest-path')) === null) {
$destPath = $em->getConfiguration()->getProxyDir();
}
if (!is_dir($destPath)) {
mkdir($destPath, 0777, true);
}
$destPath = realpath($destPath);
if (!file_exists($destPath)) {
throw new \InvalidArgumentException(sprintf("Proxies destination directory '<info>%s</info>' does not exist.", $em->getConfiguration()->getProxyDir()));
}
if (!is_writable($destPath)) {
throw new \InvalidArgumentException(sprintf("Proxies destination directory '<info>%s</info>' does not have write permissions.", $destPath));
}
if (count($metadatas)) {
foreach ($metadatas as $metadata) {
$output->writeln(sprintf('Processing entity "<info>%s</info>"', $metadata->name));
}
// Generating Proxies
$em->getProxyFactory()->generateProxyClasses($metadatas, $destPath);
// Outputting information message
$output->writeln(PHP_EOL . sprintf('Proxy classes generated to "<info>%s</INFO>"', $destPath));
} else {
$output->writeln('No Metadata Classes to process.');
}
}
/**
* @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);*/
}
protected function execute(InputInterface $input, OutputInterface $output)
{
$bundle = $this->getApplication()->getKernel()->getBundle($input->getArgument('bundle'));
$destPath = $bundle->getPath();
/* $type = $input->getArgument('mapping-type') ? $input->getArgument('mapping-type') : 'xml';
if ('annotation' === $type) {
$destPath .= '/Entity/Base';
} else {
$destPath .= '/Resources/config/doctrine';
}
if ('yaml' === $type) {
$type = 'yml';
}*/
$cme = new ClassMetadataExporter();
$exporter = $cme->getExporter($type);
$exporter->setOverwriteExistingFiles($input->getOption('force'));
if ('annotation' === $type) {
$entityGenerator = $this->getEntityGenerator();
$exporter->setEntityGenerator($entityGenerator);
}
$em = $this->getEntityManager($input->getOption('em'));
$databaseDriver = new DatabaseDriver($em->getConnection()->getSchemaManager());
$em->getConfiguration()->setMetadataDriverImpl($databaseDriver);
$emName = $input->getOption('em');
$emName = $emName ? $emName : 'default';
$cmf = new DisconnectedClassMetadataFactory();
$cmf->setEntityManager($em);
$metadata = $cmf->getAllMetadata();
$metadata = MetadataFilter::filter($metadata, $input->getOption('filter'));
if ($metadata) {
$output->writeln(sprintf('Importing mapping information from "<info>%s</info>" entity manager', $emName));
foreach ($metadata as $class) {
$className = $class->name;
$class->name = $bundle->getNamespace() . '\\Entity\\Base\\' . $className;
if ('annotation' === $type) {
$path = $destPath . '/' . $className . '.php';
} else {
$path = $destPath . '/' . $className . '.orm.' . $type;
}
$output->writeln(sprintf(' > writing <comment>%s</comment>', $path));
$code = $exporter->exportClassMetadata($class);
if (!is_dir($dir = dirname($path))) {
mkdir($dir, 0777, true);
}
$code = str_replace('private $', 'protected $', $code);
file_put_contents($path, $code);
$mainFilePath = $destPath . '/../' . $className . '.php';
$output->writeln(sprintf(' > writing <comment>%s</comment>', $mainFilePath));
file_put_contents($mainFilePath, '<?php' . "\n\n" . 'namespace ' . $bundle->getNamespace() . '\\Entity;' . "\n\n" . 'use ' . $bundle->getNamespace() . '\\Entity\\Base\\' . $className . ' as Base' . $className . ';' . "\n\n" . 'class ' . $className . ' extends Base' . $className . "\n" . '{' . "\n" . '}');
}
} else {
$output->writeln('Database does not have any mapping information.', 'ERROR');
$output->writeln('', 'ERROR');
}
}
protected function _getMetadata()
{
if (null === $this->metadata) {
$this->bootstrap->bootstrap('Doctrine2');
$em = $this->bootstrap->getResource('Doctrine2');
$cmf = new \Doctrine\ORM\Tools\DisconnectedClassMetadataFactory($em);
$metadatas = $cmf->getAllMetadata();
$entityName = $this->_getEntityName();
$entityClass = $this->_getModuleNamespace() . '_Model_' . $entityName;
$metadata = current(\Doctrine\ORM\Tools\Console\MetadataFilter::filter($metadatas, $entityClass));
$this->metadata = $metadata;
}
return $this->metadata;
}
/**
* @see Console\Command\Command
*/
protected function execute(Console\Input\InputInterface $input, Console\Output\OutputInterface $output)
{
$em = $this->getHelper('em')->getEntityManager();
if ($input->getOption('from-database') === true) {
$databaseDriver = new \Doctrine\ORM\Mapping\Driver\DatabaseDriver($em->getConnection()->getSchemaManager());
$em->getConfiguration()->setMetadataDriverImpl($databaseDriver);
if (($namespace = $input->getOption('namespace')) !== null) {
$databaseDriver->setNamespace($namespace);
}
}
$cmf = new DisconnectedClassMetadataFactory();
$cmf->setEntityManager($em);
$metadata = $cmf->getAllMetadata();
$metadata = MetadataFilter::filter($metadata, $input->getOption('filter'));
// Process destination directory
if (!is_dir($destPath = $input->getArgument('dest-path'))) {
mkdir($destPath, 0777, true);
}
$destPath = realpath($destPath);
if (!file_exists($destPath)) {
throw new \InvalidArgumentException(sprintf("Mapping destination directory '<info>%s</info>' does not exist.", $destPath));
} else {
if (!is_writable($destPath)) {
throw new \InvalidArgumentException(sprintf("Mapping destination directory '<info>%s</info>' does not have write permissions.", $destPath));
}
}
$toType = strtolower($input->getArgument('to-type'));
$exporter = $this->getExporter($toType, $destPath);
$exporter->setOverwriteExistingFiles($input->getOption('force') !== false);
if ($toType == 'annotation') {
$entityGenerator = new \Internshala\Doctrine_Extension\Entity_Generator();
//$entityGenerator = new EntityGenerator();
$exporter->setEntityGenerator($entityGenerator);
$entityGenerator->setNumSpaces($input->getOption('num-spaces'));
if (($extend = $input->getOption('extend')) !== null) {
$entityGenerator->setClassToExtend($extend);
}
}
if (count($metadata)) {
foreach ($metadata as $class) {
$output->write(sprintf('Processing entity "<info>%s</info>"', $class->name) . PHP_EOL);
}
$exporter->setMetadata($metadata);
$exporter->export();
$output->write(PHP_EOL . sprintf('Exporting "<info>%s</info>" mapping information to "<info>%s</info>"' . PHP_EOL, $toType, $destPath));
} else {
$output->write('No Metadata Classes to process.' . PHP_EOL);
}
}
/**
* @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.", $destPath));
} 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 (($attributeVisibility = $input->getOption('attribute-visibility')) !== null) {
$entityGenerator->setAttributeVisibility($attributeVisibility);
}
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);
}
}
/**
* Execute the console command.
*
* @param ManagerRegistry $registry
*/
public function fire(ManagerRegistry $registry)
{
$names = $this->option('em') ? [$this->option('em')] : $registry->getManagerNames();
foreach ($names as $name) {
$em = $registry->getManager($name);
$this->comment('');
$this->message('Generating proxies for <info>' . $name . '</info> entity manager...', 'blue');
$metadatas = $em->getMetadataFactory()->getAllMetadata();
$metadatas = MetadataFilter::filter($metadatas, $this->option('filter'));
// Process destination directory
if (($destPath = $this->argument('dest-path')) === null) {
$destPath = $em->getConfiguration()->getProxyDir();
}
if (!is_dir($destPath)) {
mkdir($destPath, 0777, true);
}
$destPath = realpath($destPath);
if (!file_exists($destPath)) {
throw new InvalidArgumentException(sprintf("Proxies destination directory '<info>%s</info>' does not exist.", $em->getConfiguration()->getProxyDir()));
}
if (!is_writable($destPath)) {
throw new InvalidArgumentException(sprintf("Proxies destination directory '<info>%s</info>' does not have write permissions.", $destPath));
}
if (count($metadatas)) {
foreach ($metadatas as $metadata) {
$this->comment(sprintf('Processing entity "<info>%s</info>"', $metadata->name));
}
// Generating Proxies
$em->getProxyFactory()->generateProxyClasses($metadatas, $destPath);
// Outputting information message
$this->comment(sprintf('Proxy classes generated to "<info>%s</INFO>"', $destPath));
} else {
$this->error('No Metadata Classes to process.');
}
}
}
public function exportJson()
{
$metadata = $this->cmf->getAllMetadata();
$metadata = MetadataFilter::filter($metadata, $this->filter);
if ($metadata) {
$filename = $this->path . '/' . $this->extensionKey . '/' . self::PROJECT_FILE_NAME;
if (!is_dir($dir = dirname($filename))) {
mkdir($dir, 0777, true);
}
$configuration = new ExtensionBuilderConfiguration();
if (is_readable($filename)) {
if ($this->overwriteExistingFiles && $this->roundTripExistingFiles) {
$this->logs[] = sprintf('File "<info>%s</info>" already exists, you selected both override (force) and round-trip - please choose one.', $filename);
return 1;
}
if (!$this->overwriteExistingFiles && !$this->roundTripExistingFiles) {
$this->logs[] = sprintf('File "<info>%s</info>" already exists, use --force to override or --round-trip it.', $filename);
return 1;
}
if ($this->roundTripExistingFiles) {
$roundtripContents = json_decode(file_get_contents($filename), true);
$configuration->setProperties($this->mapArrayToClass($roundtripContents['properties'], new Properties()));
$configuration->setLog($this->mapArrayToClass($roundtripContents['log'], new Log()));
}
}
$configuration->getProperties()->setExtensionKey($this->extensionKey);
$configuration->getLog()->setLastModified(date('Y-m-d H:i'));
//in this array we store the target entites for all relations to create wires later on
$relationTargetsByModuleByRelation = array();
$moduleIndex = 0;
$posX = 50;
$posY = 50;
foreach ($metadata as $metadata) {
if ($moduleIndex) {
if (0 == $moduleIndex % 5) {
$posX = 50;
$posY += 200;
} else {
$posX += 300;
}
}
$className = $metadata->name;
//remove namespaces, e.g. when importing entities
if (class_exists($className)) {
$reflection = new \ReflectionClass($className);
$className = $reflection->getShortName();
}
$this->logs[] = sprintf('Processing table "<info>%s</info>"', $className);
$module = new Module();
$module->getValue()->setName($className);
$module->getConfig()->setPosition(array($posX, $posY));
$module->getValue()->getObjectsettings()->setUid($this->getRandomUid());
$module->getValue()->getObjectsettings()->setType(ObjectSettings::OBJECT_TYPE_ENTITY);
//export properties
foreach ($metadata->fieldMappings as $fieldMapping) {
$property = new Property();
$property->setPropertyName($fieldMapping['fieldName']);
$property->setPropertyType($this->getPropertyType($fieldMapping['type']));
$property->setUid($this->getRandomUid());
$module->getValue()->getPropertyGroup()->addProperty($property);
}
//export relations
$relationIndex = 0;
foreach ($metadata->associationMappings as $associationMapping) {
$relationNameSingular = $associationMapping['fieldName'];
$relationNamePlural = Inflector::pluralize(Inflector::singularize($associationMapping['fieldName']));
$relation = new Relation();
$relationType = null;
$relationName = '';
switch ($associationMapping['type']) {
case ClassMetadataInfo::ONE_TO_MANY:
$relationType = Relation::ONE_TO_MANY;
$relationName = $relationNamePlural;
break;
case ClassMetadataInfo::MANY_TO_ONE:
$relationType = Relation::MANY_TO_ONE;
$relationName = $relationNameSingular;
break;
case ClassMetadataInfo::ONE_TO_ONE:
$relationType = Relation::ONE_TO_ONE;
$relationName = $relationNameSingular;
break;
case ClassMetadataInfo::MANY_TO_MANY:
$relationType = Relation::MANY_TO_MANY;
$relationName = $relationNamePlural;
break;
}
$relation->setRelationName($relationName);
$relation->setRelationType($relationType);
$relationName = $relationNameSingular;
$module->getValue()->getRelationGroup()->addRelation($relation);
$targetClassName = $associationMapping['targetEntity'];
//remove namespaces, e.g. when importing entities
if (class_exists($targetClassName)) {
$reflection = new \ReflectionClass($targetClassName);
$targetClassName = $reflection->getShortName();
}
$relationTargetsByModuleByRelation[$moduleIndex][$relationIndex] = $targetClassName;
$relationIndex++;
$this->logs[] = sprintf('Added relation "<comment>%s</comment>": "<info>%s</info>" -> "<info>%s</info>"', $relationName, $className, $targetClassName);
}
$configuration->addModule($module);
$moduleIndex++;
}
// now we have all the modules, we can create wires
$moduleIndex = 0;
foreach ($configuration->getModules() as $key => $module) {
$relationIndex = 0;
if (!empty($module->getValue()->getRelationGroup()->getRelations())) {
foreach ($module->getValue()->getRelationGroup()->getRelations() as $relation) {
/* @var $relation Relation */
// now add the corresponding wire for the relation
$wire = new Wire();
$targetEntity = $relationTargetsByModuleByRelation[$moduleIndex][$relationIndex];
$targetModule = $configuration->getModuleByName($targetEntity);
if ($targetModule) {
$targetModuleId = array_search($targetModule, $configuration->getModules());
$src = new Node();
$src->setModuleId($key);
$src->setTerminal(Node::TERMINAL_SRC . $relationIndex);
$src->setUid($relation->getUid());
$tgt = new Node();
$tgt->setModuleId($targetModuleId);
$tgt->setTerminal(Node::TERMINAL_TGT);
$tgt->setUid($targetModule->getValue()->getObjectsettings()->getUid());
$wire->setSrc($src);
$wire->setTgt($tgt);
$configuration->addWire($wire);
$this->logs[] = sprintf('Added wire "<comment>%s</comment>": "<info>%s</info>" -> "<info>%s</info>"', $relation->getRelationName(), $module->getValue()->getName(), $targetEntity);
}
$relationIndex++;
}
}
$moduleIndex++;
}
file_put_contents($filename, json_encode($configuration, JSON_PRETTY_PRINT));
$this->logs[] = 'Exported database schema to ' . $filename;
return true;
} else {
$this->logs[] = 'Database does not have any mapping information.';
return false;
}
}
/**
* {@inheritDoc}
*/
protected function execute(InputInterface $input, OutputInterface $output)
{
$app = $this->getHelper("app")->getApplication();
$registry = $app['orm.manager_registry'];
/* @var $registry ManagerRegistry */
$emName = $input->getOption("em") ? $input->getOption("em") : "default";
$em = $registry->getManager($emName);
//$bundle = $this->getApplication()->getKernel()->getBundle($input->getArgument('bundle'));
// $destPath = $bundle->getPath();
$destPath = $input->getArgument("path");
$type = $input->getArgument('mapping-type') ? $input->getArgument('mapping-type') : 'xml';
if ('annotation' === $type) {
$destPath .= "/" . preg_replace("#\\\\#", "/", $input->getOption("namespace"));
} else {
$destPath .= '/Resources/doctrine';
}
if ('yaml' === $type) {
$type = 'yml';
}
$cme = new ClassMetadataExporter();
$exporter = $cme->getExporter($type);
$exporter->setOverwriteExistingFiles($input->getOption('force'));
if ('annotation' === $type) {
$entityGenerator = $this->getEntityGenerator();
$exporter->setEntityGenerator($entityGenerator);
}
//$em = $this->getEntityManager($input->getOption('em'));
$databaseDriver = new DatabaseDriver($em->getConnection()->getSchemaManager());
$em->getConfiguration()->setMetadataDriverImpl($databaseDriver);
//$emName = $input->getOption('em');
// $emName = $emName ? $emName : 'default';
$cmf = new DisconnectedClassMetadataFactory();
$cmf->setEntityManager($em);
$metadata = $cmf->getAllMetadata();
$metadata = MetadataFilter::filter($metadata, $input->getOption('filter'));
if ($metadata) {
$output->writeln(sprintf('Importing mapping information from "<info>%s</info>" entity manager', $emName));
foreach ($metadata as $class) {
$className = $class->name;
$class->name = $input->getOption("namespace") . "\\" . $className;
//$classPath = $class-> /* todo fix it */
if ('annotation' === $type) {
$path = $destPath . '/' . $className . '.php';
} else {
$path = $destPath . '/' . preg_replace('#\\\\#', ".", $class->name) . '.dcm.' . $type;
}
$output->writeln(sprintf(' > writing <comment>%s</comment>', $path));
$code = $exporter->exportClassMetadata($class);
if (!is_dir($dir = dirname($path))) {
mkdir($dir, 0777, true);
}
file_put_contents($path, $code);
}
} else {
$output->writeln('Database does not have any mapping information.', 'ERROR');
$output->writeln('', 'ERROR');
}
}
protected function prepare()
{
$this->metadata = $this->cmf->getAllMetadata();
$this->metadata = MetadataFilter::filter($this->metadata, $this->filter);
$this->filename = $this->path . '/' . self::PROJECT_FILE;
if (!is_dir($dir = dirname($this->filename))) {
mkdir($dir, 0777, true);
}
$configFile = $this->path . '/' . self::CONFIG_FILE;
if (is_readable($configFile)) {
$this->configuration = Yaml::parse(file_get_contents($configFile));
}
}
/**
* 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);
}
$metadatas = $em->getMetadataFactory()->getAllMetadata();
if (!empty($this->filter)) {
$metadatas = MetadataFilter::filter($metadatas, $this->filter);
}
if (count($metadatas)) {
foreach ($metadatas as $metadata) {
$this->log(sprintf('Processing entity %s', $metadata->name));
}
$em->getProxyFactory()->generateProxyClasses($metadatas, $this->output);
// Outputting information message
$this->log(sprintf('Proxy classes generated to %s', $this->output));
} else {
$this->log('No metadata classes to process');
}
}
/**
* 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}
*/
protected function execute(InputInterface $input, OutputInterface $output)
{
$em = $this->getEntityManager();
$destPath = APP_PATH . DIRECTORY_SEPARATOR . preg_replace("#\\\\#", DIRECTORY_SEPARATOR, $this->getNamespace());
$type = 'annotation';
$cme = new ClassMetadataExporter();
$exporter = $cme->getExporter($type);
$exporter->setOverwriteExistingFiles($input->getOption('force'));
$exporter->setEntityGenerator($this->getEntityGenerator());
$databaseDriver = new DatabaseDriver($em->getConnection()->getSchemaManager());
$em->getConfiguration()->setMetadataDriverImpl($databaseDriver);
$cmf = new DisconnectedClassMetadataFactory();
$cmf->setEntityManager($em);
$metadata = $cmf->getAllMetadata();
$metadata = MetadataFilter::filter($metadata, $input->getOption('filter'));
if ($metadata) {
$output->writeln(sprintf('Importing mapping information from "<info>%s</info>" entity manager', 'default'));
foreach ($metadata as $class) {
$className = $class->name;
$class->name = sprintf('%s\\%s', $this->getNamespace(), $className);
$path = $destPath . DIRECTORY_SEPARATOR . str_replace('\\', '.', $className) . '.php';
$output->writeln(sprintf(' > writing <comment>%s</comment>', $path));
$code = $exporter->exportClassMetadata($class);
if (!is_dir($dir = dirname($path))) {
mkdir($dir, 0775, true);
}
file_put_contents($path, $code);
chmod($path, 0664);
}
return 0;
} else {
$output->writeln('Database does not have any mapping information.', 'ERROR');
$output->writeln('', 'ERROR');
return 1;
}
}
/**
* Get metadata
*
* @return array
*/
protected function getMetadata()
{
$sm = $this->em->getConnection()->getSchemaManager();
$driver = new DatabaseDriver($sm);
$driver->setNamespace($this->getNsEntity());
$this->em->getConfiguration()->setMetadataDriverImpl($driver);
$cmf = new DisconnectedClassMetadataFactory();
$cmf->setEntityManager($this->em);
$metadata = $cmf->getAllMetadata();
if (count($this->getFilter()) > 0) {
$metadata = MetadataFilter::filter($metadata, $this->getFilter());
}
return $metadata;
}