How association mapping Many-To-One or two using doctrine? - php

Question

I have two entities, Student and Responsible (father/mother or tutors). I have to keep both information in the database, so I have to relate both. I think that the best way would be an association Many-To-One adding a foreign key of each responsible (two maximum) in the Student table. I do not know if this would be possible with this association or whether it would be necessary to make a one Many-To-Many association.
use Doctrine\ORM\Mapping as ORM;
class Student{
....
/**
*#ORM\ManyToOne(targerEntity="myBundle\Entity\Responsible")
*#ORM\JoinColumn(name="responsible_id", referencedColumnName="id")
*/
protected $responsible;
}
I'm a bit new to the topic, I appreciate any help possible.

Answer 1

Change to Many-To-Many
I would change to Many-To-Many This means one Responsible can be responsible for several students (a collection of Student) and a student can have many responsibles (a collection of Responsible):
<?php
use Doctrine\ORM\Mapping as ORM;
class Responsible
{
/**
*#ORM\ManyToMany(targetEntity="myBundle\Entity\Student", mappedBy="responsibles")
*/
private $students;
/**
* It is important to initialize your $students collection
*/
public function __construct(){
$students = new ArrayCollection
}
// ALL STUDENT SETTERS + GETTERS
/**
* Get students
*
* #return Collection
*/
public function getStudents()
{
return $this->students;
}
/**
* Add student.
*
* #param Student $student
* #return self
*/
public function addStudent(Student $student)
{
$this->students[] = $student;
return $this;
}
/**
* Add students.
*
* #param Collection $students
* #return self
*/
public function addStudents(Collection $students)
{
foreach ($students as $student) {
$this->addStudent($student);
}
return $this;
}
/**
* Remove student.
*
* #param Student $student
*/
public function removeStudent(Student $student)
{
$this->students->removeElement($student);
}
/**
* Remove students.
*
* #param Collection $students
* #return self
*/
public function removeStudents(Collection $students)
{
foreach ($students as $student) {
$this->removeStudent($student);
}
return $this;
}
}
In your Student:
<?php
use Doctrine\ORM\Mapping as ORM;
class Student
{
/**
*#ORM\ManyToMany(targetEntity="myBundle\Entity\Responsible", mappedBy="student")
* #ORM\JoinTable(name="student_responisble",
* joinColumns={#ORM\JoinColumn(name="student_id", referencedColumnName="id")},
* inverseJoinColumns={#ORM\JoinColumn(name="responsible_id", referencedColumnName="id")}
* )
*/
private $responsibles;
/**
* It is important to initialize your $responsibles collection
*/
public function __construct(){
$responsibles = new ArrayCollection
}
// ALL RESPONSIBLE SETTERS + GETTERS
/**
* Get responsibles
*
* #return Collection
*/
public function getResponsibles()
{
return $this->responsibles;
}
/**
* Add responsible.
*
* #param Responsible $responsible
* #return self
*/
public function addResponsible(Responsible $responsible)
{
$this->responsibles[] = $responsible;
return $this;
}
/**
* Add responsibles.
*
* #param Collection $responsibles
* #return self
*/
public function addResponsibles(Collection $responsibles)
{
foreach ($responsibles as $responsible) {
$this->addResponsible($responsible);
}
return $this;
}
/**
* Remove responsible.
*
* #param Responsible $responsible
*/
public function removeResponsible(Responsible $responsible)
{
$this->responsibles->removeElement($responsible);
}
/**
* Remove responsibles.
*
* #param Collection $responsibles
* #return self
*/
public function removeResponsibles(Collection $responsibles)
{
foreach ($responsibles as $responsible) {
$this->removeResponsible($responsible);
}
return $this;
}
}
Alternative solution
If you really want to restrict the amount of responsibles for one student then you could also add the two responsible persons directly to student as $firstResponsible and $secondResponsible and add a custom getResponsibles method so you can get them all at once in an array. You can later also add a $thirdResponsible if necessary of course.
<?php
use Doctrine\ORM\Mapping as ORM;
class Student
{
/**
* #ORM\ManyToOne(targerEntity="myBundle\Entity\Responsible")
* #ORM\JoinColumn(name="first_responsible_id", referencedColumnName="id")
*/
private $firstResponsible;
/**
* #ORM\ManyToOne(targerEntity="myBundle\Entity\Responsible")
* #ORM\JoinColumn(name="second_responsible_id", referencedColumnName="id")
*/
private $secondResponsible;
/**
* Set first responsible
*
* #param Responsible $responsible
* #return self
*/
public function setFirstResponsible(Responsible $responsible)
{
$this->firstResponsible = $responsible;
return $this;
}
/**
* Get first responsible
*
* #return Responsible
*/
public function getFirstResponsible()
{
return $this->firstResponsible;
}
/**
* Set second responsible
*
* #param Responsible $responsible
* #return self
*/
public function setSecondResponsible(Responsible $responsible)
{
$this->secondResponsible = $responsible;
return $this;
}
/**
* Get second responsible
*
* #return Responsible
*/
public function getSecondResponsible()
{
return $this->secondResponsible;
}
/**
* Get student responsibles
*
* #return array
*/
public function getResponsibles()
{
$responsibles = array();
if(isset($this->firstResponsible)){
$responsibles[] = $this->firstResponsible;
}
if(isset($this->secondResponsible)){
$responsibles[] = $this->secondResponsible;
}
return $responsibles;
}
}

Answer 2

Well, a student can have more than one Responsible (tutor, father or mother) and it's presumably possible that a tutor could be mentoring more than one student, or a parent might have more than one child who is a student.
So a many to many relationship would work best here. Even if you have a limit of two Responsible entities, there's still a many to many requirement based on the information you've given.

Answer 3

Of course it's possible as it's not complicated case.
You can use ManyToMany association if one Responsible can have more than one Student else it's enough to use bidirectional ManyToOne association in your Student entity:
use Doctrine\ORM\Mapping as ORM;
class Student
{
/**
*#ORM\ManyToOne(targetEntity="myBundle\Entity\Responsible", inversedBy="student")
*/
private $responsible;
}
and your Responsible entity should be:
use Doctrine\ORM\Mapping as ORM;
class Responsible
{
/**
*#ORM\OneToMany(targetEntity="myBundle\Entity\Responsible", mappedBy="responsible")
*/
private $student;
}
JoinColumn is not necessary if you want to use standard naming for your fields: field_id.
Also you should use private properties if you do not plan to inherit from your entities.
Please read well written official Symfony documentation and Doctrine documentation for more information about the topic.