src/JuridicusBundle/Entity/ProtokollInfothekPruefer.php line 20

Open in your IDE?
  1. <?php
  3. namespace JF\JuridicusBundle\Entity;
  5. use Doctrine\ORM\Mapping as ORM;
  6. use Symfony\Component\Validator\Constraints as Assert;
  7. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  8. use JF\JuridicusBundle\Validator\Constraints as JfAssert;
  9. use JF\JuridicusBundle\Utils\Juridicus;
  10. use Doctrine\Common\Collections\ArrayCollection;
  11. use JF\JuridicusBundle\Repository\ProtokollInfothekPrueferRepository;
  13. /**
  14.  * ProtokollInfothekPruefer
  15.  *
  16.  * @UniqueEntity(fields={"protokoll_infothek_pruefung","pruefer"}, message="Ein Prüfer kann nur einmal an der Prüfung teilnehmen.")
  17.  */
  18.  
  19. #[ORM\Entity(repositoryClass: ProtokollInfothekPrueferRepository::class)]
  20. class ProtokollInfothekPruefer extends InitModeEntity
  21. {
  22.     const CLASSNAME = __CLASS__;
  24.     /**
  25.      * @var integer
  26.      */
  27.     private $id;
  29.     /**
  30.      * @var integer
  31.      */
  32.     private $sortierung = 0;
  34.     /**
  35.      * @var string
  36.      * @Assert\Length(max="18")
  37.      */
  38.     private $fach;
  40.     /**
  41.      * @var integer
  42.      * @Assert\Type(type="integer")
  43.      * @Assert\Range(min="1", max="2047", minMessage="Es muss mindestens ein Wert ausgewählt werden.",groups={"finish"})
  44.      */
  45.     private $person_verhalten;
  47.     /**
  48.      * @var array
  49.      */
  50.     private static $person_verhalten_options = array(
  51.         1 => 'freundlich',
  52.         2 => 'humorvoll',
  53.         4 => 'neutral',
  54.         8 => 'distanziert',
  55.         16 => 'wohlwollend',
  56.         32 => 'beruhigend',
  57.         64 => 'nervös',
  58.         128 => 'unsicher',
  59.         256 => 'ungeduldig',
  60.         512 => 'ernst',
  61.         1024 => 'sachlich'
  62.     );
  64.     /**
  65.      * @return array
  66.      */
  67.     public static function getPersonVerhaltenOptions()
  68.     {
  69.         return self::$person_verhalten_options;
  70.     }
  72.     /**
  73.      * @var integer
  74.      * @Assert\NotNull(groups={"finish"}, message="Es muss ein Wert ausgewählt werden.")
  75.      * @Assert\Choice(callback = "getPersonFuehrtKeys", groups={"finish"})
  76.      */
  77.     private $person_fuehrt;
  79.     /**
  80.      * @var array
  81.      */
  82.     private static $person_fuehrt_options = array(
  83.         0 => 'gut',
  84.         1 => 'schlecht'
  85.     );
  87.     /**
  88.      * @return string
  89.      * @throws \OutOfBoundsException
  90.      */
  91.     public function getPersonFuehrtString()
  92.     {
  93.         if (!isset($this->person_fuehrt)) {
  94.             return '';
  95.         } else if (isset(self::$person_fuehrt_options[$this->person_fuehrt])) {
  96.             return self::$person_fuehrt_options[$this->person_fuehrt];
  97.         } else {
  98.             throw new \OutOfBoundsException(sprintf('%s, Ungültiger Index %d', __METHOD__, $this->person_fuehrt));
  99.         }
  100.     }
  102.     /**
  103.      * @return array
  104.      */
  105.     public static function getPersonFuehrtKeys()
  106.     {
  107.         return array_keys(self::$person_fuehrt_options);
  108.     }
  110.     /**
  111.      * @return array
  112.      */
  113.     public static function getPersonFuehrtOptions()
  114.     {
  115.         return self::$person_fuehrt_options;
  116.     }
  118.     /**
  119.      * @var integer
  120.      * @Assert\NotNull(groups={"finish"}, message="Es muss ein Wert ausgewählt werden.")
  121.      * @Assert\Choice(callback="getPersonNotengebungKeys",groups={"finish"})
  122.      */
  123.     private $person_notengebung;
  125.     /**
  126.      * @return string
  127.      * @throws \OutOfBoundsException
  128.      */
  129.     public function getPersonNotengebungString()
  130.     {
  131.         if (!isset($this->person_notengebung)) {
  132.             return '';
  133.         } else if (isset(self::$person_notengebung_options[$this->person_notengebung])) {
  134.             return self::$person_notengebung_options[$this->person_notengebung];
  135.         } else {
  136.             throw new \OutOfBoundsException(sprintf('%s, Ungültiger Index %d', __METHOD__, $this->person_notengebung));
  137.         }
  138.     }
  140.     /**
  141.      * @var array
  142.      */
  143.     private static $person_notengebung_options = array(
  144.         1 => 'wohlwollend',
  145.         2 => 'korrekt',
  146.         3 => 'streng'
  147.     );
  149.     /**
  150.      * @return array
  151.      */
  152.     public static function getPersonNotengebungKeys()
  153.     {
  154.         return array_keys(self::$person_notengebung_options);
  155.     }
  157.     /**
  158.      * @return array
  159.      */
  160.     public static function getPersonNotengebungOptions()
  161.     {
  162.         return self::$person_notengebung_options;
  163.     }
  165.     /**
  166.      * @var integer
  167.      * @Assert\NotNull(groups={"finish"}, message="Es muss ein Wert ausgewählt werden.")
  168.      * @Assert\Range(min="1", max="5", groups={"finish"})
  169.      */
  170.     private $person_eindruck;
  172.     /**
  173.      * @var string
  174.      * @Assert\NotBlank(groups={"finish"})
  175.      * @JfAssert\StripMinLength(min="500", groups={"finish"})
  176.      */
  177.     private $person_lang;
  179.     /**
  180.      * @var integer
  181.      * @Assert\Range(min="0", max="3", groups={"finish"})
  182.      */
  183.     private $sache_stoff;
  185.     /**
  186.      * @var array
  187.      */
  188.     private static $sache_stoff_options = array(
  189.         1 => "protokollfest",
  190.         2 => "aktuelle Fälle"
  191.     );
  193.     /**
  194.      * @return array
  195.      */
  196.     public static function getSacheStoffOptions()
  197.     {
  198.         return self::$sache_stoff_options;
  199.     }
  201.     /**
  202.      * @var string
  203.      * @Assert\NotBlank(groups={"finish"})
  204.      */
  205.     private $sache_themen;
  207.     /**
  208.      * @var integer
  209.      * @Assert\NotNull(groups={"finish"})
  210.      * @Assert\Range(min="1", minMessage="Es muss mindestens ein Wert ausgewählt werden.", groups={"finish"})
  211.      */
  212.     private $sache_gespraech;
  214.     /**
  215.      * @var array
  216.      */
  217.     private static $sache_gespraech_options = array(
  218.         1 => 'Frage-Antwort',
  219.         2 => 'Diskussion',
  220.         4 => 'hält Reihenfolge ein',
  221.         8 => 'lässt Meldungen zu',
  222.         16 => 'Intensivbefragung Einzelner',
  223.         32 => 'verfolgt Zwischenthemen',
  224.         64 => 'hart am Fall',
  225.         128 => 'lässt sich ablenken',
  226.         256 => 'Fragestellung klar'
  227.     );
  229.     /**
  230.      * @return array
  231.      */
  232.     public static function getSacheGespraechOptions()
  233.     {
  234.         return self::$sache_gespraech_options;
  235.     }
  237.     /**
  238.      * @var string
  239.      * @Assert\NotBlank(groups={"finish"})
  240.      * @JfAssert\StripMinLength(min="1500", groups={"finish"})
  241.      */
  242.     private $sache_lang;
  244.     /**
  245.      * @var \JF\JuridicusBundle\Entity\Pruefer
  246.      * @Assert\NotNull(message="Bitte Prüfer angeben",groups={"finish"})
  247.      */
  248.     private $pruefer;
  250.     /**
  251.      * @var \JF\JuridicusBundle\Entity\PdfProtokollInfothekPruefer
  252.      */
  253.     private $pdf_protokoll_infothek_pruefer;
  255.     /**
  256.      * @var \JF\JuridicusBundle\Entity\ProtokollInfothekPruefung
  257.      */
  258.     private $protokoll_infothek_pruefung;
  260.     /**
  261.      * @var \Doctrine\Common\Collections\Collection
  262.      */
  263.     private $similarities;
  265.     /**
  266.      * @var \Doctrine\Common\Collections\Collection
  267.      */
  268.     private $emails;
  270.     /**
  271.      *
  272.      * @var \Doctrine\Common\Collections\Collection
  273.      * @Assert\Count(
  274.      *      max = "5",
  275.      *      maxMessage = "Es dürfen höchstens {{ limit }} Gesetze angegeben werden.",
  276.      *      groups = {"admin"}
  277.      * )
  278.      * @Assert\Valid()
  279.      */
  280.     private $protokoll_gesetze;
  282.     /**
  283.      * @Assert\IsFalse(
  284.      *      message = "Es muss mindestens ein Paragraph angegeben werden.",
  285.      *      groups = {"finish"}
  286.      * )
  287.      * changedFrom Assert\False
  288.      */
  289.     public function isProtokollGesetzeEmpty()
  290.     {
  291.         foreach ($this->getProtokollGesetze() as $pg) {
  292.             if (!$pg->isEmpty()) {
  293.                 return false;
  294.             }
  295.         }
  296.         return true;
  297.     }
  299.     /**
  300.      * Get id
  301.      *
  302.      * @return integer
  303.      */
  304.     public function getId()
  305.     {
  306.         return $this->id;
  307.     }
  309.     /**
  310.      * Set sortierung
  311.      *
  312.      * @param integer $sortierung
  313.      * @return ProtokollInfothekPruefer
  314.      */
  315.     public function setSortierung($sortierung)
  316.     {
  317.         $this->sortierung = $sortierung;
  319.         return $this;
  320.     }
  322.     /**
  323.      * Get sortierung
  324.      *
  325.      * @return integer
  326.      */
  327.     public function getSortierung()
  328.     {
  329.         return $this->sortierung;
  330.     }
  332.     /**
  333.      * Set fach
  334.      *
  335.      * @param string $fach
  336.      * @return ProtokollInfothekPruefer
  337.      */
  338.     public function setFach($fach)
  339.     {
  340.         $this->fach = PrueferPruefung::unifyFach($fach);
  342.         return $this;
  343.     }
  345.     /**
  346.      * Get fach
  347.      *
  348.      * @return string
  349.      */
  350.     public function getFach()
  351.     {
  352.         return $this->fach;
  353.     }
  355.     /**
  356.      * Set person_verhalten
  357.      *
  358.      * @param integer $personVerhalten
  359.      * @return ProtokollInfothekPruefer
  360.      */
  361.     public function setPersonVerhalten($personVerhalten)
  362.     {
  363.         $this->person_verhalten = $personVerhalten;
  365.         return $this;
  366.     }
  368.     /**
  369.      * Get person_verhalten
  370.      *
  371.      * @return integer
  372.      */
  373.     public function getPersonVerhalten()
  374.     {
  375.         return $this->person_verhalten;
  376.     }
  378.     /**
  379.      * Set person_fuehrt
  380.      *
  381.      * @param integer $personFuehrt
  382.      * @return ProtokollInfothekPruefer
  383.      */
  384.     public function setPersonFuehrt($personFuehrt)
  385.     {
  386.         $this->person_fuehrt = $personFuehrt;
  388.         return $this;
  389.     }
  391.     /**
  392.      * Get person_fuehrt
  393.      *
  394.      * @return integer
  395.      */
  396.     public function getPersonFuehrt()
  397.     {
  398.         return $this->person_fuehrt;
  399.     }
  401.     /**
  402.      * Set person_notengebung
  403.      *
  404.      * @param integer $personNotengebung
  405.      * @return ProtokollInfothekPruefer
  406.      */
  407.     public function setPersonNotengebung($personNotengebung)
  408.     {
  409.         $this->person_notengebung = $personNotengebung;
  411.         return $this;
  412.     }
  414.     /**
  415.      * Get person_notengebung
  416.      *
  417.      * @return integer
  418.      */
  419.     public function getPersonNotengebung()
  420.     {
  421.         return $this->person_notengebung;
  422.     }
  424.     /**
  425.      * Set person_eindruck
  426.      *
  427.      * @param integer $personEindruck
  428.      * @return ProtokollInfothekPruefer
  429.      */
  430.     public function setPersonEindruck($personEindruck)
  431.     {
  432.         $this->person_eindruck = $personEindruck;
  434.         return $this;
  435.     }
  437.     /**
  438.      * Get person_eindruck
  439.      *
  440.      * @return integer
  441.      */
  442.     public function getPersonEindruck()
  443.     {
  444.         return $this->person_eindruck;
  445.     }
  447.     /**
  448.      * Set person_lang
  449.      *
  450.      * @param string $personLang
  451.      * @return ProtokollInfothekPruefer
  452.      */
  453.     public function setPersonLang($personLang)
  454.     {
  455.         $this->person_lang = $personLang;
  457.         return $this;
  458.     }
  460.     /**
  461.      * Get person_lang
  462.      *
  463.      * @return string
  464.      */
  465.     public function getPersonLang()
  466.     {
  467.         return $this->person_lang;
  468.     }
  470.     /**
  471.      * Set sache_stoff
  472.      *
  473.      * @param integer $sacheStoff
  474.      * @return ProtokollInfothekPruefer
  475.      */
  476.     public function setSacheStoff($sacheStoff)
  477.     {
  478.         $this->sache_stoff = $sacheStoff;
  480.         return $this;
  481.     }
  483.     /**
  484.      * Get sache_stoff
  485.      *
  486.      * @return integer
  487.      */
  488.     public function getSacheStoff()
  489.     {
  490.         return $this->sache_stoff;
  491.     }
  493.     /**
  494.      * Set sache_themen
  495.      *
  496.      * @param string $sacheThemen
  497.      * @return ProtokollInfothekPruefer
  498.      */
  499.     public function setSacheThemen($sacheThemen)
  500.     {
  501.         $this->sache_themen = $sacheThemen;
  503.         return $this;
  504.     }
  506.     /**
  507.      * Get sache_themen
  508.      *
  509.      * @return string
  510.      */
  511.     public function getSacheThemen()
  512.     {
  513.         return $this->sache_themen;
  514.     }
  516.     /**
  517.      * Set sache_gespraech
  518.      *
  519.      * @param integer $sacheGespraech
  520.      * @return ProtokollInfothekPruefer
  521.      */
  522.     public function setSacheGespraech($sacheGespraech)
  523.     {
  524.         $this->sache_gespraech = $sacheGespraech;
  526.         return $this;
  527.     }
  529.     /**
  530.      * Get sache_gespraech
  531.      *
  532.      * @return integer
  533.      */
  534.     public function getSacheGespraech()
  535.     {
  536.         return $this->sache_gespraech;
  537.     }
  539.     /**
  540.      * Set sache_lang
  541.      *
  542.      * @param string $sacheLang
  543.      * @return ProtokollInfothekPruefer
  544.      */
  545.     public function setSacheLang($sacheLang)
  546.     {
  547.         $this->sache_lang = $sacheLang;
  549.         return $this;
  550.     }
  552.     /**
  553.      * Get sache_lang
  554.      *
  555.      * @return string
  556.      */
  557.     public function getSacheLang()
  558.     {
  559.         return $this->sache_lang;
  560.     }
  562.     /**
  563.      * Set pruefer [OWNING SIDE]
  564.      *
  565.      * @param \JF\JuridicusBundle\Entity\Pruefer $pruefer
  566.      * @return ProtokollInfothekPruefer
  567.      */
  568.     public function setPruefer(Pruefer $pruefer = null)
  569.     {
  570.         $this->pruefer = $pruefer;
  572.         return $this;
  573.     }
  575.     /**
  576.      * Get pruefer
  577.      *
  578.      * @return \JF\JuridicusBundle\Entity\Pruefer
  579.      */
  580.     public function getPruefer()
  581.     {
  582.         return $this->pruefer;
  583.     }
  585.     /**
  586.      * Set protokoll_infothek_pruefung [OWNING SIDE]
  587.      *
  588.      * @param \JF\JuridicusBundle\Entity\ProtokollInfothekPruefung $protokollInfothekPruefung
  589.      * @return ProtokollInfothekPruefer
  590.      */
  591.     public function setProtokollInfothekPruefung(ProtokollInfothekPruefung $protokollInfothekPruefung = null)
  592.     {
  593.         $this->protokoll_infothek_pruefung = $protokollInfothekPruefung;
  595.         return $this;
  596.     }
  598.     /**
  599.      * Get protokoll_infothek_pruefung
  600.      *
  601.      * @return \JF\JuridicusBundle\Entity\ProtokollInfothekPruefung
  602.      */
  603.     public function getProtokollInfothekPruefung()
  604.     {
  605.         return $this->protokoll_infothek_pruefung;
  606.     }
  608.     /**
  609.      * Set pdf_protokoll_infothek_pruefer [INVERSE SIDE]
  610.      *
  611.      * @param \JF\JuridicusBundle\Entity\PdfProtokollInfothekPruefer $pdfProtokollInfothekPruefer
  612.      * @return ProtokollInfothekPruefer
  613.      */
  614.     public function setPdfProtokollInfothekPruefer(PdfProtokollInfothekPruefer $pdfProtokollInfothekPruefer = null)
  615.     {
  616.         $this->pdf_protokoll_infothek_pruefer = $pdfProtokollInfothekPruefer;
  618.         return $this;
  619.     }
  621.     /**
  622.      * Get pdf_protokoll_infothek_pruefer
  623.      *
  624.      * @return \JF\JuridicusBundle\Entity\PdfProtokollInfothekPruefer
  625.      */
  626.     public function getPdfProtokollInfothekPruefer()
  627.     {
  628.         return $this->pdf_protokoll_infothek_pruefer;
  629.     }
  631.     /**
  632.      * String Representation
  633.      *
  634.      * @return string
  635.      */
  636.     public function __toString()
  637.     {
  638.         return sprintf('Protokoll Infothek Prüfer #%s', $this->id);
  639.     }
  641.     /**
  642.      * addToPdf
  643.      *
  644.      * @param \TCPDF $pdf
  645.      */
  646.     public function addToPdf(\TCPDF & $pdf)
  647.     {
  648.         $width = 50;
  649.         $nwidth = 10;
  651.         $protokoll_infothek_pruefung = $this->getProtokollInfothekPruefung();
  653.         // Basisdaten einfügen
  654.         $protokoll_infothek_pruefung->addBaseToPdf($pdf, $this->sortierung);
  656.         $pdf->Cell($width, 0, "Prüfungsfach (-fächer)");
  657.         $pdf->Cell(0, 0, $this->fach, 0, 1);
  659.         $pdf->Ln(5);
  660.         $pdf->writeHTML("<h3>Die Prüfung im Einzelnen</h3>");
  661.         $pdf->Ln(5);
  663.         // Notentabelle einfügen
  664.         $protokoll_infothek_pruefung->addNotenToPdf($pdf);
  666.         $pdf->Ln(5);
  667.         $pdf->writeHTML("<h3>Zur Person:</h3>");
  668.         $pdf->Ln(5);
  670.         $pdf->Cell($nwidth, 0, '1.');
  671.         $pdf->Cell($width, 0, 'Prüfungsverhalten');
  672.         foreach (Juridicus::pick($this->person_verhalten, self::$person_verhalten_options) AS $option) {
  673.             $pdf->Cell(0, 0, $option, 0, 2);
  674.         }
  675.         $pdf->Ln(0);
  677.         if (isset($this->person_fuehrt)) {
  678.             $pdf->Cell($nwidth, 0, '');
  679.             $pdf->Cell($width, 0, 'führt');
  680.             $pdf->Cell(0, 0, $this->getPersonFuehrtString(), 0, 1);
  681.         }
  683.         if (isset($this->person_notengebung)) {
  684.             $pdf->Cell($nwidth, 0, '2.');
  685.             $pdf->Cell($width, 0, 'Notengebung');
  686.             $pdf->Cell(0, 0, $this->getPersonNotengebungString(), 0, 1);
  687.         }
  689.         if (isset($this->person_eindruck)) {
  690.             $pdf->Cell($nwidth, 0, '3.');
  691.             $pdf->Cell($width, 0, 'Gesamteindruck');
  692.             $pdf->Cell(0, 0, sprintf('%s (1 = ideal ... 5 = äußerst unangenehm)', $this->person_eindruck), 0, 1);
  693.         }
  695.         $pdf->Ln(5);
  696.         $pdf->writeHTML("<h3>Zur Sache:</h3>");
  697.         $pdf->Ln(5);
  699.         $pdf->Cell($nwidth, 0, '1.');
  701.         if (!empty($this->sache_stoff)) {
  702.             $selected = Juridicus::pick($this->sache_stoff, self::$sache_stoff_options);
  703.             $pdf->Cell($width, 0, 'Prüfungsstoff');
  704.             $pdf->Cell(0, 0, implode(", ", $selected), 0, 1);
  705.             $pdf->Cell($nwidth, 0, '');
  706.         }
  708.         $pdf->Cell($width, 0, 'Prüfungsthemen');
  709.         $pdf->writeHTMLCell(0, 0, '', '', $this->sache_themen, 0, 1);
  711.         $paragraphen = array();
  712.         foreach($this->getProtokollGesetze() as $protokoll_gesetz) {
  713.             /* @var $protokoll_gesetz \JF\JuridicusBundle\Entity\ProtokollGesetz */
  714.             $paragraphen[] = sprintf('<a href="%s">%s</a>',
  715.                 $protokoll_gesetz->getAbsoluteLink(),
  716.                 $protokoll_gesetz->getKurzbezeichnung()
  717.             );
  718.         }
  719.         if (!empty($paragraphen)) {
  720.                $pdf->Cell($nwidth, 0, '');
  721.             $pdf->Cell($width, 0, 'Paragraphen');
  722.                $pdf->writeHTMLCell(0, 0, '', '', \implode(', ', $paragraphen), 0, 1);
  723.         }
  725.         $pdf->Cell($nwidth, 0, '2.');
  726.         $pdf->Cell($width, 0, 'Prüfungsgespräch');
  728.         foreach (Juridicus::pick($this->sache_gespraech, self::$sache_gespraech_options) AS $option)     {
  729.             $pdf->Cell(0, 0, $option, 0, 2);
  730.         }
  732.         $pdf->Ln(5);
  733.         $pdf->writeHTML("<h3>Zur Person des Prüfers (ausführlich)</h3>");
  734.         $pdf->Ln(5);
  735.         $pdf->writeHTML($this->person_lang);
  736.         $pdf->Ln(5);
  737.         $pdf->writeHTML("<h3>Zur Sache (ausführlich)</h3>");
  738.         $pdf->Ln(5);
  739.         $pdf->writeHTML($this->sache_lang);
  740.         $pdf->Ln(5);
  741.         $pdf->lastPage();
  742.     }
  744.     /**
  745.      * Konstructor.
  746.      */
  747.     public function __construct()
  748.     {
  749.         $this->similarities = new ArrayCollection();
  750.         $this->emails = new ArrayCollection();
  751.         $this->protokoll_gesetze = new ArrayCollection();
  752.     }
  755.     /**
  756.      * Add similarities
  757.      *
  758.      * @param \JF\JuridicusBundle\Entity\Similarity $similarities
  759.      * @return ProtokollInfothekPruefer
  760.      */
  761.     public function addSimilaritie(Similarity $similarities)
  762.     {
  763.         $this->similarities[] = $similarities;
  765.         return $this;
  766.     }
  768.     /**
  769.      * Remove similarities
  770.      *
  771.      * @param \JF\JuridicusBundle\Entity\Similarity $similarities
  772.      */
  773.     public function removeSimilaritie(Similarity $similarities)
  774.     {
  775.         $this->similarities->removeElement($similarities);
  776.     }
  778.     /**
  779.      * Get similarities
  780.      *
  781.      * @return \Doctrine\Common\Collections\Collection
  782.      */
  783.     public function getSimilarities()
  784.     {
  785.         return $this->similarities;
  786.     }
  788.     /**
  789.      * Add emails
  790.      *
  791.      * @param \JF\JuridicusBundle\Entity\Email $emails
  792.      * @return ProtokollInfothekPruefer
  793.      */
  794.     public function addEmail(Email $emails)
  795.     {
  796.         $this->emails[] = $emails;
  798.         return $this;
  799.     }
  801.     /**
  802.      * Remove emails
  803.      *
  804.      * @param \JF\JuridicusBundle\Entity\Email $emails
  805.      */
  806.     public function removeEmail(Email $emails)
  807.     {
  808.         $this->emails->removeElement($emails);
  809.     }
  811.     /**
  812.      * Get emails
  813.      *
  814.      * @return \Doctrine\Common\Collections\Collection
  815.      */
  816.     public function getEmails()
  817.     {
  818.         return $this->emails;
  819.     }
  821.     /**
  822.      * Add protokoll_gesetze
  823.      *
  824.      * @param \JF\JuridicusBundle\Entity\ProtokollGesetz $protokollGesetz
  825.      * @return ProtokollInfothekPruefer
  826.      */
  827.     public function addProtokollGesetze(ProtokollGesetz $protokollGesetz)
  828.     {
  829.         $this->protokoll_gesetze[] = $protokollGesetz;
  830.         $protokollGesetz->setProtokollInfothekPruefer($this);
  832.         return $this;
  833.     }
  835.     /**
  836.      * Remove protokoll_gesetze
  837.      *
  838.      * @param \JF\JuridicusBundle\Entity\ProtokollGesetz $protokollGesetz
  839.      */
  840.     public function removeProtokollGesetze(ProtokollGesetz $protokollGesetz)
  841.     {
  842.         $this->protokoll_gesetze->removeElement($protokollGesetz);
  843.     }
  845.     /**
  846.      * Get protokoll_gesetze
  847.      *
  848.      * @return \Doctrine\Common\Collections\Collection
  849.      */
  850.     public function getProtokollGesetze()
  851.     {
  852.         return $this->protokoll_gesetze;
  853.     }
  855.     /**
  856.      *
  857.      * @param integer $limit
  858.      */
  859.     public function expandProtokollGesetze($limit = 5)
  860.     {
  861.         $pg_count = $this->getProtokollGesetze()->count();
  862.         for ($i = $pg_count + 1; $i <= $limit; $i++) {
  863.             $pg = new ProtokollGesetz();
  864.             //  $pg->setSortierung($i);
  865.             $this->addProtokollGesetze($pg);
  866.         }
  867.     }
  869.     /**
  870.      *
  871.      */
  872.     public function removeEmptyProtokollGesetze()
  873.     {
  874.         foreach($this->getProtokollGesetze() as $pg) {
  875.             if ($pg->isEmpty()) {
  876.                 $this->removeProtokollGesetze($pg);
  877.             }
  878.         }
  879.     }
  880. }