src/Entity/File/OSFile.php line 26

Open in your IDE?
  1. <?php
  3. namespace App\Entity\File;
  5. use App\Entity\Attachment;
  6. use App\Repository\FileRepository;
  7. use App\EventListener\OSFile\OSFileEntityListener;
  8. use App\Entity\Users;
  9. use Doctrine\ORM\Mapping as ORM;
  10. use Symfony\Component\HttpFoundation\File\File as SymfonyFile;
  11. use Symfony\Component\Uid\UuidV4;
  12. use Symfony\Component\Validator\Constraints as Assert;
  13. use OlaSoft\Common;
  15. #[ORM\Entity(repositoryClass: FileRepository::class)]
  16. #[ORM\Table(name: "File")]
  17. #[ORM\InheritanceType("JOINED")]
  18. #[ORM\DiscriminatorColumn(name: "type", type: "string")]
  19. #[ORM\DiscriminatorMap([
  20.     "file" => OSFile::class,
  21.     "attachment" => Attachment::class,
  22.     "picture" => Picture::class,
  23. ])]
  24. #[ORM\HasLifecycleCallbacks]
  25. #[ORM\EntityListeners([OSFileEntityListener::class])]
  26. class OSFile implements \Serializable
  27. {
  28.     public const ACCESS_PRIVATE = 'private';
  29.     public const ACCESS_PROTECTED = 'protected';
  30.     public const ACCESS_PUBLIC = 'public';
  32.     protected $file;
  34.     public function getUploadedFile()
  35.     {
  36.         return $this->file;
  37.     }
  38.     protected $filename;
  39.     protected $autoResize = true;
  40.     protected $previousTarget;
  42.     #[ORM\Id]
  43.     #[ORM\GeneratedValue]
  44.     #[ORM\Column(type: 'integer')]
  45.     protected ?int $id= null;
  47.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  48.     #[Assert\NotNull]
  49.     protected ?string $target= null;
  51.     #[ORM\Column(type: 'integer', nullable: true)]
  52.     protected ?int $pages;
  54.     #[ORM\Column(type: 'integer', nullable: true)]
  55.     protected ?int $downloads;
  57.     #[ORM\Column(type: 'integer', nullable: true)]
  58.     protected ?int $reading;
  60.     #[ORM\Column(type: 'string', nullable: true)]
  61.     protected ?string $name;
  63.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  64.     protected ?string $dir;
  66.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  67.     protected ?string $source;
  69.     #[ORM\Column(type: 'integer', nullable: true)]
  70.     protected ?int $size;
  72.     #[ORM\Column(type: 'boolean', nullable: true)]
  73.     protected ?bool $isEnabled;
  75.     #[ORM\Column(type: 'boolean', nullable: true)]
  76.     protected ?bool $isDeleted;
  78.     #[ORM\Column(type: 'datetime', nullable: true)]
  79.     protected ?\DateTimeInterface $lastUpdate;
  81.     #[ORM\Column(type: 'datetime', nullable: true)]
  82.     protected ?\DateTimeInterface $createdAt;
  84.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  85.     protected ?string $formatSize= null;
  87.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  88.     protected ?string $mimetype= null;
  90.     protected array $validsMimetypes= ["*"];
  92.     #[ORM\ManyToOne(targetEntity: Users::class)]
  93.     private ?Users $createdBy;
  95.     #[ORM\Column(type: 'uuid', nullable: true)]
  96.     private ?UuidV4 $uuid;
  98.     #[ORM\Column(type: 'array', nullable: true)]
  99.     private ?array $viewStrategy= [];
  101.     public function __construct(?string $path = null)
  102.     {
  103.         $this->file = null;
  104.         $this->filename = null;
  105.         $this->previousTarget = null;
  106.         $this->validsMimetypes = ["*"];
  107.         $this->autoResize = true;
  109.         if($path){
  110.             $t = explode("/", $path);
  111.             $filename = $t[count($t)-1];
  112.             $this->target = $filename;
  113.             $this->dir = preg_replace('/\b\/'.$filename.'$\b/', '', $path);
  114.         }
  115.         else {
  116.             $this->dir = 'upload/files/';
  117.         }
  118.     }
  120.     public function getId(): ?int
  121.     {
  122.         return $this->id;
  123.     }
  125.     protected function getRoot(){
  126.         return __DIR__.'/../../../public/';
  127.     }
  129.     protected function getRootDir(){
  130.         return $this->getRoot().$this->getDir();
  131.     }
  133.     public function getFile(){
  134.         return $this->getDir().'/'.$this->target;
  135.     }
  137.     public function getRootFile(){
  138.         return $this->getRootDir().'/'.$this->target;
  139.     }
  141.     public function getPages(): ?int
  142.     {
  143.         return $this->pages;
  144.     }
  146.     public function setPages(?int $pages): self
  147.     {
  148.         $this->pages = $pages;
  150.         return $this;
  151.     }
  153.     public function getDownloads(): ?int
  154.     {
  155.         return $this->downloads;
  156.     }
  158.     public function setDownloads(?int $downloads): self
  159.     {
  160.         $this->downloads = $downloads;
  162.         return $this;
  163.     }
  165.     public function getReading(): ?int
  166.     {
  167.         return $this->reading;
  168.     }
  170.     public function setReading(?int $reading): self
  171.     {
  172.         $this->reading = $reading;
  174.         return $this;
  175.     }
  177.     public function getName(): ?string
  178.     {
  179.         return $this->name;
  180.     }
  182.     public function setName(?string $name): self
  183.     {
  184.         $this->name = $name;
  186.         return $this;
  187.     }
  189.     public function getDir(): ?string
  190.     {
  191.         return $this->dir;
  192.     }
  194.     public function setDir(?string $dir): self
  195.     {
  196.         $this->dir = $dir;
  198.         return $this;
  199.     }
  201.     public function setAutoResize(?bool $autoResize = true){
  202.         $this->autoResize = $autoResize;
  203.     }
  205.     public function getSource(): ?string
  206.     {
  207.         return $this->source;
  208.     }
  210.     public function setSource(?string $source): self
  211.     {
  212.         $this->source = $source;
  214.         return $this;
  215.     }
  217.     public function getIsEnabled(): ?bool
  218.     {
  219.         return $this->isEnabled;
  220.     }
  222.     public function setIsEnabled(?bool $isEnabled): self
  223.     {
  224.         $this->isEnabled = $isEnabled;
  226.         return $this;
  227.     }
  229.     public function getIsDeleted(): ?bool
  230.     {
  231.         return $this->isDeleted;
  232.     }
  234.     public function setIsDeleted(?bool $isDeleted): self
  235.     {
  236.         $this->isDeleted = $isDeleted;
  238.         return $this;
  239.     }
  241.     public function getLastUpdate(): ?\DateTimeInterface
  242.     {
  243.         return $this->lastUpdate;
  244.     }
  246.     public function setLastUpdate(?\DateTimeInterface $lastUpdate): self
  247.     {
  248.         $this->lastUpdate = $lastUpdate;
  250.         return $this;
  251.     }
  253.     public function getCreatedAt(): ?\DateTimeInterface
  254.     {
  255.         return $this->createdAt;
  256.     }
  258.     public function setCreatedAt(\DateTimeInterface $createdAt): self
  259.     {
  260.         $this->createdAt = $createdAt;
  262.         return $this;
  263.     }
  265.     #[ORM\PrePersist]
  266.     public  function setDateOnPersist(){
  267.         $this->createdAt= new \DateTime();
  268.     }
  270.     #[ORM\PreUpdate]
  271.     public  function setDateOnUpdate(){
  272.         $this->lastUpdate= new \DateTime();
  273.     }
  275.     public function getTarget(): ?SymfonyFile
  276.     {
  277.         if($this->target){
  278.             return new SymfonyFile($this->target, false);
  279.         }
  280.         return null;
  281.     }
  283.     public function setTarget($target)
  284.     {
  285.         if ($target){
  286.             $this->file = $target;
  287.             $this->source = $target->getClientOriginalName();
  288.             $fileName = $this->filename ?? Common::generateCode().Common::generateName().'.'. ( $target->guessExtension() ? $target->guessExtension() : $target->getClientOriginalExtension() );
  289.             $this->size = $target->getSize();
  290.             $this->mimetype = $target->getMimeType();
  291.             $this->previousTarget = $this->target;
  292.             $this->target = $fileName;
  293.             $this->formatSize = Common::prettySize($this->size);
  294.         }
  295.         return $this;
  296.     }
  298.     protected function getPrevFile(){
  299.         return $this->getRootDir().'/'.$this->previousTarget;
  300.     }
  302.     public function setFilename($filename){
  303.         $this->filename = $filename;
  304.         return $this;
  305.     }
  307.     public function getSize(): ?int
  308.     {
  309.         return $this->size;
  310.     }
  312.     public function setSize(?int $size): self
  313.     {
  314.         $this->size = $size;
  316.         return $this;
  317.     }
  319.     public function getFormatSize(): ?string
  320.     {
  321.         return $this->formatSize;
  322.     }
  324.     public function setFormatSize(?string $formatSize): self
  325.     {
  326.         $this->formatSize = $formatSize;
  328.         return $this;
  329.     }
  331.     public function getMimetype(): ?string
  332.     {
  333.         return $this->mimetype;
  334.     }
  336.     public function setMimetype(?string $mimetype): self
  337.     {
  338.         $this->mimetype = $mimetype;
  340.         return $this;
  341.     }
  343.     #[ORM\PrePersist]
  344.     #[ORM\PostUpdate]
  345.     public function persistFile()
  346.     {
  347.         if ($this->file){
  348.             $this->file->move($this->getRootDir(), $this->target);
  349.             if($this->previousTarget && $this->previousTarget != $this->target){
  350.                 $previousFile = $this->getPrevFile();
  351.                 if(is_file($previousFile))
  352.                     unlink($previousFile);
  353.             }
  355.         }
  356.     }
  358.     #[ORM\PreRemove]
  359.     public function deleteFile()
  360.     {
  361.         if(is_file($this->getFile()))
  362.             unlink($this->getFile());
  363.     }
  365.     #[Assert\IsTrue(message : "Veuillez choisir des fichiers valides s'il vous plaît. Vérifiez également le MimeType.")]
  366.     public function isValidMimetype()
  367.     {
  368.         if(!$this->validsMimetypes || in_array('*', $this->validsMimetypes))
  369.             return true;
  371.         return  in_array($this->mimetype, $this->validsMimetypes);
  372.     }
  374.     public function setValidsMimetypes(?array $mimetypes): self
  375.     {
  376.         $this->validsMimetypes = $mimetypes;
  377.         return $this;
  378.     }
  380.     public function getValidsMimetypes(): ?array
  381.     {
  382.         return $this->validsMimetypes;
  383.     }
  385.     public function __toString(): string{
  386.         return $this->getFile() ?? "";
  387.     }
  389.     public function serialize()
  390.     {
  391.         return serialize(array(
  392.             $this->id,
  393.             $this->name,
  394.             $this->target,
  395.         ));
  396.     }
  398.     public function unserialize($serialized)
  399.     {
  400.         list (
  401.             $this->id,
  402.             $this->name,
  403.             $this->target,
  404.             ) = unserialize($serialized);
  405.     }
  407.     public function getCreatedBy(): ?Users
  408.     {
  409.         return $this->createdBy;
  410.     }
  412.     public function setCreatedBy(?Users $createdBy): self
  413.     {
  414.         $this->createdBy = $createdBy;
  416.         return $this;
  417.     }
  419.     public function getUuid(): ?UuidV4
  420.     {
  421.         return $this->uuid;
  422.     }
  424.     public function getViewStrategy(): array
  425.     {
  426.         return $this->viewStrategy ?? [];
  427.     }
  429.     public function makeAsPrivate(): static
  430.     {
  431.         // add strategy to make file private
  432.         if(!$this->viewStrategy){
  433.             $this->viewStrategy = [];
  434.         }
  435.         $this->viewStrategy[] = self::ACCESS_PRIVATE;
  436.         return $this;
  437.     }
  439.     public function makeAsPublic(): static
  440.     {
  441.         // add strategy to make file public
  442.         if(!$this->viewStrategy){
  443.             $this->viewStrategy = [];
  444.         }
  445.         $this->viewStrategy[] = self::ACCESS_PUBLIC;
  446.         return $this;
  447.     }
  449.     public function makeAsProtected(): static
  450.     {
  451.         // add strategy to make file protected
  452.         if(!$this->viewStrategy){
  453.             $this->viewStrategy = [];
  454.         }
  455.         $this->viewStrategy[] = self::ACCESS_PROTECTED;
  456.         return $this;
  457.     }
  459.     public function __serialize(): array
  460.     {
  461.         return array(
  462.             $this->id,
  463.             $this->name,
  464.             $this->target,
  465.         );
  466.     }
  468.     public function __unserialize(array $data): void
  469.     {
  470.         [
  471.             $this->id,
  472.             $this->name,
  473.             $this->target,
  474.         ] = $data;
  475.     }
  476. }