• Jeder User im Forum verpflichtet sich zur Akzeptanz und zur Einhaltung dieser Regeln:
    1. Umgangston
      Ein angemessener höflicher Umgangston, ohne Beleidigungen, Beschimpfungen und aggressive Postings ist für jedes Mitglied Pflicht.
    2. Beiträge
      Jedes Mitglied sollte sich bemühen nur sinnvolle Beiträge zum Thema zu posten. Dabei ist unbedingt vorher zu prüfen, ob das Thema vorher schon einmal diskutiert wurde und daher fortgesetzt werden kann
      • Suchfunktion benutzen!
      • offizielle Doku lesen!
    3. Haftung
      Jeder Beitragsersteller übernimmt die alleinige Verantwortung seiner Inhalte.
    4. Werbung
      Wir erlauben keine Beiträge, Signaturen, Private Nachrichten oder eMails an Benutzer, die Werbung enthalten. Ausgenommen
      sind Stellengesuche /-angebote, welche ausschließlich im Forum "Stellengesuche" veröffentlicht werden dürfen.
    5. Verstöße
      Regelwidrige Beiträge sollten dem Team gemeldet werden. Nach deren Überprüfung werden wir schnellstmöglich
      entsprechend handeln.
    6. Authorität
      Den Anweisungen der Team-Mitglieder (Administratoren und Moderatoren) sind in diesem Forum Folge zu leisten.
      Bei Fragen oder Beschwerden bitte an diese wenden.
    Wir möchten Euch darauf aufmerksam machen, dass es bei Verstößen gegen einen oder mehreren der oben genannten
    Punkte dem Team frei steht entsprechend zu handeln. Dies kann z.B. das Löschen eines Beitrags, das Ausschliessen bzw.
    Sperren von Mitgliedern oder aber lediglich eine Verwarnung sein.

    In diesem Zusammenhang sollte erwähnt werden, dass das Forum automatisch die IP-Adresse jedes Beitrag-Erstellers
    speichert. Bei schweren Vergehen, behalten wir es uns vor, die IP-Adresse zur Strafverfolgung weiterzugeben.
  • Willkommen im Zend Framework Forum

    ZF1 Zend Framework 1 + ZF2 Zend Framework 2

    Das Zend Framework Forum ist seit 2006 die erste Anlaufstelle für Zend Framework Entwickler in Deutschland. Mit über 70.000 Beiträgen und einer steigenden Nutzerzahl bietet das Forum hilfreiche Themen und ZF-Tutorials für professionelle Entwickler, fortgeschrittene Programmierer sowie Zend Framework Einsteiger.
    Wenn dies Dein erster Besuch in der Zend Framework Community ist, lies bitte zuerst die Hilfe - FAQ durch. Du musst Dich registrieren, bevor Du Beiträge verfassen kannst. Klicke oben auf 'Registrieren', um die Registrierung zu starten. Du kannst auch jetzt schon Beiträge lesen. Hier im Forum findest Du die Zend Framework Hilfe, die Du suchst!

    Grüße an alle Zend Framework Entwickler. Das Team vom Zend Framework Forum!

    Drupal Agentur

Doctrine2 Standard Beziehung von Entities

domeb

New member
Hi,

db.jpg

ein Kunde hat mehrere Kundengruppen, in welche Personen zugewiesen werden (Siehe Datenbankmodell Bild). Kundengruppen können vom Kunde frei definiert werden. Nun ist es so, dass jeder Kunde die Kundengruppe "Standard" besitzen soll, in die eine Person automatisch eingefügt wird, wenn keine andere Kundengruppe gewählt wird. Meine Frage ist nun wie ich das am besten lösen soll?


  1. Beim erstellen vom Kunde wir automatisch die Kundengruppe "Standard" erstellt, welche dann nicht gelöscht oder editiert werden kann, etc...
  2. Die Person erhält den Wert "NULL" in der Beziehung zur Kundengruppe, wodurch soweit klar ist, dass dieser keiner bzw. der Gruppe "Standard" angehört
Persönlich finde ich den zweiten Weg um einiges Besser. Dabei entsteht aber folgendes Problem: Es gibt eine Liste aller Kundengruppen, mit den zugewiesenen Personen. Hier hätte ich dann nicht die Möglichkeit über die Kundengruppen des Kunden zu iterieren und dessen Personen auszugeben, da ja die Gruppe "Standard" gar nicht existiert. kann ich diese irgendwie on the fly in der methode der Service Klasse generieren, welche mir die Kundengruppen eines Kunden zurück gibt?

Danke euch für jegliche Hinweise...
 

Powers

New member
Hi,

ich denke ich würde Vorschlag 1 umsetzen mit einer ManyToOne-Relation die beim erstellen des Nutzers gesetzt wird und dann geändert werden kann. Eine wirklich existierende Gruppe (wenn auch nur "Standard") ist im zweifelsfall doch persistenter.

Etwa so:

PHP:
// entity User
/**
* @ORM\ManyToOne(targetEntity="Group")
* @ORM\JoinColumn(name="group_id", referencedColumnName="id")
*/
protected $group;
Manchmal kommt es ja auch erst im späteren Entwicklungsverlauf zu Tage, dass auch irgendein Standardwert ggf Werte haben sollte, die man abfragen will.
 
Zuletzt bearbeitet:

domeb

New member
Das mit dem Customer,den Personen und deren Beziehungen im Modell stimmt soweit schon, will hier aber nicht näher auf das Thema eingehen, da es nicht Zielführend ist :)

Ja ich denke ich werde es auch über die "reelle" Entity machen. Muss mir dann nur überlegen, wie ich das mit dem editieren und löschen der Gruppen mache, da diese dies ja nicht können darf... Es gibt z. B. den Fall, dass eine Gruppe gelöscht wird, in welcher Personen sind. Diese Personen müssen dann der Standard Gruppe zugewiesen werden. Das ist dann aber wieder Programmlogik...
 

Powers

New member
Und Du bist Dir auch sicher, dass eine Person nicht auch mehrere Gruppen haben darf? Weil das ist oftmals auch ein Königsweg (bei Typo3 im Grunde gängig, sofern gewollt). Was Du beschreibst klingt irgendwie danach, als könnte auch eine ManyToMany Relation zwischen Usern und Gruppen entstehen, auch wenn letztlich nur eine Gruppe zählt (nämlich, falls gesetzt, die nicht-Standard-Gruppe). In dem Fall könnte einfach jeder einer Standardgruppe gehören und ggf. bei Bedarf noch einer weiteren Gruppe, die dann weitere Möglichkeiten eröffnet.

Die Vorgehensweise habe ich jetzt von Typo3 abgeguckt und finde das auch zielführend, da die stets gesetzte Standardgruppe automatisch Dein Fallback wird, sobald eine übergeordnete Gruppe sich in Luft auflöst. Kann Dich da gerne mit Code zu ManyToMany, ArrayCollection, add- remove-Code versorgen, falls da ggf noch know-how in Doctrine fehlen sollte :)

Da könnte man dann einem Nutzer nach Bedarf Gruppen hinzugefügen und wieder entfernen, wären aber mindestens Mitglied der Standard-Gruppe (die natürlich nicht löschbar ist). Damit entledigt man sich dann dem Aufwand, an allen Ecken irgendwelche if-else Zusammenhänge aufzulösen (falls keine Gruppe, dann...).
 
Zuletzt bearbeitet:

domeb

New member
Hi Powers,

Danke für deine Unterstützung, ich komme bei Bedarf auf jeden Fall auf dich zurück ;-)

Nach langem hin und her haben wir uns dazu entschieden, die default Gruppe zu entfernen, wodurch der Kunde gezwungen ist, vorerst min. eine Kundengrupppe anzulegen. Nun kommt ein weiteres Problem dazu. Es ist so, dass es mehrere Kunden gibt, welche individuelle Kundengruppen haben. Beim erstellen einer Person, muss also eine Kundengruppe des entsprechenden Kunden gewählt werden...

Ich wollte das eigentlich mit dem Doctrine2 ObjectSelect element machen, bei welchem ich ja auch eine Methode aus meinem custom repository angeben kann, um die Auswahl der Kundengruppe auf die eines Kunden zu minimieren. Dazu habe ich eine Methode findByCustomer($customer), welche mir alle Gruppen eines kunden liefert. Nun habe ich aber im Formular eine Abhängigkeit zu einem Kunden, wo ich nicht richtig weiterkomme. Dumm ausgedrückt, wird der Kunde über die URL selektiert. /admin/customer/1/person/add => Bedeutet, dass ich eine Person zum Kunde mit der ID 1 hinzufügen möchte. Somit hab ich das Kundenobjekt im Controller zur verfügung, könnte es auch an das Formular übergeben, aber leider ist es dort schon zu spät, da das Fomrular bereits initialisiert wurde... Hier mal meine Controller action und das Formular

PHP:
public function addAction() {
    $customerId = $this->params()->fromRoute('customerId');
    $customer = $this->customerService->getCustomer($customerId);
        
    $this->personForm->setCustomer($customer);
       
    return array(
        'personForm' => $this->personForm
    );
}
PHP:
namespace Customer\Form;

use Customer\Entity\Customer;
use Doctrine\Common\Persistence\ObjectManager;
use DoctrineModule\Persistence\ObjectManagerAwareInterface;
use Zend\Form\Form;

class PersonForm extends Form implements ObjectManagerAwareInterface {
    public function init() {
        $this->add(array(
            'type' => 'ObjectSelect',
            'name' => 'customerGroup',
            'options' => array(
                'label' => 'Customer Group',
                'empty_option' => '-- Please Choose --',
                'object_manager' => $this->getObjectManager(),
                'target_class' => 'Customer\Entity\CustomerGroup',
                'property' => 'name',
                'is_method' => true,
                'find_method' => array(
                    'name' => 'findByCustomer',
                    'params' => array(
                        'customer' => $this->getCustomer(),
                    )
                )
            )
        ));
    }

    public function getCustomer() {
        return $this->customer;
    }

    public function setCustomer(Customer $customer) {
        $this->customer = $customer;
        return $this;
    }
}
Irgendwelche Lösungsvorschläge? :)
 

Powers

New member
Hey,

also wenn ich das Problem richtig verstehe hast Du das constructor-Problem - Du hast eine Instanz erstellt und versäumt, beim Erstellen die notwendigen Daten mitzugeben, wodurch der Zug abgefahren ist.

Was wäre, wenn Du auf die (eigentlich sehr sauber gedacht!) getter und setter von Customer verzichtest und Dein Formular im Controller folgend aufrust:
PHP:
$this->personForm($customer)
Während Du im Formular aus "init()" ein "__construct" machst:

PHP:
public function __construct($customer) {
        $this->add(array(
            'type' => 'ObjectSelect',
            'name' => 'customerGroup',
            'options' => array(
                'label' => 'Customer Group',
                'empty_option' => '-- Please Choose --',
                'object_manager' => $this->getObjectManager(),
                'target_class' => 'Customer\Entity\CustomerGroup',
                'property' => 'name',
                'is_method' => true,
                'find_method' => array(
                    'name' => 'findByCustomer',
                    'params' => array(
                        'customer' => $customer,
                    )
                )
            )
        ));
    }
So würde Dein Formular bei der Initialisierung den Customer-Wert erhalten.
 
Zuletzt bearbeitet:

domeb

New member
Das Formular wird nicht im Controller erzeugt, sondern wird via controller factory in den controller eingefügt. Das Formular wird über den FormElementManager bezogen, wodurch dieses die init methode verwenden muss, da sonst z. B. der Doctrine ObjectManager im constructor ebenfalls nicht zur Verfügung steht.

Ich habe es nun so gemacht, dass ich in der Form factory die customer id vom request hole, daraus das Kundenobjekt, und dieses dann in das Form Objekt einfüge. Funktioniert soweit eigentlich, kann mir nur nicht vorstellen, dass das die Super Lösung ist :) Dadurch ergibt sich bei mir folgende Factory:

PHP:
class PersonFormFactory implements FactoryInterface {
    
    public function createService(ServiceLocatorInterface $formElementManager) {
        $serviceLocator = $formElementManager->getServiceLocator();
        $customerService = $serviceLocator->get('Customer\Service\Customer');
        $objectManager = $serviceLocator->get('Doctrine\ORM\EntityManager');
        $inputFilterManager = $serviceLocator->get('InputFilterManager');
        $hydratorManager = $serviceLocator->get('HydratorManager');
        
        $router = $serviceLocator->get('Router');
        $request = $serviceLocator->get('Request');
        $routeMatch = $router->match($request);
        $customerId = $routeMatch->getParam('customerId');
        $customer = $customerService->getCustomer($customerId);
        
        $form = new PersonForm($customer);
        $form->setObjectManager($objectManager);
        $form->setInputFilter($inputFilterManager->get('Customer\InputFilter\Person'));
        $form->setHydrator($hydratorManager->get('Application\Hydrator\Doctrine'));
        $form->bind(new Person());
        
        return $form;
    }
    
}
Am Formular hat sich eigentlich nichts geändert. Nur dass ich nun, wie du auch schon gesagt hast, den Customer über den Konstruktor rein gebe...
 

michl

New member
Das Request Object hat absolut NICHTS in der Form Factory verloren!

Als Tip: http://framework.zend.com/apidoc/2.3/classes/Zend.ServiceManager.MutableCreationOptionsInterface.html

Du musst auch nicht über den Konstructor gehen. (wie du im Konstruktor auf $this->getObjectManager() zugreifen willst, musst du mir zeigen ;) )
Via $this->getOption('...'); hast du in der init() Methode vollen Zugriff auf die Options.


e:
PHP:
use Zend\ServiceManager\FactoryInterface;
use Zend\ServiceManager\ServiceLocatorInterface;
use Zend\ServiceManager\MutableCreationOptionsInterface;
use BadMethodCallException;

class PersonFormFactory implements FactoryInterface, MutableCreationOptionsInterface 
{

    /**
     * @var array
     */
    protected $creationOptions = [];

    /**
     * @param array $creationOptions
     */
    public function setCreationOptions(array $creationOptions)
    {
        if (!isset($creationOptions['customerId']) {
             throw new BadMethodCallException("No customerId received via creationOptions");
        }
        $this->creationOptions = $creationOptions;
    }
    
    public function createService(ServiceLocatorInterface $formElementManager) {
        $serviceLocator = $formElementManager->getServiceLocator();
        $customerService = $serviceLocator->get('Customer\Service\Customer');
        $objectManager = $serviceLocator->get('Doctrine\ORM\EntityManager');
        $inputFilterManager = $serviceLocator->get('InputFilterManager');
        $hydratorManager = $serviceLocator->get('HydratorManager');
        
         
        $form = new PersonForm(
            'person', 
            ['customer' => $customerService->getCustomer($this->creationOptions['customerId'])]
        );


        $form->setObjectManager($objectManager);
        $form->setInputFilter($inputFilterManager->get('Customer\InputFilter\Person'));
        $form->setHydrator($hydratorManager->get('Application\Hydrator\Doctrine'));
        $form->bind(new Person());
        
        return $form;
    }
    
}
Im Formular:
PHP:
public function init() {
        $this->add(array(
            'type' => 'ObjectSelect',
            'name' => 'customerGroup',
            'options' => array(
                'label' => 'Customer Group',
                'empty_option' => '-- Please Choose --',
                'object_manager' => $this->getObjectManager(),
                'target_class' => 'Customer\Entity\CustomerGroup',
                'property' => 'name',
                'is_method' => true,
                'find_method' => array(
                    'name' => 'findByCustomer',
                    'params' => array(
                        'customer' => $this->getOption('customer'),
                    )
                )
            )
        ));
    }
In deiner ControllerFactory Instanzierst du das Formular dann via
PHP:
$companyForm = $serviceLocator->get('FormElementManager')->get('Company', ['customerId' => 0815]);
 
Zuletzt bearbeitet:

domeb

New member
Hi michl,

ja das habe ich mir schon gedacht... Dein Ansatz ist interessant, aber wie komme ich dann in der controller factory zu meiner customer id? Die erhalte ich ja nur über den Pfad...

Danke und Gruß!
 

michl

New member
Klar. War nur ein Beispiel. Jetzt weiß ich allerdings was du meinst :)


PHP:
public function createService(ServiceLocatorInterface $sl)
{
    $companyForm = $sl->get('FormElementManager')->get(
        'Customer',
        [
            'customerId' => $sl->getServiceLocator()->get('Application')->getMvcEvent()->getRouteMatch()->getParam('customerId')
        ]
    );
}
 

domeb

New member
Ja ok, das hab ich mir schlussendlich auch gedacht. In der Controllerfactory ist es ja legitim den Request abzufragen...

Ich danke dir vielmals für deine Hilfe!
 

michl

New member
Gerne :)

Noch 1 Sache ...
Du instanzierst das Formular wirklich IMMER wenn der Controller aufgerufen wird? Also egal bei welcher Action? Dann würde ich zumindest mal in Erwägung ziehen das Formular (und anderen Dependencies, bei denen das Sinn macht auch!) als LazyService zu injecten.

Bei dem Formular macht es alleine aus dem Grund schon Sinn, weil du in der FormFactory einen DB Query abfeuerst.

Lazy Services — Zend Framework 2 2.3.4 documentation - Zend Framework
 
Zuletzt bearbeitet:

domeb

New member
Hab ich in der Tat auf dem Zettel, im Moment liegen die Prioritäten aber noch woanders :) Aber danke für den hint!
 

domeb

New member
@Powers: Bzgl der Hilfestellung bei Beziehungen von Entities könnte ich deine Hilfe nochmals gebrauchen.

Ich habe ein Formular in dem ich Teilnahmen zu einer Umfrage speichern will. Die Teilnahme ist hierbei eine eigene Entity mit Verknüpfung zur Person und zur Umfrage. Nun hätte ich gerne zwei Multiselects. Im ersten stehen die verfügbaren Personen und im anderen stehen die, die bereits teilnehmen. Dort will ich dann Personen als Teilnehmer hinzufügen, bzw. entfernen können.

Mir fehlt hier total der Ansatz, wie ich das realisieren kann...

Danke und Gruß!
 

Powers

New member
Guten :)

Also wenn ich das fix durchdenke, hat Umfrage zu Teilnahmen eine ManyToMany-Beziehung? OneToMany wäre auch denkbar, aber da ich nicht alle Facetten Deiner Anwendung kenne, bleibe ich mal bei ManyToMany auf der sicheren Seite.
Hat es denn wirklich Sinn, dass es die Zwischentity "Teilnahme" gibt - besitzt diese nochmal extra-Informationen gegenüber einer Person?
-> ansonsten würde ich das schonmal verschlanken auf Umfrage:personen als ManyToMany. Würde zumindest das Dreieck konkret vereinfachen - muss aber natürlich nicht sein.

Aber egal wie Du es natürlich umsetzt, bei welchem Teil benötigst Du noch support? Nur bei der Form, oder auch beim modellieren innerhalb der Entities?

Ich gehe nun mal spontan mal davon aus, dass wir in dem Formular/Entity "Umfrage" sind, in welchem Teilnehmer hinzugefügt werden sollen.
Mein Tip wäre der, dass Du auf die Entity "Teilnehmer" verzichtest und stattdessen "teilnehmer" als Assoziation zwischen den Entity's "Umfrage" und "Person" reinbringst. Ich glaube das wäre Sinngemäß ein guter Ansatz.

Folgend müsste das assoziiert werden, damit Du eine Umfrage mit Personen (teilnehmern) verknüpfen kannst:
PHP:
// Entity Umfrage

use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\Common\Collections\Collection;

/**
* @ORM\ManyToMany(targetEntity="Person", cascade="persist")
* @ORM\JoinTable(name="umfragen_nm_personen",
*         joinColumns={@ORM\JoinColumn(name="umfrage_id", referencedColumnName="id")},
*         inverseJoinColumns={@ORM\JoinColumn(name="person_id", referencedColumnName="id")}
* )
*/
protected $teilnehmer;

// get, add & remove
/**
* teilnehmer
*/
public function getTeilnehmer()
{
   return $this->teilnehmer;
}

public function addTeilnehmer(Collection $teilnehmer)
{
    foreach ($teilnehmer as $einTeilnehmer) {
        $this->teilnehmer->add($einTeilnehmer));
    }
    return $this;
}

public function removeTeilnehmer(Collection $teilnehmer)
{
    foreach ($teilnehmer as $einTeilnehmer)) {
        $this->teilnehmer->removeElement($einTeilnehmer));
   }
   return $this;
}
Für diesen Vorschlag müsste es natürlich den assoziations-Table "umfragen_nm_personen" in Deiner Datenbank geben. Sinngemäß könnte man den Table auch "TeilnehmerAnUmfrage" nennen oder so :)
Die Vekrnüpfungstabellen müssen auch nicht nochmal als Entity o.ä. kenntlich gemacht werden. Einfach wie oben gezeigt angeben, dass reicht völlig aus.

Ein Multiselect davon könnte in der Form dann folgend umgesetzt werden:
PHP:
$this->add(array(
       'type'    => 'DoctrineModule\Form\Element\ObjectSelect',
       'name'    => 'teilnehmer',
       'attributes' => array(
           'multiple' => 'multiple',
           'size' => '10',
        ),
        'options' => array(
           'label'          => 'Teilnehmer',
           'object_manager' => $objectManager,
           'target_class'   => 'Application\Entity\Person',
           'value'             => 'id',
           'property'       => 'lastname',
        ),
));
Ich hoffe ich habe mit dem Ansatz getroffen, was Du benötigst. Hatte die Diskussion nach einigen Posts vom Abonnement genommen - daher die späte Antwort. Gerade erst zufällig beim browsen gesehen.

Frag ruhig nochmal gegen, wenn etwas unklar ist oder Du nicht weiterkommst. Falls Du an Deiner Entity "Teilnahme" festhalten solltest (und es nicht wie vorgeschlagen als reine Assoziation sehen möchtest), dann ergänze in meinem Beispiel die Entity "Person" durch Entity "Teilnahme". Die beiden Entitys "Person" und "Teilnahme" hätten dann natürlich wiederrum eine 1:1 Beziehung zueinander. Aber ich glaube, so muss das ggf nicht gelöst werden.

EDIT:
Ich vergas: Zu jeder Array-Collection (hier in der "Umfrage"-Entity) gehört auch ein Aufruf im Constructor der Entity, der die ArrayCollection initializiert:
PHP:
// Umfrage Entity
/**
* constructor
*/
public function __construct() {
    $this->teilnehmer = new ArrayCollection();
}
 
Zuletzt bearbeitet:

domeb

New member
Hey,

first of all vielen Dank für deine ausführliche Antwort...

Die Entity "Teilnahme" wird benötigt, da die Teilnehmer eingeladen werden, und über einen Hash identifiziert werden. Außerdem können die Teilnehmer selbst entscheiden, wenn Sie die Umgrafe "beenden" möchten. Habe mal ein vereinfachtes DB-Modell ergänzt, dass dies eventuell etwas klarer wird.

db.jpg

mich hat leider die Grippe erwischt, wodruch ich gerade nicht wirklich weiter machen kann. Werde es aber schnellstmöglich veruschen und gebe dann nochmals bescheid!

Gruß
Dominik
 

Powers

New member
Alles klar, war auch nur ein Vorschlag, den Weg zu verkürzen :)

Wie erwähnt, müsstest Du dann im Beispiel statt Entity "Person" dann überall auf die Entity "Umfrage" umschreiben. Das Kernproblem (wie Du bereits selbst siehst und daher hier die Frage gesellt hast), sehe ich dann darin, dass beim Erstellen einer "Umfrage" die OneToOne Verbindung zwischen "Teilnahme" und "Person" zu dem Zeitpunkt noch nicht existiert. Mann kann Formulare auch verschachteln und einige Beziehungen darstellen - und mit etwas Geschick geht es ggf auch so dynamisch, dass Du sowohl eine unbegerenzte Anzahl an "Teilnahmen" generieren, als auch je Teilnahme den Benutzer zuweisen kannst, aber so konkret ist das ja eher kniffelig.

Im Grunde ist Teilnahme (participation) ja eine ManyToMany-Tabelle, wie ich Dir oben vorgeschlagen habe. Mit der einzigen Besonderheit, dass sie etwas mehr können soll, als nur verknüpfen.

Also entweder, Du lagerst die beiden Properties (ggf etwas unsauber) in die Entity "Person" aus und setzt es um wie empfohlen - ooooder Du gehst etwas mehr rein in die Materie. Habe eben mal etwas gegoogelt, was Dein Problem anbelangt mit dem Hinweis, dass es nicht möglich ist, was Du vorhast (ein Association-Table with extra columns: properties - Doctrine 2: How to handle join tables with extra columns - Stack Overflow)

Aber dort ist auch gleich ein Hinweis-Link für einen Umgang mit der Situation "Doctrine 2: How to handle join tables with extra columns":
Doctrine 2: How to handle join tables with extra columns ● Future500 B.V.

Das solltest Du dir an der Stelle das einfach mal geben, wenn Du es definitiv so umsetzen willst, wie Du es konkret aufzeigst. Ich habe mich da jetzt nicht direkt reindenken wollen in den Link, aber das Schlußzitat macht doch Hoffnung darauf, dass es nicht so schwer ist:
"Hopefully this demonstrates that working with these one-to-many/many-to-one setups is not that hard. The trick is to shift you way of thinking. It's not a join table with extra columns, it's a real object with its own data linking 2 other objects."

Klingt sogesehen, als wärst Du schon auf dem richtigen Weg mit dem, was Du willst. Falls es aber dennoch irgendwie nicht hinhauen soll, kannste ja nochmal nachfragen. Und: Gute Besserung!
 
Zuletzt bearbeitet:
Oben