src/Entity/Workroom.php line 12

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Entity\Common\StateInterface;
  6. use App\Repository\WorkroomRepository;
  7. use Doctrine\Common\Collections\ArrayCollection;
  8. use Doctrine\Common\Collections\Collection;
  9. use Doctrine\ORM\Mapping as ORM;
  11. #[ORM\Entity(repositoryClass: WorkroomRepository::class)]
  12. class Workroom
  13. {
  14.     public const BINDINGS = [
  15.         '[[WORKROOM.NAME]]',
  16.         '[[WORKROOM.PROJECT.NAME]]',
  17.     ];
  19.     public const STATE_CLOSED = StateInterface::STATE_WKR_CLOSED_INT;
  20.     
  21.     #[ORM\Id]
  22.     #[ORM\GeneratedValue]
  23.     #[ORM\Column(type: 'integer')]
  24.     private $id;
  26.     #[ORM\Column(type: 'string', length: 255)]
  27.     private $name;
  29.     #[ORM\OneToOne(targetEntity: Chat::class, mappedBy: 'workroom', cascade: ['persist', 'remove'])]
  30.     private $chat;
  32.     #[ORM\OneToMany(targetEntity: Section::class, mappedBy: 'workroom', cascade: ['remove'])]
  33.     private $sections;
  35.     #[ORM\OneToMany(targetEntity: SemanticTag::class, mappedBy: 'workroom')]
  36.     private $semanticTags;
  38.     #[ORM\OneToMany(targetEntity: WorkroomResource::class, mappedBy: 'workroom', cascade: ['remove'])]
  39.     private $workroomResources;
  41.     #[ORM\ManyToOne(targetEntity: Project::class, inversedBy: 'workrooms')]
  42.     #[ORM\JoinColumn(onDelete: 'CASCADE')]
  43.     private $project;
  45.     #[ORM\OneToMany(targetEntity: UserWorkroom::class, mappedBy: 'workroom', cascade: ['remove'])]
  46.     private $userWorkrooms;
  48.     #[ORM\OneToMany(targetEntity: WorkroomFolder::class, mappedBy: 'workroom', cascade: ['remove'])]
  49.     private $workroomFolders;
  51.     #[ORM\Column(type: 'string', length: 255, unique: true)]
  52.     private $uuid;
  54.     #[ORM\ManyToMany(targetEntity: Invitation::class, mappedBy: 'workroom')]
  55.     private $invitations;
  57.     #[ORM\OneToMany(targetEntity: WorkroomRevision::class, mappedBy: 'workroom', orphanRemoval: true, cascade: ['remove'])]
  58.     private $workroomRevisions;
  60.     #[ORM\OneToOne(targetEntity: WorkroomArena::class, mappedBy: 'workroom', cascade: ['persist', 'remove'])]
  61.     private $workroomArena;
  63.     #[ORM\Column(name: 'state', type: 'smallint', options: ['default' => 1])]
  64.     private $state;
  66.     #[ORM\Column(type: 'smallint')]
  67.     private $position;
  69.     private Collection $chats;
  71.     /**
  72.      * Workroom constructor.
  73.      */
  74.     public function __construct()
  75.     {
  76.         $this->chats = new ArrayCollection();
  77.         $this->sections = new ArrayCollection();
  78.         $this->workroomResources = new ArrayCollection();
  79.         $this->userWorkrooms = new ArrayCollection();
  80.         $this->workroomFolders = new ArrayCollection();
  81.         $this->invitations = new ArrayCollection();
  82.         $this->workroomRevisions = new ArrayCollection();
  83.     }
  85.     public function __toString()
  86.     {
  87.         return $this->name;
  88.     }
  89.     
  90.     public function getBindings(): array
  91.     {
  92.         return [
  93.             'WORKROOM.NAME' => $this->getName(),
  94.             'WORKROOM.PROJECT.NAME' => $this->getProject()->getName(),
  95.         ];
  96.     }
  98.     /**
  99.      * @return int|null
  100.      */
  101.     public function getId(): ?int
  102.     {
  103.         return $this->id;
  104.     }
  106.     /**
  107.      * @return string|null
  108.      */
  109.     public function getName(): ?string
  110.     {
  111.         return $this->name;
  112.     }
  114.     /**
  115.      * @param string $name
  116.      * @return $this
  117.      */
  118.     public function setName(string $name): self
  119.     {
  120.         $this->name = $name;
  122.         return $this;
  123.     }
  125.     public function getChat(): ?Chat
  126.     {
  127.         return $this->chat;
  128.     }
  130.     public function setChat(Chat $chat): self
  131.     {
  132.         // set the owning side of the relation if necessary
  133.         if ($chat->getWorkroom() !== $this) {
  134.             $chat->setWorkroom($this);
  135.         }
  137.         $this->chat = $chat;
  139.         return $this;
  140.     }
  142.     /**
  143.      * @return Collection|Section[]
  144.      */
  145.     public function getSections(): Collection
  146.     {
  147.         return $this->sections;
  148.     }
  150.     /**
  151.      * @param Section $section
  152.      * @return $this
  153.      */
  154.     public function addSection(Section $section): self
  155.     {
  156.         if (!$this->sections->contains($section)) {
  157.             $this->sections[] = $section;
  158.             $section->setWorkroom($this);
  159.         }
  161.         return $this;
  162.     }
  164.     /**
  165.      * @param Section $section
  166.      * @return $this
  167.      */
  168.     public function removeSection(Section $section): self
  169.     {
  170.         if ($this->sections->removeElement($section)) {
  171.             // set the owning side to null (unless already changed)
  172.             if ($section->getWorkroom() === $this) {
  173.                 $section->setWorkroom(null);
  174.             }
  175.         }
  177.         return $this;
  178.     }
  180.     /**
  181.      * @return Collection|WorkroomResource[]
  182.      */
  183.     public function getWorkroomResources(): Collection
  184.     {
  185.         return $this->workroomResources;
  186.     }
  188.     /**
  189.      * @param WorkroomResource $workroomResource
  190.      * @return $this
  191.      */
  192.     public function addWorkroomResource(WorkroomResource $workroomResource): self
  193.     {
  194.         if (!$this->workroomResources->contains($workroomResource)) {
  195.             $this->workroomResources[] = $workroomResource;
  196.             $workroomResource->setWorkroom($this);
  197.         }
  199.         return $this;
  200.     }
  202.     /**
  203.      * @param WorkroomResource $workroomResource
  204.      * @return $this
  205.      */
  206.     public function removeWorkroomResource(WorkroomResource $workroomResource): self
  207.     {
  208.         if ($this->workroomResources->removeElement($workroomResource)) {
  209.             // set the owning side to null (unless already changed)
  210.             if ($workroomResource->getWorkroom() === $this) {
  211.                 $workroomResource->setWorkroom(null);
  212.             }
  213.         }
  215.         return $this;
  216.     }
  218.     /**
  219.      * @return Project|null
  220.      */
  221.     public function getProject(): ?Project
  222.     {
  223.         return $this->project;
  224.     }
  226.     /**
  227.      * @param Project|null $project
  228.      * @return $this
  229.      */
  230.     public function setProject(?Project $project): self
  231.     {
  232.         $this->project = $project;
  234.         return $this;
  235.     }
  237.     /**
  238.      * @return Collection|UserWorkroom[]
  239.      */
  240.     public function getUserWorkrooms(): Collection
  241.     {
  242.         return $this->userWorkrooms;
  243.     }
  245.     /**
  246.      * @param UserWorkroom $userWorkroom
  247.      * @return $this
  248.      */
  249.     public function addUserWorkroom(UserWorkroom $userWorkroom): self
  250.     {
  251.         if (!$this->userWorkrooms->contains($userWorkroom)) {
  252.             $this->userWorkrooms[] = $userWorkroom;
  253.             $userWorkroom->setWorkroom($this);
  254.         }
  256.         return $this;
  257.     }
  259.     /**
  260.      * @param UserWorkroom $userWorkroom
  261.      * @return $this
  262.      */
  263.     public function removeUserWorkroom(UserWorkroom $userWorkroom): self
  264.     {
  265.         if ($this->userWorkrooms->removeElement($userWorkroom)) {
  266.             // set the owning side to null (unless already changed)
  267.             if ($userWorkroom->getWorkroom() === $this) {
  268.                 $userWorkroom->setWorkroom(null);
  269.             }
  270.         }
  272.         return $this;
  273.     }
  275.     /**
  276.      * @return Collection|WorkroomFolder[]
  277.      */
  278.     public function getWorkroomFolders(): Collection
  279.     {
  280.         return $this->workroomFolders;
  281.     }
  283.     public function addWorkroomFolder(WorkroomFolder $workroomFolder): self
  284.     {
  285.         if (!$this->workroomFolders->contains($workroomFolder)) {
  286.             $this->workroomFolders[] = $workroomFolder;
  287.             $workroomFolder->setWorkroom($this);
  288.         }
  290.         return $this;
  291.     }
  293.     public function removeWorkroomFolder(WorkroomFolder $workroomFolder): self
  294.     {
  295.         if ($this->workroomFolders->removeElement($workroomFolder)) {
  296.             // set the owning side to null (unless already changed)
  297.             if ($workroomFolder->getWorkroom() === $this) {
  298.                 $workroomFolder->setWorkroom(null);
  299.             }
  300.         }
  302.         return $this;
  303.     }
  305.     public function getUuid(): ?string
  306.     {
  307.         return $this->uuid;
  308.     }
  310.     public function setUuid(string $uuid): self
  311.     {
  312.         $this->uuid = $uuid;
  314.         return $this;
  315.     }
  317.     /**
  318.      * @return $this
  319.      * @throws \Exception
  320.      */
  321.     public function generateUuid(): self
  322.     {
  323.         $this->uuid = bin2hex(random_bytes(16));
  325.         return $this;
  326.     }
  328.     /**
  329.      * Gets triggered only on insert.
  330.      * Set created date.
  331.      */
  332.     #[ORM\PrePersist]
  333.     public function onPrePersist()
  334.     {
  335.         $this->generateUuid();
  337.         return $this;
  338.     }
  340.     /**
  341.      * @return Collection|Invitation[]
  342.      */
  343.     public function getInvitations(): Collection
  344.     {
  345.         return $this->invitations;
  346.     }
  348.     public function addInvitation(Invitation $invitation): self
  349.     {
  350.         if (!$this->invitations->contains($invitation)) {
  351.             $this->invitations[] = $invitation;
  352.             $invitation->addWorkroom($this);
  353.         }
  355.         return $this;
  356.     }
  358.     public function removeInvitation(Invitation $invitation): self
  359.     {
  360.         if ($this->invitations->removeElement($invitation)) {
  361.             $invitation->removeWorkroom($this);
  362.         }
  364.         return $this;
  365.     }
  367.     /**
  368.      * @return Collection|WorkroomRevision[]
  369.      */
  370.     public function getWorkroomRevisions(): Collection
  371.     {
  372.         return $this->workroomRevisions;
  373.     }
  375.     public function addWorkroomRevision(WorkroomRevision $workroomRevision): self
  376.     {
  377.         if (!$this->workroomRevisions->contains($workroomRevision)) {
  378.             $this->workroomRevisions[] = $workroomRevision;
  379.             $workroomRevision->setWorkroom($this);
  380.         }
  382.         return $this;
  383.     }
  385.     public function removeWorkroomRevision(WorkroomRevision $workroomRevision): self
  386.     {
  387.         if ($this->workroomRevisions->removeElement($workroomRevision)) {
  388.             // set the owning side to null (unless already changed)
  389.             if ($workroomRevision->getWorkroom() === $this) {
  390.                 $workroomRevision->setWorkroom(null);
  391.             }
  392.         }
  394.         return $this;
  395.     }
  397.     public function getWorkroomArena(): ?WorkroomArena
  398.     {
  399.         return $this->workroomArena;
  400.     }
  402.     public function setWorkroomArena(WorkroomArena $workroomArena): self
  403.     {
  404.         // set the owning side of the relation if necessary
  405.         if ($workroomArena->getWorkroom() !== $this) {
  406.             $workroomArena->setWorkroom($this);
  407.         }
  409.         $this->workroomArena = $workroomArena;
  411.         return $this;
  412.     }
  414.     public function getState(): ?int
  415.     {
  416.         return $this->state;
  417.     }
  419.     public function setState(int $state): self
  420.     {
  421.         $this->state = $state;
  423.         return $this;
  424.     }
  426.     /**
  427.      * @return int|null
  428.      */
  429.     public function getPosition(): ?int
  430.     {
  431.         return $this->position;
  432.     }
  434.     /**
  435.      * @param int $position
  436.      * @return $this
  437.      */
  438.     public function setPosition(int $position): self
  439.     {
  440.         $this->position = $position;
  442.         return $this;
  443.     }
  444. }