src/Entity/Document.php line 13

  1. <?php
  3. namespace App\Entity;
  5. use App\Entity\Document\Block;
  6. use App\Repository\DocumentRepository;
  7. use Doctrine\Common\Collections\ArrayCollection;
  8. use Doctrine\Common\Collections\Collection;
  9. use Doctrine\DBAL\Types\Types;
  10. use Doctrine\ORM\Mapping as ORM;
  12. #[ORM\Entity(repositoryClass: DocumentRepository::class)]
  13. class Document
  14. {
  15.     const TYPE_WEB = 0;
  16.     const TYPE_DOCX = 1;
  18.     const STATUS_DRAFT=0;
  19.     const STATUS_ON_PROGRESS=1;
  20.     const STATUS_FINALIZED=2;
  22.     const STATUSES = [
  23.         self::STATUS_DRAFT => "Draft",
  24.         self::STATUS_ON_PROGRESS => "On progress",
  25.         self::STATUS_FINALIZED => "Finalized"
  26.     ];
  29.     #[ORM\Id]
  30.     #[ORM\GeneratedValue]
  31.     #[ORM\Column]
  32.     private ?int $id = null;
  34.     #[ORM\Column(length: 255)]
  35.     private ?string $title = null;
  37.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  38.     private ?string $description = null;
  40.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  41.     private ?string $tags = null;
  43.     #[ORM\ManyToOne(inversedBy: 'docs')]
  44.     private ?User $owner = null;
  46.     #[ORM\Column(nullable: true)]
  47.     private ?bool $isTemplate = null;
  49.     #[ORM\ManyToOne(targetEntity: self::class)]
  50.     private ?self $sourceTemplate = null;
  52.     #[ORM\Column(type: Types::DATETIME_MUTABLE)]
  53.     private ?\DateTimeInterface $dateCreated = null;
  55.     #[ORM\Column(type: Types::DATETIME_MUTABLE)]
  56.     private ?\DateTimeInterface $dateUpdated = null;
  58.     #[ORM\Column(type: Types::DATETIME_MUTABLE)]
  59.     private ?\DateTimeInterface $version = null;
  61.     #[ORM\ManyToOne(targetEntity: self::class)]
  62.     private ?self $versionOf = null;
  64.     #[ORM\Column]
  65.     private ?int $type = null;
  67.     /* web specific attributes */
  68.     #[ORM\OneToMany(mappedBy: 'document', targetEntity: Block::class)]
  69.     #[ORM\OrderBy(["blockorder" => "ASC"])]
  70.     private Collection $blocks;
  73.     /* docx specific attributes */
  74.     #[ORM\ManyToOne]
  75.     private ?File $file = null;
  77.     #[ORM\OneToMany(mappedBy: 'document', targetEntity: DocumentPermission::class, orphanRemoval: true)]
  78.     private Collection $documentPermissions;
  80.     #[ORM\Column]
  81.     private ?int $status = 0;
  83.     #[ORM\Column]
  84.     private ?bool $isLastVersion = null;
  90.     public function __construct()
  91.     {
  92.         $this->blocks = new ArrayCollection();
  93.         $this->documentPermissions = new ArrayCollection();
  94.     }
  96.     public function getId(): ?int
  97.     {
  98.         return $this->id;
  99.     }
  101.     public function getTitle(): ?string
  102.     {
  103.         return $this->title;
  104.     }
  106.     public function setTitle(string $title): self
  107.     {
  108.         $this->title = $title;
  110.         return $this;
  111.     }
  113.     public function getDescription(): ?string
  114.     {
  115.         return $this->description;
  116.     }
  118.     public function setDescription(?string $description): self
  119.     {
  120.         $this->description = $description;
  122.         return $this;
  123.     }
  125.     public function getTags(): ?string
  126.     {
  127.         return $this->tags;
  128.     }
  130.     public function setTags(?string $tags): self
  131.     {
  132.         $this->tags = $tags;
  134.         return $this;
  135.     }
  137.     public function getOwner(): ?User
  138.     {
  139.         return $this->owner;
  140.     }
  142.     public function setOwner(?User $owner): self
  143.     {
  144.         $this->owner = $owner;
  146.         return $this;
  147.     }
  149.     public function isIsTemplate(): ?bool
  150.     {
  151.         return $this->isTemplate;
  152.     }
  154.     public function setIsTemplate(?bool $isTemplate): self
  155.     {
  156.         $this->isTemplate = $isTemplate;
  158.         return $this;
  159.     }
  161.     public function getSourceTemplate(): ?self
  162.     {
  163.         return $this->sourceTemplate;
  164.     }
  166.     public function setSourceTemplate(?self $sourceTemplate): self
  167.     {
  168.         $this->sourceTemplate = $sourceTemplate;
  170.         return $this;
  171.     }
  173.     public function getDateCreated(): ?\DateTimeInterface
  174.     {
  175.         return $this->dateCreated;
  176.     }
  178.     public function setDateCreated(\DateTimeInterface $dateCreated): self
  179.     {
  180.         $this->dateCreated = $dateCreated;
  182.         return $this;
  183.     }
  185.     public function getDateUpdated(): ?\DateTimeInterface
  186.     {
  187.         return $this->dateUpdated;
  188.     }
  190.     public function setDateUpdated(\DateTimeInterface $dateUpdated): self
  191.     {
  192.         $this->dateUpdated = $dateUpdated;
  194.         return $this;
  195.     }
  197.     public function getVersion(): ?\DateTimeInterface
  198.     {
  199.         return $this->version;
  200.     }
  202.     public function setVersion(\DateTimeInterface $version): self
  203.     {
  204.         $this->version = $version;
  206.         return $this;
  207.     }
  209.     public function getVersionOf(): ?self
  210.     {
  211.         return $this->versionOf;
  212.     }
  214.     public function setVersionOf(?self $versionOf): self
  215.     {
  216.         $this->versionOf = $versionOf;
  218.         return $this;
  219.     }
  221.     public function getType(): ?int
  222.     {
  223.         return $this->type;
  224.     }
  225.     public function getTypeToString()
  226.     {
  227.         $strType = $this->type == Document::TYPE_WEB ? "Web" : "";
  228.         $strType = $this->type == Document::TYPE_DOCX ? "Docx" : $strType;
  229.         return $strType;
  230.     }
  231.     public function typeIsWeb()
  232.     {
  233.         return $this->type == Document::TYPE_WEB;
  234.     }
  236.     public function setType(int $type): self
  237.     {
  238.         $this->type = $type;
  240.         return $this;
  241.     }
  243.     /**
  244.      * @return Collection<int, Block>
  245.      */
  246.     public function getBlocks(): Collection
  247.     {
  248.         return $this->blocks;
  249.     }
  251.     public function addBlock(Block $block): self
  252.     {
  253.         if (!$this->blocks->contains($block)) {
  254.             $this->blocks->add($block);
  255.             $block->setDocument($this);
  256.         }
  258.         return $this;
  259.     }
  261.     public function removeBlock(Block $block): self
  262.     {
  263.         if ($this->blocks->removeElement($block)) {
  264.             // set the owning side to null (unless already changed)
  265.             if ($block->getDocument() === $this) {
  266.                 $block->setDocument(null);
  267.             }
  268.         }
  270.         return $this;
  271.     }
  273.     public function getFile(): ?File
  274.     {
  275.         return $this->file;
  276.     }
  278.     public function setFile(?File $file): self
  279.     {
  280.         $this->file = $file;
  282.         return $this;
  283.     }
  284.     public static function clone(Document $source)
  285.     {
  286.         $document = new Document();
  287.         $document->setTags($source->getTags());
  288.         $document->setDescription($source->getDescription());
  289.         $document->setTitle($source->getTitle());
  290.         $document->setOwner($source->getOwner());
  291.         foreach($source->getBlocks() as $block)
  292.             $document->addBlock(Block::clone($block));
  293.         return $document;
  294.     }
  296.     public function getNextBlockId() {
  297.         if(count($this->getBlocks()) == 0)
  298.             return 1;
  299.         $ids = [];
  300.         /** @var Block $block */
  301.         foreach($this->getBlocks() as $block)
  302.             array_push($ids, $block->getIdInDoc());
  303.         sort($ids);
  304.         return ($ids[count($ids) - 1]) + 1;
  305.     }
  307.     /**
  308.      * @return Collection<int, DocumentPermission>
  309.      */
  310.     public function getDocumentPermissions(): Collection
  311.     {
  312.         return $this->documentPermissions;
  313.     }
  315.     public function addDocumentPermission(DocumentPermission $documentPermission): self
  316.     {
  317.         if (!$this->documentPermissions->contains($documentPermission)) {
  318.             $this->documentPermissions->add($documentPermission);
  319.             $documentPermission->setDocument($this);
  320.         }
  322.         return $this;
  323.     }
  325.     public function removeDocumentPermission(DocumentPermission $documentPermission): self
  326.     {
  327.         if ($this->documentPermissions->removeElement($documentPermission)) {
  328.             // set the owning side to null (unless already changed)
  329.             if ($documentPermission->getDocument() === $this) {
  330.                 $documentPermission->setDocument(null);
  331.             }
  332.         }
  334.         return $this;
  335.     }
  337.     public function allows(User $user) {
  338.         /** @var DocumentPermission $p */
  339.         foreach($this->documentPermissions as $p){
  340.             if($p->getUser() === $user)
  341.                 return true;
  342.         }
  343.         return false;
  344.     }
  346.     public function getStatus(): ?int
  347.     {
  348.         return $this->status;
  349.     }
  351.     public function setStatus(int $status): self
  352.     {
  353.         $this->status = $status;
  355.         return $this;
  356.     }
  358.     public function toArray()
  359.     {
  360.         return  [
  361.             "id" => $this->getId(),
  362.             "tags" => $this->getTags(),
  363.             "description" => $this->getDescription(),
  364.             "title" => $this->getTitle(),
  365.         ];
  366.     }
  368.     public function isIsLastVersion(): ?bool
  369.     {
  370.         return $this->isLastVersion;
  371.     }
  373.     public function setIsLastVersion(bool $isLastVersion)
  374.     {
  375.         $this->isLastVersion = $isLastVersion;
  377.         return $this;
  378.     }
  379. }