Chciałbym wygenerować automatycznie metody dla modeli powiązanych relacjami wg dokumentacji http://symfony.com/doc/current/cookbook/do...ngineering.html .

Robię to komendą generate:doctrine:entities i nic, nie dodaje żadnych metod, mimo że konsola nie wyrzuca błędów.




Od początku.

Wygenerowałem bazę na podstawie diagramu ER i utworzyłem ją na serwerze. Tę bazę komendą doctrine:mapping:import i doctrine:mapping:convert annotation i doctrine:generate:entities sprowadziłem do projektu Symfony i utworzyłem modele.

Dokumentacja mówi, że te komendy nie generują w pełni kodu i trzeba ręcznie dodać parę rzeczy.
(If you want to have a one-to-many relationship, you will need to add it manually into the entity or to the generated XML or YAML files. Add a section on the specific entities for one-to-many defining the inversedBy and the mappedBy pieces.)

Dodałem brakujące adnotacje relacji OneToMany i zmodyfikowałem relacje ManyToOne . Po tych zmianach uruchomiłem komendę doctrine:generate:entities i w efekcie nie dodał do klas żadnych nowych metod takich jak __construct() czy addxxx().



Co źle robię?



Dla przykładu wkleję dwa modele powiązane relacją ManyToOne. Ręcznie dodałem adnotacje OneToMany w klasie Kategoria.php i zmodyfikowałem ManyToOne w klasie Ksiazka.php.

ręcznie dodałem kod linii 32-35

[PHP] pobierz, plaintext 
#Kategoria.php
<?php
 
namespace AppBundle\Entity;
 
use Doctrine\ORM\Mapping as ORM;
 
/**
 * Kategoria
 *
 * @ORM\Table(name="kategoria")
 * @ORM\Entity
 */
class Kategoria
{
    /**
     * @var string
     *
     * @ORM\Column(name="nazwa", type="string", length=45, nullable=true)
     */
    private $nazwa;
 
    /**
     * @var integer
     *
     * @ORM\Column(name="idKategoria", type="integer")
     * @ORM\Id
     * @ORM\GeneratedValue(strategy="IDENTITY")
     */
    private $idkategoria;
 
    /**
    * @ORM\OneToMany(targetEntity="Ksiazka", mappedBy="kategoria")
    */
    protected $ksiazki;
 
    /**
     * Set nazwa
     *
     * @param string $nazwa
     * @return Kategoria
     */
    public function setNazwa($nazwa)
    {
        $this->nazwa = $nazwa;
 
        return $this;
    }
 
    /**
     * Get nazwa
     *
     * @return string 
     */
    public function getNazwa()
    {
        return $this->nazwa;
    }
 
    /**
     * Get idkategoria
     *
     * @return integer 
     */
    public function getIdkategoria()
    {
        return $this->idkategoria;
    }
}
 
[PHP] pobierz, plaintext 

modyfikowałem kod linii 78-86

[PHP] pobierz, plaintext 
Ksiazka.php
<?php
 
namespace AppBundle\Entity;
 
use Doctrine\ORM\Mapping as ORM;
 
/**
 * Ksiazka
 *
 * @ORM\Table(name="ksiazka", indexes={@ORM\Index(name="idKategoria_idx", columns={"idKategoria"})})
 * @ORM\Entity
 */
class Ksiazka
{
    /**
     * @var string
     *
     * @ORM\Column(name="autor", type="string", length=45, nullable=true)
     */
    private $autor;
 
    /**
     * @var string
     *
     * @ORM\Column(name="opis", type="text", length=65535, nullable=true)
     */
    private $opis;
 
    /**
     * @var string
     *
     * @ORM\Column(name="cena", type="decimal", precision=10, scale=2, nullable=true)
     */
    private $cena;
 
    /**
     * @var string
     *
     * @ORM\Column(name="obrazek", type="string", length=45, nullable=true)
     */
    private $obrazek;
 
    /**
     * @var string
     *
     * @ORM\Column(name="wydawnictwo", type="string", length=45, nullable=true)
     */
    private $wydawnictwo;
 
    /**
     * @var string
     *
     * @ORM\Column(name="rokWydania", type="string", length=45, nullable=true)
     */
    private $rokwydania;
 
    /**
     * @var string
     *
     * @ORM\Column(name="isbn", type="string", length=45)
     * @ORM\Id
     * @ORM\GeneratedValue(strategy="IDENTITY")
     */
    private $isbn;
 
//    Było. Automatycznie wygenerowane bez inversedBy.
//    /**
//     * @var \AppBundle\Entity\Kategoria
//     *
//     * @ORM\ManyToOne(targetEntity="AppBundle\Entity\Kategoria")
//     * @ORM\JoinColumns({
//     *   @ORM\JoinColumn(name="idKategoria", referencedColumnName="idKategoria")
//     * })
//     */
//    private $idkategoria;
 
    /**
     * @var \AppBundle\Entity\Kategoria
     *
     * @ORM\ManyToOne(targetEntity="AppBundle\Entity\Kategoria", inversedBy="ksiazki")
     * @ORM\JoinColumns({
     *   @ORM\JoinColumn(name="idKategoria", referencedColumnName="idKategoria")
     * })
     */
    private $kategoria;
 
    /**
    * @ORM\OneToMany(targetEntity="Zamowienie_Produkt", mappedBy="ksiazka")
    */
    protected $zamowienie_produkty;
 
 
    /**
     * Set autor
     *
     * @param string $autor
     * @return Ksiazka
     */
    public function setAutor($autor)
    {
        $this->autor = $autor;
 
        return $this;
    }
 
    /**
     * Get autor
     *
     * @return string 
     */
    public function getAutor()
    {
        return $this->autor;
    }
 
    /**
     * Set opis
     *
     * @param string $opis
     * @return Ksiazka
     */
    public function setOpis($opis)
    {
        $this->opis = $opis;
 
        return $this;
    }
 
    /**
     * Get opis
     *
     * @return string 
     */
    public function getOpis()
    {
        return $this->opis;
    }
 
    /**
     * Set cena
     *
     * @param string $cena
     * @return Ksiazka
     */
    public function setCena($cena)
    {
        $this->cena = $cena;
 
        return $this;
    }
 
    /**
     * Get cena
     *
     * @return string 
     */
    public function getCena()
    {
        return $this->cena;
    }
 
    /**
     * Set obrazek
     *
     * @param string $obrazek
     * @return Ksiazka
     */
    public function setObrazek($obrazek)
    {
        $this->obrazek = $obrazek;
 
        return $this;
    }
 
    /**
     * Get obrazek
     *
     * @return string 
     */
    public function getObrazek()
    {
        return $this->obrazek;
    }
 
    /**
     * Set wydawnictwo
     *
     * @param string $wydawnictwo
     * @return Ksiazka
     */
    public function setWydawnictwo($wydawnictwo)
    {
        $this->wydawnictwo = $wydawnictwo;
 
        return $this;
    }
 
    /**
     * Get wydawnictwo
     *
     * @return string 
     */
    public function getWydawnictwo()
    {
        return $this->wydawnictwo;
    }
 
    /**
     * Set rokwydania
     *
     * @param string $rokwydania
     * @return Ksiazka
     */
    public function setRokwydania($rokwydania)
    {
        $this->rokwydania = $rokwydania;
 
        return $this;
    }
 
    /**
     * Get rokwydania
     *
     * @return string 
     */
    public function getRokwydania()
    {
        return $this->rokwydania;
    }
 
    /**
     * Get isbn
     *
     * @return string 
     */
    public function getIsbn()
    {
        return $this->isbn;
    }
 
    /**
     * Set idkategoria
     *
     * @param \AppBundle\Entity\Kategoria $idkategoria
     * @return Ksiazka
     */
    public function setIdkategoria(\AppBundle\Entity\Kategoria $idkategoria = null)
    {
        $this->idkategoria = $idkategoria;
 
        return $this;
    }
 
    /**
     * Get idkategoria
     *
     * @return \AppBundle\Entity\Kategoria 
     */
    public function getIdkategoria()
    {
        return $this->idkategoria;
    }
    /**
     * @var \AppBundle\Entity\Kategoria
     */
    private $idkategoria;
 
 
}
 
[PHP] pobierz, plaintext 

To są raczej generatory z doctrine, ale nie zmienia to faktu, że nie może tych encji wygenerować skoro już są wygenerowane. Doctrine zwyczajnie w świecie ma bardzo ubogi generator encji, co jest dla mnie zrozumiałe, bo ORM ma mapować obiekty do bazy, a nie bazę do obiektów.

Jeszcze teraz mi się rzucił w oczy getter i setter dla id kategoria, zupełnie niepotrzebne. Interesują nas obiekty a nie ich identyfikatory.

ale zdaje się, że komenda doctrine:generate:entities aktualizuje model o dodatkowe metody po dodaniu nowych właściwości?

(Z innej beczki. To jak to się profesjonalnie robi ? Myślałem, że najpierw projektuje się bazę, diagramy a dopiero potem modele w projekcie Symfony. No ale widzę, że w internetach nie wiele tematów dotyczących reverse engineering)

Ale diagramu modeli nie można wykonać czy co?

// EDIT

Proponuję się zapoznać z definicją ORMa

w szkołach kazali zaczynać od diagramów ER.
To od czego Wy rozpoczynacie projekty (proste), od pisania klas modeli?
----

No dobrze, ale wracając do istoty. Gdzie jest błąd, że komenda generate:doctrine:entities nie generuje metod __contruct i addXXX() w modelu Kategoria ?

----

Z podręcznika Gajdy:

Użycie relacji 1:n w Symfony 2
W Symfony 2 relacje 1:n definiujemy adnotacjami:
@ORM\OneToMany(...)
@ORM\ManyToOne(...)

W klasie Entity odpowiadającej tabeli źródłowej dodajemy adnotację @ORM\OneToMany ,
a w klasie odpowiadającej tabeli docelowej ? adnotację @ORM\ManyToOne . Powiązanie
tabel kontynent oraz panstwo jest zilustrowane na listingach 32.2 oraz 32.3.

[PHP] pobierz, plaintext 
#Listing 32.2. Właściwość i adnotacja definiujące relację 1:n w klasie źródłowej kontynent
class Kontynent
{
...
/**
* @ORM\OneToMany(targetEntity="Panstwo", mappedBy="kontynent")
*/
protected $panstwa;
...
}
[PHP] pobierz, plaintext 

[PHP] pobierz, plaintext 
#Listing 32.3. Właściwość i adnotacja definiujące relację 1:n w klasie docelowej panstwo
class Panstwo
{
...
/**
* @ORM\ManyToOne(targetEntity="Kontynent", inversedBy="panstwa")
*/
protected $kontynent;
...
}
[PHP] pobierz, plaintext 

Po dodaniu w klasach Kontynent oraz Panstwo właściwości z listingów 32.2 oraz 32.3
wydajemy polecenie:
php app/console generate:doctrine:entities My
Spowoduje ono dodanie w klasie Kontynent metod przedstawionych na listingu 32.4 oraz
w klasie Panstwo metod przedstawionych na listingu 32.5.

[PHP] pobierz, plaintext 
#Listing 32.4. Metody klasy Kontynent wygenerowane automatycznie dla właściwości z listingu 32.2
class Kontynent
{
...
public function __construct()
{
$this->panstwa = new \Doctrine\Common\Collections\ArrayCollection();
}
/**
* Add panstwa
*
* @param My\FrontendBundle\Entity\Panstwo $panstwa
*/
public function addPanstwo(\My\FrontendBundle\Entity\Panstwo $panstwa)
{
$this->panstwa[] = $panstwa;
}
/**
* Get panstwa
*
* @return Doctrine\Common\Collections\Collection
*/
public function getPanstwa()
{
return $this->panstwa;
}
...
}
[PHP] pobierz, plaintext 

Odświeżyłem swoją wiedzę na temat generowania encji. Skorzystaj z pomocy tego polecenia i zobaczysz opcje takie jak: update-entities i regenerate-entities.

w helpie doctrine:generate:entities?

nic tam nie widzę o tym co piszesz.

Na ten problem ciężko jest podać rozwiązanie, bo nie wiadomo, czy nie możesz otworzyć tej pomocy, czy nie rozumiesz angielskiego czy jest jakiś inny powód. Tutaj też nie widzisz nic na ten temat?

dzięki, sprawdzę to na pewno (później).



"Skorzystaj z pomocy tego polecenia i zobaczysz opcje takie jak: update-entities i regenerate-entities."

[PHP] pobierz, plaintext 
$ php app/console doctrine:generate:entities --help
Usage:
 doctrine:generate:entities [--path="..."] [--no-backup] name
 
Aliases: generate:doctrine:entities
Arguments:
 name                  A bundle name, a namespace, or a class name
 
Options:
 --path                The path where to generate entities when it cannot be gue
ssed
 --no-backup           Do not backup existing entities files.
 --help (-h)           Display this help message
 --quiet (-q)          Do not output any message
 --verbose (-v|vv|vvv) Increase the verbosity of messages: 1 for normal output,
2 for more verbose output and 3 for debug
 --version (-V)        Display this application version
 --ansi                Force ANSI output
 --no-ansi             Disable ANSI output
 --no-interaction (-n) Do not ask any interactive question
 --shell (-s)          Launch the shell.
 --process-isolation   Launch commands from shell as a separate process.
 --env (-e)            The Environment name. (default: "dev")
 --no-debug            Switches off debug mode.
 
Help:
 The doctrine:generate:entities command generates entity classes
 and method stubs from your mapping information:
 
 You have to limit generation of entities:
 
 * To a bundle:
 
   php app/console doctrine:generate:entities MyCustomBundle
 
 * To a single entity:
 
   php app/console doctrine:generate:entities MyCustomBundle:User
   php app/console doctrine:generate:entities MyCustomBundle/Entity/User
 
 * To a namespace
 
   php app/console doctrine:generate:entities MyCustomBundle/Entity
 
 If the entities are not stored in a bundle, and if the classes do not exist,
 the command has no way to guess where they should be generated. In this case,
 you must provide the --path option:
 
   php app/console doctrine:generate:entities Blog/Entity --path=src/
 
 By default, the unmodified version of each entity is backed up and saved
 (e.g. Product.php~). To prevent this task from creating the backup file,
 pass the --no-backup option:
 
   php app/console doctrine:generate:entities Blog/Entity --no-backup
 
 Important: Even if you specified Inheritance options in your
 XML or YAML Mapping files the generator cannot generate the base and
 child classes for you correctly, because it doesn't know which
 class is supposed to extend which. You have to adjust the entity
 code manually for inheritance to work!
 
 
chin@CHINY /C/wamp/www/Szobuk2
[PHP] pobierz, plaintext 

u mnie użycie komendy

[PHP] pobierz, plaintext 
doctrine:generate:entities AppBundle:Ksiazka --update-entities
[PHP] pobierz, plaintext 

powoduje

[PHP] pobierz, plaintext 
  [RuntimeException]                              
  The "--update-entities" option does not exist. 
[PHP] pobierz, plaintext 

ale, tak jak piszesz, istnieje i w moim projekcie klasa z opcjami update i regenerate

[PHP] pobierz, plaintext 
#\vendor\doctrine\orm\lib\Doctrine\ORM\Tools\Console\Command\GenerateEntitiesCom
mand.php
<?php
/*
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * This software consists of voluntary contributions made by many individuals
 * and is licensed under the MIT license. For more information, see
 * <http://www.doctrine-project.org>.
 */
 
namespace Doctrine\ORM\Tools\Console\Command;
 
use Symfony\Component\Console\Input\InputArgument;
use Symfony\Component\Console\Input\InputOption;
use Doctrine\ORM\Tools\Console\MetadataFilter;
use Doctrine\ORM\Tools\EntityGenerator;
use Doctrine\ORM\Tools\DisconnectedClassMetadataFactory;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Command\Command;
 
/**
 * Command to generate entity classes and method stubs from your mapping information.
 *
 * @link    www.doctrine-project.org
 * @since   2.0
 * @author  Benjamin Eberlei <kontakt@beberlei.de>
 * @author  Guilherme Blanco <guilhermeblanco@hotmail.com>
 * @author  Jonathan Wage <jonwage@gmail.com>
 * @author  Roman Borschel <roman@code-factory.org>
 */
class GenerateEntitiesCommand extends Command
{
    /**
     * {@inheritdoc}
     */
    protected function configure()
    {
        $this
        ->setName('orm:generate-entities')
        ->setAliases(array('orm:generate:entities'))
        ->setDescription('Generate entity classes and method stubs from your mapping information.')
        ->setDefinition(array(
            new InputOption(
                'filter', null, InputOption::VALUE_REQUIRED | InputOption::VALUE_IS_ARRAY,
                'A string pattern used to match entities that should be processed.'
            ),
            new InputArgument(
                'dest-path', InputArgument::REQUIRED, 'The path to generate your entity classes.'
            ),
            new InputOption(
                'generate-annotations', null, InputOption::VALUE_OPTIONAL,
                'Flag to define if generator should generate annotation metadata on entities.', false
            ),
            new InputOption(
                'generate-methods', null, InputOption::VALUE_OPTIONAL,
                'Flag to define if generator should generate stub methods on entities.', true
            ),
            new InputOption(
                'regenerate-entities', null, InputOption::VALUE_OPTIONAL,
                'Flag to define if generator should regenerate entity if it exists.', false
            ),
            new InputOption(
                'update-entities', null, InputOption::VALUE_OPTIONAL,
                'Flag to define if generator should only update entity if it exists.', true
            ),
            new InputOption(
                'extend', null, InputOption::VALUE_OPTIONAL,
                'Defines a base class to be extended by generated entity classes.'
            ),
            new InputOption(
                'num-spaces', null, InputOption::VALUE_OPTIONAL,
                'Defines the number of indentation spaces', 4
            )
        ))
        ->setHelp(<<<EOT
Generate entity classes and method stubs from your mapping information.
 
If you use the <comment>--update-entities</comment> or <comment>--regenerate-entities</comment> flags your existing
code gets overwritten. The EntityGenerator will only append new code to your
file and will not delete the old code. However this approach may still be prone
to error and we suggest you use code repositories such as GIT or SVN to make
backups of your code.
 
It makes sense to generate the entity code if you are using entities as Data
Access Objects only and don't put much additional logic on them. If you are
however putting much more logic on the entities you should refrain from using
the entity-generator and code your entities manually.
 
<error>Important:</error> Even if you specified Inheritance options in your
XML or YAML Mapping files the generator cannot generate the base and
child classes for you correctly, because it doesn't know which
class is supposed to extend which. You have to adjust the entity
code manually for inheritance to work!
EOT
        );
    }
 
    /**
     * {@inheritdoc}
     */
    protected function execute(InputInterface $input, 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'))
            );
        }
 
        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->writeln(
                    sprintf('Processing entity "<info>%s</info>"', $metadata->name)
                );
            }
 
            // Generating Entities
            $entityGenerator->generate($metadatas, $destPath);
 
            // Outputting information message
            $output->writeln(PHP_EOL . sprintf('Entity classes generated to "<info>%s</INFO>"', $destPath));
        } else {
            $output->writeln('No Metadata Classes to process.');
        }
    }
}
[PHP] pobierz, plaintext 

Oj, przepraszam, nie zauważyłem, że symfony ma swój generator encji.

Troszkę się chyba wyłamałeś tworząc strukturę projektu w klasach masz
namespace AppBundle\Entity;

gdzie indziej piszesz
\My\FrontendBundle\Entity

Powiedz dokładnie jaka jest ściezka do klasy co chcesz zrobic update, i wywal wszystkie metody get i set przy tym co sie nie robi update i wywołaj bez żadnych parametrów dodatkowych

php app/console doctrine:generate:entities My
(jezeli twój entityjest pod srv/My/FrontendBundle/Entity)

nie

generate:doctrine:entities

Pozdrawiam