src/Entity/OSFile.php line 15

  1. <?php
  3. namespace App\Entity;
  5. use Doctrine\ORM\Mapping as ORM;
  6. use Doctrine\ORM\Mapping\MappedSuperclass;
  7. use Symfony\Component\HttpFoundation\File\File as SymfonyFile;
  8. use Symfony\Component\Validator\Constraints as Assert;
  9. use OlaSoft\Common;
  11. /**
  12.  * @ORM\MappedSuperclass()
  13.  * @ORM\HasLifecycleCallbacks()
  14.  */
  15. class OSFile implements \Serializable
  16. {
  17.     protected $file;
  18.     protected $filename;
  19.     protected $autoResize = true;
  20.     protected $previousTarget;
  22.     /**
  23.      * @ORM\Column(name="id", type="integer")
  24.      * @ORM\Id
  25.      * @ORM\GeneratedValue(strategy="AUTO")
  26.      */
  27.     protected $id;
  29.     /**
  30.      * @ORM\Column(name="target", type="string", length=255,nullable=true)
  31.      */
  32.     protected $target;
  34.     /**
  35.      * @ORM\Column(type="integer", nullable=true)
  36.      */
  37.     protected $pages;
  39.     /**
  40.      * @ORM\Column(name="downloads", type="integer", nullable=true)
  41.      */
  42.     protected $downloads;
  44.     /**
  45.      * @ORM\Column(name="reading", type="integer", nullable=true)
  46.      */
  47.     protected $reading;
  49.     /**
  50.      * @ORM\Column(name="name", type="string", nullable=true)
  51.      */
  52.     protected $name;
  54.     /**
  55.      * @ORM\Column(name="dir", type="string", length=255,nullable=true)
  56.      */
  57.     protected $dir;
  59.     /**
  60.      * @ORM\Column(name="source", type="string", length=255,nullable=true)
  61.      */
  62.     protected $source;
  64.     /**
  65.      * @ORM\Column(name="size", type="integer",nullable=true)
  66.      */
  67.     protected $size;
  69.     /**
  70.      * @ORM\Column(type="boolean", nullable=true)
  71.      */
  72.     protected $isEnabled;
  74.     /**
  75.      * @ORM\Column(type="boolean", nullable=true)
  76.      */
  77.     protected $isDeleted;
  79.     /**
  80.      * @ORM\Column(type="datetime", nullable=true)
  81.      */
  82.     protected $lastUpdate;
  84.     /**
  85.      * @ORM\Column(type="datetime", nullable=true)
  86.      */
  87.     protected $createdAt;
  89.     /**
  90.      * @ORM\Column(name="formatSize", type="string", length=255,nullable=true)
  91.      */
  92.     protected $formatSize;
  94.     /**
  95.      * @ORM\Column(name="mimetype", type="string", length=255,nullable=true)
  96.      */
  97.     protected $mimetype;
  98.     protected $validsMimetypes;
  100.     public function __construct(?string $path = null)
  101.     {
  102.         $this->file = null;
  103.         $this->filename = null;
  104.         $this->previousTarget = null;
  105.         $this->validsMimetypes = ["*"];
  106.         $this->autoResize = true;
  108.         if($path){
  109.             $t = explode("/", $path);
  110.             $filename = $t[count($t)-1];
  111.             $this->target = $filename;
  112.             $this->dir = preg_replace('/\b\/'.$filename.'$\b/', '', $path);
  113.         }
  114.         else {
  115.             $this->dir = 'upload/files/';
  116.         }
  117.     }
  119.     public function getId(): ?int
  120.     {
  121.         return $this->id;
  122.     }
  124.     protected function getRoot(){
  125.         return __DIR__.'/../../public/';
  126.     }
  128.     protected function getRootDir(){
  129.         return $this->getRoot().$this->getDir();
  130.     }
  132.     public function getFile(){
  133.         return $this->getDir().'/'.$this->target;
  134.     }
  136.     public function getRootFile(){
  137.         return $this->getRootDir().'/'.$this->target;
  138.     }
  140.     public function getPages(): ?int
  141.     {
  142.         return $this->pages;
  143.     }
  145.     public function setPages(?int $pages): self
  146.     {
  147.         $this->pages = $pages;
  149.         return $this;
  150.     }
  152.     public function getDownloads(): ?int
  153.     {
  154.         return $this->downloads;
  155.     }
  157.     public function setDownloads(?int $downloads): self
  158.     {
  159.         $this->downloads = $downloads;
  161.         return $this;
  162.     }
  164.     public function getReading(): ?int
  165.     {
  166.         return $this->reading;
  167.     }
  169.     public function setReading(?int $reading): self
  170.     {
  171.         $this->reading = $reading;
  173.         return $this;
  174.     }
  176.     public function getName(): ?string
  177.     {
  178.         return $this->name;
  179.     }
  181.     public function setName(?string $name): self
  182.     {
  183.         $this->name = $name;
  185.         return $this;
  186.     }
  188.     public function getDir(): ?string
  189.     {
  190.         return $this->dir;
  191.     }
  193.     public function setDir(?string $dir): self
  194.     {
  195.         $this->dir = $dir;
  197.         return $this;
  198.     }
  200.     public function setAutoResize(?bool $autoResize = true){
  201.         $this->autoResize = $autoResize;
  202.     }
  204.     public function getSource(): ?string
  205.     {
  206.         return $this->source;
  207.     }
  209.     public function setSource(?string $source): self
  210.     {
  211.         $this->source = $source;
  213.         return $this;
  214.     }
  216.     public function getIsEnabled(): ?bool
  217.     {
  218.         return $this->isEnabled;
  219.     }
  221.     public function setIsEnabled(?bool $isEnabled): self
  222.     {
  223.         $this->isEnabled = $isEnabled;
  225.         return $this;
  226.     }
  228.     public function getIsDeleted(): ?bool
  229.     {
  230.         return $this->isDeleted;
  231.     }
  233.     public function setIsDeleted(?bool $isDeleted): self
  234.     {
  235.         $this->isDeleted = $isDeleted;
  237.         return $this;
  238.     }
  240.     public function getLastUpdate(): ?\DateTimeInterface
  241.     {
  242.         return $this->lastUpdate;
  243.     }
  245.     public function setLastUpdate(?\DateTimeInterface $lastUpdate): self
  246.     {
  247.         $this->lastUpdate = $lastUpdate;
  249.         return $this;
  250.     }
  252.     public function getCreatedAt(): ?\DateTimeInterface
  253.     {
  254.         return $this->createdAt;
  255.     }
  257.     public function setCreatedAt(\DateTimeInterface $createdAt): self
  258.     {
  259.         $this->createdAt = $createdAt;
  261.         return $this;
  262.     }
  264.     /**
  265.      * @ORM\PrePersist()
  266.      */
  267.     public  function setDateOnPersist(){
  268.         $this->createdAt= new \DateTime();
  269.     }
  271.     /**
  272.      * @ORM\PreUpdate()
  273.      */
  274.     public  function setDateOnUpdate(){
  275.         $this->lastUpdate= new \DateTime();
  276.     }
  278.     public function getCreatedBy(): ?Users
  279.     {
  280.         return $this->createdBy;
  281.     }
  283.     public function setCreatedBy(?Users $createdBy): self
  284.     {
  285.         $this->createdBy = $createdBy;
  287.         return $this;
  288.     }
  290.     public function getTarget(): ?SymfonyFile
  291.     {
  292.         if($this->target){
  293.             $file = new SymfonyFile($this->target, false);
  294.             return $file;
  295.         }
  296.         return null;
  297.     }
  299.     public function setTarget($target)
  300.     {
  301.         if ($target){
  302.             $this->file = $target;
  303.             $this->source = $target->getClientOriginalName();
  304.             $fileName = $this->filename ?? Common::generateCode().Common::generateName().'.'. ( $target->guessExtension() ? $target->guessExtension() : $target->getClientOriginalExtension() );
  305.             $this->size = $target->getSize();
  306.             $this->mimetype = $target->getMimeType();
  307.             $this->previousTarget = $this->target;
  308.             $this->target = $fileName;
  309.             $this->formatSize = Common::prettySize($this->size);
  310.         }
  311.         return $this;
  312.     }
  314.     protected function getPrevFile(){
  315.         return $this->getRootDir().'/'.$this->previousTarget;
  316.     }
  318.     public function setFilename($filename){
  319.         $this->filename = $filename;
  320.         return $this;
  321.     }
  323.     public function getSize(): ?int
  324.     {
  325.         return $this->size;
  326.     }
  328.     public function setSize(?int $size): self
  329.     {
  330.         $this->size = $size;
  332.         return $this;
  333.     }
  335.     public function getFormatSize(): ?string
  336.     {
  337.         return $this->formatSize;
  338.     }
  340.     public function setFormatSize(?string $formatSize): self
  341.     {
  342.         $this->formatSize = $formatSize;
  344.         return $this;
  345.     }
  347.     public function getMimetype(): ?string
  348.     {
  349.         return $this->mimetype;
  350.     }
  352.     public function setMimetype(?string $mimetype): self
  353.     {
  354.         $this->mimetype = $mimetype;
  356.         return $this;
  357.     }
  359.     /**
  360.     * @ORM\PrePersist()
  361.     */
  362.     public function persistFile()
  363.     {
  364.         if ($this->file){
  365.             $this->file->move($this->getRootDir(), $this->target);
  366.             if($this->previousTarget && $this->previousTarget != $this->target){
  367.                 $previousFile = $this->getPrevFile();
  368.                 if(is_file($previousFile))
  369.                     unlink($previousFile);
  370.             }
  372.         }
  373.     }
  375.     /**
  376.     * @ORM\PostUpdate()
  377.     */
  378.     public function updateFile()
  379.     {
  380.         $this->persistFile();
  381.     }
  383.     /**
  384.     * @ORM\PreRemove()
  385.     */
  386.     public function deleteFile()
  387.     {
  388.         if(is_file($this->getFile()))
  389.             unlink($this->getFile());
  390.     }
  392.     /**
  393.      * @Assert\IsTrue(message = "Veuillez choisir des fichiers valides s'il vous plaît. Vérifiez également le MimeType.")
  394.      */
  395.     public function isValidMimetype()
  396.     {
  397.         return (!is_array($this->validsMimetypes) && (empty($this->validsMimetypes) || $this->validsMimetypes == '*'))
  398.             || (is_array($this->validsMimetypes) && !count($this->validsMimetypes))
  399.             || in_array($this->mimetype, $this->validsMimetypes)
  400.         ;
  401.     }
  403.     public function setValidsMimetypes(?array $mimetypes): self
  404.     {
  405.         $this->validsMimetypes = $mimetypes;
  406.         return $this;
  407.     }
  409.     public function getValidsMimetypes(): ?array
  410.     {
  411.         return $this->validsMimetypes;
  412.     }
  414.     public function __toString(){
  415.         return $this->getFile() ?? "";
  416.     }
  418.     public function serialize()
  419.     {
  420.         return serialize(array(
  421.             $this->id,
  422.             $this->name,
  423.             $this->target,
  424.         ));
  425.     }
  427.     public function unserialize($serialized)
  428.     {
  429.         list (
  430.             $this->id,
  431.             $this->name,
  432.             $this->target,
  433.         ) = unserialize($serialized);
  434.     }
  435. }