src/Entity/Slave/AccountType.php line 14

Open in your IDE?
  1. <?php
  3. namespace App\Entity\Slave;
  5. use Doctrine\Common\Collections\ArrayCollection;
  6. use Doctrine\Common\Collections\Collection;
  7. use Doctrine\DBAL\Types\Types;
  8. use Doctrine\ORM\Mapping as ORM;
  10. /**
  11.  * @ORM\Table(name="eposm_s_account_type")
  12.  * @ORM\Entity(repositoryClass="App\Repository\Slave\AccountTypeRepository")
  13.  */
  14. class AccountType
  15. {
  16.     public function __toString(){
  17.         return $this->getValue();
  18.     }
  20.     public function getCanDelete(){
  21.         if(sizeof($this->users) > 0) return false;
  22.         return true;
  23.     }
  24.     
  25.     /**
  26.      * @ORM\Column(name="id", type="bigint")
  27.      * @ORM\Id
  28.      * @ORM\GeneratedValue(strategy="AUTO")
  29.      */
  30.     protected $id;
  32.     /**
  33.      * @ORM\Column(name="value", type="string", length=191)
  34.      */
  35.     protected $value;
  37.     /**
  38.      * @ORM\Column(name="slug", type="string", length=191)
  39.      */
  40.     protected $slug;
  42.     // OneToMany
  43.         /**
  44.          * @ORM\OneToMany(targetEntity="App\Entity\Slave\User", mappedBy="accountType")
  45.          */
  46.         private $users;
  47.         
  48.         /**
  49.          * @ORM\OneToMany(targetEntity="App\Entity\Slave\JoinTableAccountTypePermission", mappedBy="accountType")
  50.          */
  51.         private $permissions;
  52.     //
  54.     // ManyToOne
  55.         /**
  56.          * @ORM\ManyToOne(targetEntity="App\Entity\Slave\AccountCategory", inversedBy="types")
  57.          * @ORM\JoinColumn(name="category_id", referencedColumnName="id")
  58.          */
  59.         private $category;
  61.         public function __construct()
  62.         {
  63.             $this->users = new ArrayCollection();
  64.             $this->permissions = new ArrayCollection();
  65.         }
  67.         public function getId(): ?string
  68.         {
  69.             return $this->id;
  70.         }
  72.         public function getValue(): ?string
  73.         {
  74.             return $this->value;
  75.         }
  77.         public function setValue(string $value): static
  78.         {
  79.             $this->value = $value;
  81.             return $this;
  82.         }
  84.         public function getSlug(): ?string
  85.         {
  86.             return $this->slug;
  87.         }
  89.         public function setSlug(string $slug): static
  90.         {
  91.             $this->slug = $slug;
  93.             return $this;
  94.         }
  96.         /**
  97.          * @return Collection<int, User>
  98.          */
  99.         public function getUsers(): Collection
  100.         {
  101.             return $this->users;
  102.         }
  104.         public function addUser(User $user): static
  105.         {
  106.             if (!$this->users->contains($user)) {
  107.                 $this->users->add($user);
  108.                 $user->setAccountType($this);
  109.             }
  111.             return $this;
  112.         }
  114.         public function removeUser(User $user): static
  115.         {
  116.             if ($this->users->removeElement($user)) {
  117.                 // set the owning side to null (unless already changed)
  118.                 if ($user->getAccountType() === $this) {
  119.                     $user->setAccountType(null);
  120.                 }
  121.             }
  123.             return $this;
  124.         }
  126.         /**
  127.          * @return Collection<int, JoinTableAccountTypePermission>
  128.          */
  129.         public function getPermissions(): Collection
  130.         {
  131.             return $this->permissions;
  132.         }
  134.         public function addPermission(JoinTableAccountTypePermission $permission): static
  135.         {
  136.             if (!$this->permissions->contains($permission)) {
  137.                 $this->permissions->add($permission);
  138.                 $permission->setAccountType($this);
  139.             }
  141.             return $this;
  142.         }
  144.         public function removePermission(JoinTableAccountTypePermission $permission): static
  145.         {
  146.             if ($this->permissions->removeElement($permission)) {
  147.                 // set the owning side to null (unless already changed)
  148.                 if ($permission->getAccountType() === $this) {
  149.                     $permission->setAccountType(null);
  150.                 }
  151.             }
  153.             return $this;
  154.         }
  156.         public function getCategory(): ?AccountCategory
  157.         {
  158.             return $this->category;
  159.         }
  161.         public function setCategory(?AccountCategory $category): static
  162.         {
  163.             $this->category = $category;
  165.             return $this;
  166.         }
  167. }