src/Entity/Gos/Uniqskills/Test.php line 17

Open in your IDE?
  1. <?php
  3. namespace App\Entity\Gos\Uniqskills;
  5. use App\Entity\Gos\CertificatePath;
  6. use App\Entity\Gos\User;
  7. use Doctrine\Common\Collections\ArrayCollection;
  8. use Doctrine\Common\Collections\Collection;
  9. use Doctrine\ORM\Mapping as ORM;
  10. use Gedmo\Mapping\Annotation as Gedmo;
  12. /**
  13.  * @ORM\Table()
  14.  * @ORM\Entity(repositoryClass="App\Repository\Gos\Uniqskills\TestRepository")
  15.  * @ORM\HasLifecycleCallbacks
  16.  */
  17. class Test
  18. {
  19.     /**
  20.      * @var integer
  21.      *
  22.      * @ORM\Column(type="integer")
  23.      * @ORM\Id
  24.      * @ORM\GeneratedValue(strategy="AUTO")
  25.      */
  26.     private $id;
  28.     /**
  29.      * @var bool
  30.      * @ORM\Column(type="boolean")
  31.      */
  32.     private $isActive;
  34.     /**
  35.      * @var bool
  36.      * @ORM\Column(type="boolean")
  37.      */
  38.     private $isOneQuestionPerPage;
  40.     /**
  41.      * @ORM\Column(type="string")
  42.      */
  43.     private $name;
  45.     /**
  46.      * @Gedmo\Slug(fields={"name"})
  47.      * @ORM\Column(type="string", length=191, unique=true)
  48.      */
  49.     private $slug;
  51.     /**
  52.      * @ORM\Column(type="string")
  53.      */
  54.     private $type;
  56.     /**
  57.      * @ORM\Column(type="string", nullable=true)
  58.      */
  59.     private $share;
  61.     /**
  62.      * @ORM\Column(type="datetime", nullable=true)
  63.      */
  64.     private $dateStart;
  66.     /**
  67.      * @ORM\Column(type="integer", nullable=true)
  68.      */
  69.     private $shareDays;
  71.     /**
  72.      * @ORM\Column(type="float")
  73.      */
  74.     private $pointsGoodAnswer;
  76.     /**
  77.      * @ORM\Column(type="float")
  78.      */
  79.     private $pointsWrongAnswer;
  81.     /**
  82.      * @ORM\Column(type="float")
  83.      */
  84.     private $minimumScore;
  86.     /**
  87.      * @ORM\Column(type="float", nullable=true)
  88.      */
  89.     private $educationPointsPerScorePoint;
  91.     /**
  92.      * @ORM\Column(type="integer")
  93.      */
  94.     private $numberRepetitions;
  96.     /**
  97.      * @ORM\Column(type="boolean", nullable=true)
  98.      */
  99.     private $infiniteRepeatTest;
  101.     /**
  102.      * @ORM\Column(type="integer", nullable=true)
  103.      */
  104.     private $timeToRepeatTest;
  106.     /**
  107.      * @var \DateTime
  108.      *
  109.      * @ORM\Column(type="datetime", nullable=true)
  110.      */
  111.     private $createdAt;
  113.     /**
  114.      * @var \DateTime
  115.      *
  116.      * @ORM\Column(type="datetime", nullable=true)
  117.      */
  118.     private $updatedAt;
  120.     /**
  121.      * @var \DateTime
  122.      *
  123.      * @ORM\Column(type="datetime", nullable=true)
  124.      */
  125.     private $deletedAt;
  127.     /**
  128.      * @ORM\OneToOne(targetEntity="Module", inversedBy="test")
  129.      * @ORM\JoinColumn(name="module_id", referencedColumnName="id", onDelete="cascade")
  130.      */
  131.     private $module;
  133.     /**
  134.      * @ORM\ManyToOne(targetEntity="Course", inversedBy="test")
  135.      * @ORM\JoinColumn(name="course_id", referencedColumnName="id", onDelete="cascade")
  136.      */
  137.     private $course;
  139.     /**
  140.      * @ORM\OneToMany(targetEntity="Question", mappedBy="test")
  141.      */
  142.     private $question;
  144.     /**
  145.      * @ORM\OneToMany(targetEntity="UserTest", mappedBy="test")
  146.      */
  147.     private $userTest;
  149.     /**
  150.      * @ORM\OneToMany(targetEntity="UserAnswer", mappedBy="test")
  151.      */
  152.     private $userAnswer;
  154. //    /**
  155. //     * @ORM\OneToOne(targetEntity="Certificate", mappedBy="test")
  156. //     */
  157. //    private $certificate;
  159.     /**
  160.      * @ORM\ManyToOne(targetEntity="App\Entity\Gos\User", inversedBy="test")
  161.      * @ORM\JoinColumn()
  162.      */
  163.     private $user;
  165.     /**
  166.      * @ORM\OneToMany(targetEntity=CertificatePath::class, mappedBy="test")
  167.      */
  168.     private $certificatePaths;
  170.     public function __construct()
  171.     {
  172.         $this->question = new ArrayCollection();
  173.         $this->userTest = new ArrayCollection();
  174.         $this->userAnswer = new ArrayCollection();
  175.         $this->certificatePaths = new ArrayCollection();
  176.     }
  178.     /** @ORM\PrePersist() */
  179.     public function prePersist()
  180.     {
  181.         $this->createdAt = new \DateTime();
  182.     }
  184.     /** @ORM\PreUpdate() */
  185.     public function preUpdate()
  186.     {
  187.         $this->updatedAt = new \DateTime();
  188.     }
  190.     public function __toString()
  191.     {
  192.         return (string) $this->name;
  193.     }
  195.     public function isCompletedTestByUser($user)
  196.     {
  197.         if (!$this->hasQuestions())
  198.         {
  199.             return true;
  200.         }
  201.         foreach ($this->userTest as $userTest)
  202.         {
  203.             if ($userTest->getUser() && $userTest->getUser()->getId() == $user->getId())
  204.             {
  205.                 return true;
  206.             }
  207.         }
  208.         return false;
  209.     }
  211.     public function canUserRepeatTest($user)
  212.     {
  213.         if ($this->infiniteRepeatTest && $this->hasQuestions())
  214.         {
  215.             return true;
  216.         }
  218.         if ($this->numberRepetitions > 0 && $this->hasQuestions())
  219.         {
  220.             foreach ($this->userTest as $userTest)
  221.             {
  222.                 if ($userTest->getUser() && $userTest->getUser()->getId() == $user->getId())
  223.                 {
  224.                     $date           = (new \DateTime())->format('U');
  225.                     $userTestTime   = $userTest->getCreatedAt()->format('U');
  227.                     if (
  228.                         (
  229.                             ($date - $userTestTime) / 3600 > $this->timeToRepeatTest
  230.                         )
  231.                         && $userTest->getSumCompleted() <= $this->numberRepetitions
  232.                     )
  233.                     {
  234.                         return true;
  235.                     }
  236.                 }
  237.             }
  238.         }
  240.         return false;
  241.     }
  243.     public function getClientTestByUser($user)
  244.     {
  245.         foreach ($this->userTest as $userTest)
  246.         {
  247.             if ($userTest->getUser() && $userTest->getUser()->getId() == $user->getId())
  248.             {
  249.                 return $userTest;
  250.             }
  251.         }
  253.         return null;
  254.     }
  256.     public function hasOpenQuestions()
  257.     {
  258.         foreach ($this->question as $question)
  259.         {
  260.             if (count($question->getAnswer()) === 0)
  261.             {
  262.                 return true;
  263.             }
  264.         }
  266.         return false;
  267.     }
  269.     public function __clone()
  270.     {
  271.         $this->id           = null;
  272.         $this->updatedAt    = null;
  273.     }
  275.     public function getId(): ?int
  276.     {
  277.         return $this->id;
  278.     }
  280.     public function getIsActive(): ?bool
  281.     {
  282.         return $this->isActive;
  283.     }
  285.     public function setIsActive(bool $isActive): self
  286.     {
  287.         $this->isActive = $isActive;
  289.         return $this;
  290.     }
  292.     public function getIsOneQuestionPerPage(): ?bool
  293.     {
  294.         return $this->isOneQuestionPerPage;
  295.     }
  297.     public function setIsOneQuestionPerPage(bool $isOneQuestionPerPage): self
  298.     {
  299.         $this->isOneQuestionPerPage = $isOneQuestionPerPage;
  301.         return $this;
  302.     }
  304.     public function getName(): ?string
  305.     {
  306.         return $this->name;
  307.     }
  309.     public function setName(string $name): self
  310.     {
  311.         $this->name = $name;
  313.         return $this;
  314.     }
  316.     public function getSlug(): ?string
  317.     {
  318.         return $this->slug;
  319.     }
  321.     public function setSlug(string $slug): self
  322.     {
  323.         $this->slug = $slug;
  325.         return $this;
  326.     }
  328.     public function getType(): ?string
  329.     {
  330.         return $this->type;
  331.     }
  333.     public function setType(string $type): self
  334.     {
  335.         $this->type = $type;
  337.         return $this;
  338.     }
  340.     public function getShare(): ?string
  341.     {
  342.         return $this->share;
  343.     }
  345.     public function setShare(string $share): self
  346.     {
  347.         $this->share = $share;
  349.         return $this;
  350.     }
  352.     public function getDateStart(): ?\DateTimeInterface
  353.     {
  354.         return $this->dateStart;
  355.     }
  357.     public function setDateStart(?\DateTimeInterface $dateStart): self
  358.     {
  359.         $this->dateStart = $dateStart;
  361.         return $this;
  362.     }
  364.     public function getShareDays(): ?int
  365.     {
  366.         return $this->shareDays;
  367.     }
  369.     public function setShareDays(?int $shareDays): self
  370.     {
  371.         $this->shareDays = $shareDays;
  373.         return $this;
  374.     }
  376.     public function getPointsGoodAnswer(): ?float
  377.     {
  378.         return $this->pointsGoodAnswer;
  379.     }
  381.     public function setPointsGoodAnswer(float $pointsGoodAnswer): self
  382.     {
  383.         $this->pointsGoodAnswer = $pointsGoodAnswer;
  385.         return $this;
  386.     }
  388.     public function getPointsWrongAnswer(): ?float
  389.     {
  390.         return $this->pointsWrongAnswer;
  391.     }
  393.     public function setPointsWrongAnswer(float $pointsWrongAnswer): self
  394.     {
  395.         $this->pointsWrongAnswer = $pointsWrongAnswer;
  397.         return $this;
  398.     }
  400.     public function getMinimumScore(): ?float
  401.     {
  402.         return $this->minimumScore;
  403.     }
  405.     public function setMinimumScore(float $minimumScore): self
  406.     {
  407.         $this->minimumScore = $minimumScore;
  409.         return $this;
  410.     }
  412.     public function getEducationPointsPerScorePoint(): ?float
  413.     {
  414.         return $this->educationPointsPerScorePoint;
  415.     }
  417.     public function setEducationPointsPerScorePoint(?float $educationPointsPerScorePoint): self
  418.     {
  419.         $this->educationPointsPerScorePoint = $educationPointsPerScorePoint;
  421.         return $this;
  422.     }
  424.     public function getNumberRepetitions(): ?int
  425.     {
  426.         return $this->numberRepetitions;
  427.     }
  429.     public function setNumberRepetitions(int $numberRepetitions): self
  430.     {
  431.         $this->numberRepetitions = $numberRepetitions;
  433.         return $this;
  434.     }
  436.     public function getInfiniteRepeatTest(): ?bool
  437.     {
  438.         return $this->infiniteRepeatTest;
  439.     }
  441.     public function setInfiniteRepeatTest(?bool $infiniteRepeatTest): self
  442.     {
  443.         $this->infiniteRepeatTest = $infiniteRepeatTest;
  445.         return $this;
  446.     }
  448.     public function getTimeToRepeatTest(): ?int
  449.     {
  450.         return $this->timeToRepeatTest;
  451.     }
  453.     public function setTimeToRepeatTest(?int $timeToRepeatTest): self
  454.     {
  455.         $this->timeToRepeatTest = $timeToRepeatTest;
  457.         return $this;
  458.     }
  460.     public function getCreatedAt(): ?\DateTimeInterface
  461.     {
  462.         return $this->createdAt;
  463.     }
  465.     public function setCreatedAt(?\DateTimeInterface $createdAt): self
  466.     {
  467.         $this->createdAt = $createdAt;
  469.         return $this;
  470.     }
  472.     public function getUpdatedAt(): ?\DateTimeInterface
  473.     {
  474.         return $this->updatedAt;
  475.     }
  477.     public function setUpdatedAt(?\DateTimeInterface $updatedAt): self
  478.     {
  479.         $this->updatedAt = $updatedAt;
  481.         return $this;
  482.     }
  484.     public function getDeletedAt(): ?\DateTimeInterface
  485.     {
  486.         return $this->deletedAt;
  487.     }
  489.     public function setDeletedAt(?\DateTimeInterface $deletedAt): self
  490.     {
  491.         $this->deletedAt = $deletedAt;
  493.         return $this;
  494.     }
  496.     public function getModule(): ?Module
  497.     {
  498.         return $this->module;
  499.     }
  501.     public function setModule(?Module $module): self
  502.     {
  503.         $this->module = $module;
  505.         return $this;
  506.     }
  508.     public function getCourse(): ?Course
  509.     {
  510.         return $this->course;
  511.     }
  513.     public function getCourseName(): string
  514.     {
  515.         if ($this->getCourse())
  516.         {
  517.             return $this->getCourse()->getName();
  518.         }
  519.         elseif ($this->getModule())
  520.         {
  521.             return $this->getModule()->getCourse()->getName();
  522.         }
  524.         return '';
  525.     }
  527.     public function setCourse(?Course $course): self
  528.     {
  529.         $this->course = $course;
  531.         return $this;
  532.     }
  534.     /**
  535.      * @return Collection|Question[]
  536.      */
  537.     public function getQuestion(): Collection
  538.     {
  539.         return $this->question;
  540.     }
  542.     public function hasQuestions(): bool
  543.     {
  544.         return !$this->getQuestion()->isEmpty();
  545.     }
  547.     public function addQuestion(Question $question): self
  548.     {
  549.         if (!$this->question->contains($question)) {
  550.             $this->question[] = $question;
  551.             $question->setTest($this);
  552.         }
  554.         return $this;
  555.     }
  557.     public function removeQuestion(Question $question): self
  558.     {
  559.         if ($this->question->contains($question)) {
  560.             $this->question->removeElement($question);
  561.             // set the owning side to null (unless already changed)
  562.             if ($question->getTest() === $this) {
  563.                 $question->setTest(null);
  564.             }
  565.         }
  567.         return $this;
  568.     }
  570.     /**
  571.      * @return Collection|UserTest[]
  572.      */
  573.     public function getUserTest(): Collection
  574.     {
  575.         return $this->userTest;
  576.     }
  578.     public function addUserTest(UserTest $userTest): self
  579.     {
  580.         if (!$this->userTest->contains($userTest)) {
  581.             $this->userTest[] = $userTest;
  582.             $userTest->setTest($this);
  583.         }
  585.         return $this;
  586.     }
  588.     public function removeUserTest(UserTest $userTest): self
  589.     {
  590.         if ($this->userTest->contains($userTest)) {
  591.             $this->userTest->removeElement($userTest);
  592.             // set the owning side to null (unless already changed)
  593.             if ($userTest->getTest() === $this) {
  594.                 $userTest->setTest(null);
  595.             }
  596.         }
  598.         return $this;
  599.     }
  601.     /**
  602.      * @return Collection|UserAnswer[]
  603.      */
  604.     public function getUserAnswer(): Collection
  605.     {
  606.         return $this->userAnswer;
  607.     }
  609.     public function addUserAnswer(UserAnswer $userAnswer): self
  610.     {
  611.         if (!$this->userAnswer->contains($userAnswer)) {
  612.             $this->userAnswer[] = $userAnswer;
  613.             $userAnswer->setTest($this);
  614.         }
  616.         return $this;
  617.     }
  619.     public function removeUserAnswer(UserAnswer $userAnswer): self
  620.     {
  621.         if ($this->userAnswer->contains($userAnswer)) {
  622.             $this->userAnswer->removeElement($userAnswer);
  623.             // set the owning side to null (unless already changed)
  624.             if ($userAnswer->getTest() === $this) {
  625.                 $userAnswer->setTest(null);
  626.             }
  627.         }
  629.         return $this;
  630.     }
  632.     public function getUser(): ?User
  633.     {
  634.         return $this->user;
  635.     }
  637.     public function setUser(?User $user): self
  638.     {
  639.         $this->user = $user;
  641.         return $this;
  642.     }
  644.     /**
  645.      * @return Collection|CertificatePath[]
  646.      */
  647.     public function getCertificatePaths(): Collection
  648.     {
  649.         return $this->certificatePaths;
  650.     }
  652.     public function addCertificatePath(CertificatePath $certificatePath): self
  653.     {
  654.         if (!$this->certificatePaths->contains($certificatePath)) {
  655.             $this->certificatePaths[] = $certificatePath;
  656.             $certificatePath->setTest($this);
  657.         }
  659.         return $this;
  660.     }
  662.     public function removeCertificatePath(CertificatePath $certificatePath): self
  663.     {
  664.         if ($this->certificatePaths->contains($certificatePath)) {
  665.             $this->certificatePaths->removeElement($certificatePath);
  666.             // set the owning side to null (unless already changed)
  667.             if ($certificatePath->getTest() === $this) {
  668.                 $certificatePath->setTest(null);
  669.             }
  670.         }
  672.         return $this;
  673.     }
  674. }