src/Entity/Domain.php line 17

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use AllowDynamicProperties;
  6. use App\Attribute\Searchable;
  7. use App\Repository\DomainRepository;
  8. use App\Traits\DateTimeTrait;
  9. use Doctrine\Common\Collections\ArrayCollection;
  10. use Doctrine\Common\Collections\Collection;
  11. use Doctrine\ORM\Mapping as ORM;
  12. use Overblog\GraphQLBundle\Annotation\Field;
  14. #[AllowDynamicProperties]
  15. #[ORM\Entity(repositoryClass: DomainRepository::class)]
  16. #[ORM\HasLifecycleCallbacks]
  17. class Domain extends BasicEntity
  18. {
  19.     use DateTimeTrait;
  21.     #[ORM\Id]
  22.     #[ORM\GeneratedValue]
  23.     #[ORM\Column(type: "integer")]
  24.     #[Field(name: "id", type: "int")]
  25.     private $id;
  27.     #[ORM\Column(type: "string", length: 255)]
  28.     #[Field(name: "url", type: "string")]
  29.     #[Searchable(name: 'url')]
  30.     private $url;
  32.     #[ORM\ManyToOne(targetEntity: Organisation::class, inversedBy: "domains")]
  33.     #[ORM\JoinColumn(nullable: false)]
  34.     private $organisation;
  36.     #[ORM\Column(type: "boolean")]
  37.     #[Field(name: "is_enabled", type: "boolean")]
  38.     private $isEnabled;
  40.     #[ORM\OneToMany(mappedBy: "domain", targetEntity: ExposedSubDomain::class, cascade: ["remove"])]
  41.     private $exposedSubDomains;
  43.     #[ORM\OneToMany(mappedBy: "domain", targetEntity: Vulnerability::class, cascade: ["remove"])]
  44.     private $vulnerabilities;
  46.     #[ORM\OneToMany(mappedBy: "domain", targetEntity: DarkOwl::class, cascade: ["remove"])]
  47.     private $darkOwls;
  49.     #[ORM\OneToMany(mappedBy: "domain", targetEntity: DomainScore::class, cascade: ["remove"])]
  50.     private $domainScores;
  52.     #[ORM\OneToMany(mappedBy: 'domain', targetEntity: Recommendation::class)]
  53.     private Collection $recommendations;
  55.     #[ORM\OneToMany(mappedBy: 'domain', targetEntity: LeakedPassword::class)]
  56.     private Collection $leakedPasswords;
  58.     #[ORM\OneToMany(mappedBy: 'domain', targetEntity: Score::class)]
  59.     private Collection $scores;
  61.     #[ORM\OneToMany(mappedBy: 'domain', targetEntity: ExposedIp::class)]
  62.     private Collection $exposedIps;
  64.     #[ORM\ManyToMany(targetEntity: GenericRecommendation::class, inversedBy: 'domains')]
  65.     private Collection $implementedGenericRecommendations;
  67.     #[ORM\OneToMany(mappedBy: 'domaine', targetEntity: Notification::class)]
  68.     private Collection $notifications;
  70.     #[ORM\OneToMany(mappedBy: 'domain', targetEntity: Ransomware::class)]
  71.     private Collection $ransomwares;
  73.     public function __construct()
  74.     {
  75.         $this->exposedSubDomains = new ArrayCollection();
  76.         $this->vulnerabilities = new ArrayCollection();
  77.         $this->darkOwls = new ArrayCollection();
  78.         $this->domainScores = new ArrayCollection();
  79.         $this->recommendations = new ArrayCollection();
  80.         $this->leakedPasswords = new ArrayCollection();
  81.         $this->scores = new ArrayCollection();
  82.         $this->exposedIps = new ArrayCollection();
  83.         $this->implementedGenericRecommendations = new ArrayCollection();
  84.         $this->notifications = new ArrayCollection();
  85.     }
  87.     public function getId(): ?int
  88.     {
  89.         return $this->id;
  90.     }
  92.     public function getUrl(): ?string
  93.     {
  94.         return $this->url;
  95.     }
  97.     public function setUrl(string $url): self
  98.     {
  99.         $this->url = $url;
  101.         return $this;
  102.     }
  104.     public function getOrganisation(): ?Organisation
  105.     {
  106.         return $this->organisation;
  107.     }
  109.     public function setOrganisation(?Organisation $organisation): self
  110.     {
  111.         $this->organisation = $organisation;
  113.         return $this;
  114.     }
  116.     public function getIsEnabled(): ?bool
  117.     {
  118.         return $this->isEnabled;
  119.     }
  121.     public function setIsEnabled(bool $isEnabled): self
  122.     {
  123.         $this->isEnabled = $isEnabled;
  125.         return $this;
  126.     }
  128.     /**
  129.      * @return Collection|ExposedSubDomain[]
  130.      */
  131.     public function getExposedSubDomains(): Collection
  132.     {
  133.         return $this->exposedSubDomains->filter(function($exposedSubdomain) {
  134.             return !$exposedSubdomain->getIsDeleted();
  135.         });
  136.     }
  138.     // Optionally add a method for getting all subdomains, including deleted ones
  139.     public function getAllExposedSubdomains(): Collection
  140.     {
  141.         return $this->exposedSubDomains;
  142.     }
  144.     public function addExposedSubDomain(ExposedSubDomain $exposedSubDomain): self
  145.     {
  146.         if (!$this->exposedSubDomains->contains($exposedSubDomain)) {
  147.             $this->exposedSubDomains[] = $exposedSubDomain;
  148.             $exposedSubDomain->setDomain($this);
  149.         }
  151.         return $this;
  152.     }
  154.     public function removeExposedSubDomain(ExposedSubDomain $exposedSubDomain): self
  155.     {
  156.         if ($this->exposedSubDomains->removeElement($exposedSubDomain)) {
  157.             // set the owning side to null (unless already changed)
  158.             if ($exposedSubDomain->getDomain() === $this) {
  159.                 $exposedSubDomain->setDomain(null);
  160.             }
  161.         }
  163.         return $this;
  164.     }
  166.     /**
  167.      * @return Collection|Vulnerability[]
  168.      */
  169.     public function getVulnerabilities(): Collection
  170.     {
  171.         return $this->vulnerabilities;
  172.     }
  174.     public function addVulnerability(Vulnerability $vulnerability): self
  175.     {
  176.         if (!$this->vulnerabilities->contains($vulnerability)) {
  177.             $this->vulnerabilities[] = $vulnerability;
  178.             $vulnerability->setDomain($this);
  179.         }
  181.         return $this;
  182.     }
  184.     public function removeVulnerability(Vulnerability $vulnerability): self
  185.     {
  186.         if ($this->vulnerabilities->removeElement($vulnerability)) {
  187.             // set the owning side to null (unless already changed)
  188.             if ($vulnerability->getDomain() === $this) {
  189.                 $vulnerability->setDomain(null);
  190.             }
  191.         }
  193.         return $this;
  194.     }
  196.     /**
  197.      * @return Collection<int, DarkOwl>
  198.      */
  199.     public function getDarkOwls(): Collection
  200.     {
  201.         return $this->darkOwls;
  202.     }
  204.     public function addDarkOwl(DarkOwl $darkOwl): self
  205.     {
  206.         if (!$this->darkOwls->contains($darkOwl)) {
  207.             $this->darkOwls[] = $darkOwl;
  208.             $darkOwl->setDomain($this);
  209.         }
  211.         return $this;
  212.     }
  214.     public function removeDarkOwl(DarkOwl $darkOwl): self
  215.     {
  216.         if ($this->darkOwls->removeElement($darkOwl)) {
  217.             // set the owning side to null (unless already changed)
  218.             if ($darkOwl->getDomain() === $this) {
  219.                 $darkOwl->setDomain(null);
  220.             }
  221.         }
  223.         return $this;
  224.     }
  226.     /**
  227.      * @return Collection<int, DomainScore>
  228.      */
  229.     public function getDomainScores(): Collection
  230.     {
  231.         return $this->domainScores;
  232.     }
  234.     public function addDomainScore(DomainScore $domainScore): self
  235.     {
  236.         if (!$this->domainScores->contains($domainScore)) {
  237.             $this->domainScores[] = $domainScore;
  238.             $domainScore->setDomain($this);
  239.         }
  241.         return $this;
  242.     }
  244.     public function removeDomainScore(DomainScore $domainScore): self
  245.     {
  246.         if ($this->domainScores->removeElement($domainScore)) {
  247.             // set the owning side to null (unless already changed)
  248.             if ($domainScore->getDomain() === $this) {
  249.                 $domainScore->setDomain(null);
  250.             }
  251.         }
  253.         return $this;
  254.     }
  256.     public function getLastScore(): ?DomainScore
  257.     {
  258.         $score = null;
  259.         foreach ($this->getDomainScores() as $key => $value) {
  260.             $score = $value;
  261.         }
  263.         return $score;
  264.     }
  266.     /**
  267.      * @return Collection<int, Recommendation>
  268.      */
  269.     public function getRecommendations(): Collection
  270.     {
  271.         return $this->recommendations;
  272.     }
  274.     public function addRecommendation(Recommendation $recommendation): static
  275.     {
  276.         if (!$this->recommendations->contains($recommendation)) {
  277.             $this->recommendations->add($recommendation);
  278.             $recommendation->setDomain($this);
  279.         }
  281.         return $this;
  282.     }
  284.     public function removeRecommendation(Recommendation $recommendation): static
  285.     {
  286.         if ($this->recommendations->removeElement($recommendation)) {
  287.             // set the owning side to null (unless already changed)
  288.             if ($recommendation->getDomain() === $this) {
  289.                 $recommendation->setDomain(null);
  290.             }
  291.         }
  293.         return $this;
  294.     }
  296.     /**
  297.      * @return Collection<int, LeakedPassword>
  298.      */
  299.     public function getLeakedPasswords(): Collection
  300.     {
  301.         return $this->leakedPasswords;
  302.     }
  304.     public function addLeakedPassword(LeakedPassword $leakedPassword): static
  305.     {
  306.         if (!$this->leakedPasswords->contains($leakedPassword)) {
  307.             $this->leakedPasswords->add($leakedPassword);
  308.             $leakedPassword->setDomain($this);
  309.         }
  311.         return $this;
  312.     }
  314.     public function removeLeakedPassword(LeakedPassword $leakedPassword): static
  315.     {
  316.         if ($this->leakedPasswords->removeElement($leakedPassword)) {
  317.             // set the owning side to null (unless already changed)
  318.             if ($leakedPassword->getDomain() === $this) {
  319.                 $leakedPassword->setDomain(null);
  320.             }
  321.         }
  323.         return $this;
  324.     }
  326.     /**
  327.      * @return Collection<int, Score>
  328.      */
  329.     public function getScores(): Collection
  330.     {
  331.         return $this->scores;
  332.     }
  334.     public function addScore(Score $score): static
  335.     {
  336.         if (!$this->scores->contains($score)) {
  337.             $this->scores->add($score);
  338.             $score->setDomain($this);
  339.         }
  341.         return $this;
  342.     }
  344.     public function removeScore(Score $score): static
  345.     {
  346.         if ($this->scores->removeElement($score)) {
  347.             // set the owning side to null (unless already changed)
  348.             if ($score->getDomain() === $this) {
  349.                 $score->setDomain(null);
  350.             }
  351.         }
  353.         return $this;
  354.     }
  356.     /**
  357.      * @return Collection<int, ExposedIp>
  358.      */
  359.     public function getExposedIps(): Collection
  360.     {
  361.         return $this->exposedIps;
  362.     }
  364.     public function addExposedIp(ExposedIp $exposedIp): static
  365.     {
  366.         if (!$this->exposedIps->contains($exposedIp)) {
  367.             $this->exposedIps->add($exposedIp);
  368.             $exposedIp->setDomain($this);
  369.         }
  371.         return $this;
  372.     }
  374.     public function removeExposedIp(ExposedIp $exposedIp): static
  375.     {
  376.         if ($this->exposedIps->removeElement($exposedIp)) {
  377.             // set the owning side to null (unless already changed)
  378.             if ($exposedIp->getDomain() === $this) {
  379.                 $exposedIp->setDomain(null);
  380.             }
  381.         }
  383.         return $this;
  384.     }
  386.     /**
  387.      * @return Collection<int, GenericRecommendation>
  388.      */
  389.     public function getImplementedGenericRecommendations(): Collection
  390.     {
  391.         return $this->implementedGenericRecommendations;
  392.     }
  394.     public function addImplementedGenericRecommendation(GenericRecommendation $implementedGenericRecommendation): static
  395.     {
  396.         if (!$this->implementedGenericRecommendations->contains($implementedGenericRecommendation)) {
  397.             $this->implementedGenericRecommendations->add($implementedGenericRecommendation);
  398.         }
  400.         return $this;
  401.     }
  403.     public function removeImplementedGenericRecommendation(GenericRecommendation $implementedGenericRecommendation): static
  404.     {
  405.         $this->implementedGenericRecommendations->removeElement($implementedGenericRecommendation);
  407.         return $this;
  408.     }
  410.     /**
  411.      * @return Collection<int, Notification>
  412.      */
  413.     public function getNotifications(): Collection
  414.     {
  415.         return $this->notifications;
  416.     }
  418.     public function addNotification(Notification $notification): static
  419.     {
  420.         if (!$this->notifications->contains($notification)) {
  421.             $this->notifications->add($notification);
  422.             $notification->setDomain($this);
  423.         }
  425.         return $this;
  426.     }
  428.     public function removeNotification(Notification $notification): static
  429.     {
  430.         if ($this->notifications->removeElement($notification)) {
  431.             // set the owning side to null (unless already changed)
  432.             if ($notification->getDomain() === $this) {
  433.                 $notification->setDomain(null);
  434.             }
  435.         }
  437.         return $this;
  438.     }
  439. }