PHP Doctrine 2 - So speichern Sie One to Many-Beziehung automatisch mit Cascade-Optionen

Question

Ich bin nicht in der Lage, eine Beziehung in Doctrine 2 mit Cascade zu speichern. In meiner Anwendung haben Computer viele Aktionen, und eine Aktion kann zu vielen verschiedenen Computern gehören. Aber ich habe auch ein zusätzliches Attribut, Active, um festzulegen, welche Aktionen aktiv sind pro Computer.

Meine Tabellen sind die folgenden:

CREATE TABLE IF NOT EXISTS computers (
     id INT NOT NULL PRIMARY KEY AUTO_INCREMENT, 
     name VARCHAR(50) NOT NULL UNIQUE, 
     os VARCHAR(30) NOT NULL, 
     date_creation TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP, 
     date_modification TIMESTAMP, 
     online BOOLEAN NOT NULL DEFAULT FALSE, 
     id_user_creation INT, 
     id_user_modification INT DEFAULT NULL, 

     CONSTRAINT fk_users_computers_creation FOREIGN KEY (id_user_creation) REFERENCES users(id), 
     CONSTRAINT fk_users_computers_modification FOREIGN KEY (id_user_modification) REFERENCES users(id) 
); 

CREATE TABLE IF NOT EXISTS actions (
     id INT NOT NULL PRIMARY KEY AUTO_INCREMENT, 
     name VARCHAR(50) NOT NULL UNIQUE, 
     description TEXT, 
     date_creation TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP, 
     date_modification TIMESTAMP, 
     id_user_creation INT NOT NULL, 
     id_user_modification INT DEFAULT NULL, 

     CONSTRAINT fk_users_actions_creation FOREIGN KEY (id_user_creation) REFERENCES users(id), 
     CONSTRAINT fk_users_actions_modification FOREIGN KEY (id_user_modification) REFERENCES users(id) 
); 

CREATE TABLE IF NOT EXISTS computers_actions (
     id INT NOT NULL PRIMARY KEY AUTO_INCREMENT, 
     id_computer INT NOT NULL, 
     id_action INT NOT NULL, 
     active BOOLEAN NOT NULL DEFAULT FALSE, 

     CONSTRAINT fk_computers FOREIGN KEY (id_computer) REFERENCES computers(id), 
     CONSTRAINT fk_actions FOREIGN KEY (id_action) REFERENCES actions(id) 
); 

Der obige Code nur ein Stück meiner Datenbank-Skript ist, derjenige, der von meinem aktuellen Problem betroffen ist. Meine Einheiten sind die folgenden:

Der Computer-Entität:

/** 
* @var ArrayCollection 
* @OneToMany(targetEntity="ComputerAction", mappedBy="computer", cascade={"persist"}) 
*/ 
private $actions; 

public function __construct() 
{ 
    $this->actions = new ArrayCollection(); 
} 

Die Aktion Entity:

/** 
* @var ArrayCollection 
* @OneToMany(targetEntity="ComputerAction", mappedBy="action", cascade={"persist"}) 
*/ 
private $computers; 

public function __construct() 
{ 
    $this->computers = new ArrayCollection(); 
} 

Die Beziehung, ComputerAction Entity. Ich brauche ein Attribut für diese Beziehung, deshalb habe ich die Annotation von ManyToMany nicht verwendet. In diesem Fall hat ein Computer viele ComputerAction und eine ComputerAction hat nur einen Computer. Das Gleiche passiert mit der Aktion.

/** 
* @var Computer 
* @ManyToOne(targetEntity="Computer", inversedBy="actions", cascade={"persist"}) 
* @JoinColumn(name="id_computer", referencedColumnName="id") 
*/ 
private $computer; 

/** 
* @var Action 
* @ManyToOne(targetEntity="Action", inversedBy="computers", cascade={"persist"}) 
* @JoinColumn(name="id_action", referencedColumnName="id") 
*/ 
private $action; 

/** 
* @var boolean 
* @Column(type="boolean") 
*/ 
private $active; 

Diese Attribute haben ihre eigenen Getter und Setter, und wie Sie feststellen können, haben die OneToMany diejenigen, die Lehre Arraycollection-Typ.

Hinzufügen von Aktionen des mein Computer in der Aktion erfolgt hinzufügen aus den ComputerController, die weiter unten folgen:

// ComputerController, action add 

$computer->setName($post['name']); 
$computer->setOs($post['os']); 
$computer->setOnline(false); 
$computer->setUserOwner($this->getUserService()->find($this->retrieveUser()['id'])); 

foreach($post['action'] as $id_action) { 
    $relation = new ComputerAction(); 
    $relation->setAction($this->getActionService()->find($id_action)); 
    $relation->setComputer($computer); 
    $computer->setActions($relation); 
} 

if($computer = $this->getComputerService()->save($computer)) { 
    $this->setMessage(sprintf('Computer [%s] added successfully!', $computer->getName()), MessageSkin::SUCCESS); 
} else { 
    $this->setMessage('The Computer could not be added. Try again later.', MessageSkin::DANGER); 
} 

In der Computer-Ansicht hinzufügen, ich habe eine Select Multiple mit Aktionen IDs. Ich erhalte diese IDs, und innerhalb einer Schleife erstelle ich eine neue ComputerAction, die das $ action-Attribut als die Action-Entität setzt, die diese ID enthält. Dann setze ich den aktuellen Computer in das $ computer-Attribut und schließlich füge ich diese Instanz von ComputerAction der $ actions ArrayCollection in Computer Entity hinzu.

Das Problem ist: Warum werden die ComputerAction-Entitäten nicht gespeichert?

Ich versuchte viele verschiedene Ansätze mit den Cascade-Optionen, aber nicht erfolgreich. Bitte helfen Sie!

Danke!

Siipe

Answer 1

Ich habe mein Problem gelöst, indem ich das Attribut $ active auf "false" gesetzt habe, da es in der Datenbank nicht null sein kann. Ich weiß nicht wirklich warum es passiert ist, da es auf der Datenbank DEFAULT FALSE ist. Die Doktrin hat mich weder gewarnt noch irgendeinen Fehler gemeldet.

Answer 2

Sie sollten in jeder Beziehung Lehre Haupteinheit und kartiert Einheit hat (Slave Einheit) in einer Beziehung nicht vergessen, dass. Es geht um OneToOne, OneToMany, ManyToMany Beziehungen und andere. Sie können die Haupteinheit nicht von der Slave-Einheit speichern, egal, was Sie schreiben.

Dies könnte Ihnen vielleicht helfen.