src/Entity/Media.php line 20

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use Doctrine\Common\Collections\ArrayCollection;
  6. use Doctrine\Common\Collections\Collection;
  7. use Doctrine\ORM\Mapping as ORM;
  9. use App\Repository\MediaRepository;
  10. use Gedmo\Mapping\Annotation as Gedmo;
  11. use Symfony\Component\Validator\Constraints as Assert;
  12. use Symfony\Component\HttpFoundation\File\File;
  13. use Vich\UploaderBundle\Mapping\Annotation as Vich;
  16. /**
  17.  * @ORM\Entity(repositoryClass=MediaRepository::class)
  18.  * @Vich\Uploadable
  19.  */
  20. class Media
  21. {
  22.     const ROLES = [
  23.         // label => value (first is default)
  24.         "document" => "document",
  25.         "miniature" => "thumbnail",
  26.         "diapositive" => "slide",
  27.     ];
  29.     const TYPES = [
  30.         // label => value 
  31.         "article" => "article",
  32.         "évènement" => "event",
  33.         "newsletter" => "newsletter",
  34.         "page" => "page",
  35.         "question-rep" => "questionAnswer",
  36.         "structure" => "structure",
  37.         "thème" => "theme",
  38.     ];
  39.     
  40.     /**
  41.      * @ORM\Id()
  42.      * @ORM\GeneratedValue()
  43.      * @ORM\Column(type="integer")
  44.      */
  45.     private $id;
  46.     
  47.     /**
  48.      * @ORM\Column(type="integer", nullable=true)
  49.      */
  50.     protected $tmpOldId;
  52.     /**
  53.      * NOTE: This is not a mapped field of entity metadata, just a simple property.
  54.      * 
  55.      * @Vich\UploadableField(mapping="medias", fileNameProperty="name", size="size")
  56.      * 
  57.      * @var File|null
  58.      */
  59.     private $file;
  61.     /**
  62.      * @ORM\Column(type="string", length=200)
  63.      *
  64.      * @var string|null
  65.      */
  66.     private $name;
  68.     /**
  69.      * @ORM\Column(type="string")
  70.      *
  71.      * @var string|null
  72.      */
  73.     private $description = "";
  75.     /**
  76.      * @ORM\Column(type="integer")
  77.      *
  78.      * @var int|null
  79.      */
  80.     private $size;
  82.     /**
  83.      * @ORM\Column(type="string", length=255, nullable=true)
  84.      *
  85.      * @var string|null
  86.      */
  87.     private $role;
  89.     /**
  90.      * @ORM\Column(type="array", length=255)
  91.      *
  92.      * @var array|null
  93.      */
  94.     private $types;
  95.             
  96.     /**
  97.      * @var \DateTime $createdAt
  98.      *
  99.      * @Gedmo\Timestampable(on="create")
  100.      * @ORM\Column(type="datetime", nullable=true)
  101.      */
  102.     private $createdAt;
  104.     /**
  105.      * @ORM\Column(type="datetime")
  106.      *
  107.      * @var \DateTimeInterface|null
  108.      */
  109.     private $updatedAt;
  111.     /* relations */
  114.     /**
  115.      * @ORM\ManyToMany(targetEntity="App\Entity\Article", inversedBy="medias", cascade={"persist"})
  116.      */
  117.     private $articles;
  119.     /**
  120.      * @ORM\ManyToMany(targetEntity="App\Entity\Event", inversedBy="medias", cascade={"persist"})
  121.      */
  122.     private $events;
  124.     /**
  125.      * @ORM\ManyToMany(targetEntity="App\Entity\Newsletter", inversedBy="medias", cascade={"persist"})
  126.      */
  127.     private $newsletters;
  129.     /**
  130.      * @ORM\ManyToMany(targetEntity="App\Entity\Page", inversedBy="medias", cascade={"persist"})
  131.      */
  132.     private $pages;
  134.     /**
  135.      * @ORM\ManyToMany(targetEntity="App\Entity\QuestionAnswer", inversedBy="medias", cascade={"persist"})
  136.      */
  137.     private $questionAnswers;
  139.     /**
  140.      * @ORM\ManyToMany(targetEntity="App\Entity\Structure", inversedBy="medias", cascade={"persist"})
  141.      */
  142.     private $structures;
  144.     /**
  145.      * @ORM\OneToOne(targetEntity="App\Entity\Theme", inversedBy="picto", cascade={"persist"})
  146.      * @ORM\JoinColumn(name="picto_theme", referencedColumnName="id")
  147.      */
  148.     private $theme;
  151.     public function __construct()
  152.     {
  153.         $this->updatedAt = new \DateTime();
  154.         $this->types = [];
  155.           $this->articles = new ArrayCollection();
  156.         $this->events = new ArrayCollection();
  157.         $this->newsletters = new ArrayCollection();
  158.         $this->pages = new ArrayCollection();
  159.         $this->questionAnswers = new ArrayCollection();
  160.         $this->structures = new ArrayCollection();
  161.     }
  163.     public function __toString()
  164.     {
  165.         return $this->name;
  166.     }
  168.     public static function getMimeType($ext){
  169.         $ext = strtolower($ext);
  170.         if (!(strpos($ext, '.') !== false)) {
  171.             $ext = '.' . $ext ;
  172.         }
  173.         switch ($ext) {
  174.             case '.aac': $mime ='audio/aac'; break; // AAC audio
  175.             case '.abw': $mime ='application/x-abiword'; break; // AbiWord document
  176.             case '.arc': $mime ='application/octet-stream'; break; // Archive document (multiple files embedded)
  177.             case '.avi': $mime ='video/x-msvideo'; break; // AVI: Audio Video Interleave
  178.             case '.azw': $mime ='application/vnd.amazon.ebook'; break; // Amazon Kindle eBook format
  179.             case '.bin': $mime ='application/octet-stream'; break; // Any kind of binary data
  180.             case '.bmp': $mime ='image/bmp'; break; // Windows OS/2 Bitmap Graphics
  181.             case '.bz': $mime ='application/x-bzip'; break; // BZip archive
  182.             case '.bz2': $mime ='application/x-bzip2'; break; // BZip2 archive
  183.             case '.csh': $mime ='application/x-csh'; break; // C-Shell script
  184.             case '.css': $mime ='text/css'; break; // Cascading Style Sheets (CSS)
  185.             case '.csv': $mime ='text/csv'; break; // Comma-separated values (CSV)
  186.             case '.doc': $mime ='application/msword'; break; // Microsoft Word
  187.             case '.docx': $mime ='application/vnd.openxmlformats-officedocument.wordprocessingml.document'; break; // Microsoft Word (OpenXML)
  188.             case '.eot': $mime ='application/vnd.ms-fontobject'; break; // MS Embedded OpenType fonts
  189.             case '.epub': $mime ='application/epub+zip'; break; // Electronic publication (EPUB)
  190.             case '.gif': $mime ='image/gif'; break; // Graphics Interchange Format (GIF)
  191.             case '.htm': $mime ='text/html'; break; // HyperText Markup Language (HTML)
  192.             case '.html': $mime ='text/html'; break; // HyperText Markup Language (HTML)
  193.             case '.ico': $mime ='image/x-icon'; break; // Icon format
  194.             case '.ics': $mime ='text/calendar'; break; // iCalendar format
  195.             case '.jar': $mime ='application/java-archive'; break; // Java Archive (JAR)
  196.             case '.jpeg': $mime ='image/jpeg'; break; // JPEG images
  197.             case '.jpg': $mime ='image/jpeg'; break; // JPEG images
  198.             case '.js': $mime ='application/javascript'; break; // JavaScript (IANA Specification) (RFC 4329 Section 8.2)
  199.             case '.json': $mime ='application/json'; break; // JSON format
  200.             case '.mid': $mime ='audio/midi audio/x-midi'; break; // Musical Instrument Digital Interface (MIDI)
  201.             case '.midi': $mime ='audio/midi audio/x-midi'; break; // Musical Instrument Digital Interface (MIDI)
  202.             case '.mpeg': $mime ='video/mpeg'; break; // MPEG Video
  203.             case '.mpkg': $mime ='application/vnd.apple.installer+xml'; break; // Apple Installer Package
  204.             case '.odp': $mime ='application/vnd.oasis.opendocument.presentation'; break; // OpenDocument presentation document
  205.             case '.ods': $mime ='application/vnd.oasis.opendocument.spreadsheet'; break; // OpenDocument spreadsheet document
  206.             case '.odt': $mime ='application/vnd.oasis.opendocument.text'; break; // OpenDocument text document
  207.             case '.oga': $mime ='audio/ogg'; break; // OGG audio
  208.             case '.ogv': $mime ='video/ogg'; break; // OGG video
  209.             case '.ogx': $mime ='application/ogg'; break; // OGG
  210.             case '.otf': $mime ='font/otf'; break; // OpenType font
  211.             case '.png': $mime ='image/png'; break; // Portable Network Graphics
  212.             case '.pdf': $mime ='application/pdf'; break; // Adobe Portable Document Format (PDF)
  213.             case '.ppt': $mime ='application/vnd.ms-powerpoint'; break; // Microsoft PowerPoint
  214.             case '.pptx': $mime ='application/vnd.openxmlformats-officedocument.presentationml.presentation'; break; // Microsoft PowerPoint (OpenXML)
  215.             case '.rar': $mime ='application/x-rar-compressed'; break; // RAR archive
  216.             case '.rtf': $mime ='application/rtf'; break; // Rich Text Format (RTF)
  217.             case '.sh': $mime ='application/x-sh'; break; // Bourne shell script
  218.             case '.svg': $mime ='image/svg+xml'; break; // Scalable Vector Graphics (SVG)
  219.             case '.swf': $mime ='application/x-shockwave-flash'; break; // Small web format (SWF) or Adobe Flash document
  220.             case '.tar': $mime ='application/x-tar'; break; // Tape Archive (TAR)
  221.             case '.tif': $mime ='image/tiff'; break; // Tagged Image File Format (TIFF)
  222.             case '.tiff': $mime ='image/tiff'; break; // Tagged Image File Format (TIFF)
  223.             case '.ts': $mime ='application/typescript'; break; // Typescript file
  224.             case '.ttf': $mime ='font/ttf'; break; // TrueType Font
  225.             case '.txt': $mime ='text/plain'; break; // Text, (generally ASCII or ISO 8859-n)
  226.             case '.vsd': $mime ='application/vnd.visio'; break; // Microsoft Visio
  227.             case '.wav': $mime ='audio/wav'; break; // Waveform Audio Format
  228.             case '.weba': $mime ='audio/webm'; break; // WEBM audio
  229.             case '.webm': $mime ='video/webm'; break; // WEBM video
  230.             case '.webp': $mime ='image/webp'; break; // WEBP image
  231.             case '.woff': $mime ='font/woff'; break; // Web Open Font Format (WOFF)
  232.             case '.woff2': $mime ='font/woff2'; break; // Web Open Font Format (WOFF)
  233.             case '.xhtml': $mime ='application/xhtml+xml'; break; // XHTML
  234.             case '.xls': $mime ='application/vnd.ms-excel'; break; // Microsoft Excel
  235.             case '.xlsx': $mime ='application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'; break; // Microsoft Excel (OpenXML)
  236.             case '.xml': $mime ='application/xml'; break; // XML
  237.             case '.xul': $mime ='application/vnd.mozilla.xul+xml'; break; // XUL
  238.             case '.zip': $mime ='application/zip'; break; // ZIP archive
  239.             case '.3gp': $mime ='video/3gpp'; break; // 3GPP audio/video container
  240.             case '.3g2': $mime ='video/3gpp2'; break; // 3GPP2 audio/video container
  241.             case '.7z': $mime ='application/x-7z-compressed'; break; // 7-zip archive
  242.             default: $mime = 'application/octet-stream' ; // general purpose MIME-type
  243.         }
  244.         return $mime ;    
  245.     }
  248.     public function getId(): ?int
  249.     {
  250.         return $this->id;
  251.     }
  253.     public function setId($id)
  254.     {
  255.         $this->id = $id;
  257.         return $this;
  258.     }
  259.     
  260.     public function getTmpOldId(): ?int
  261.     {
  262.         return $this->tmpOldId;
  263.     }
  265.     public function setTmpOldId(?int $tmpOldId): self
  266.     {
  267.         $this->tmpOldId = $tmpOldId;
  269.         return $this;
  270.     }
  272.     /**
  273.      * If manually uploading a file (i.e. not using Symfony Form) ensure an instance
  274.      * of 'UploadedFile' is injected into this setter to trigger the update. If this
  275.      * bundle's configuration parameter 'inject_on_load' is set to 'true' this setter
  276.      * must be able to accept an instance of 'File' as the bundle will inject one here
  277.      * during Doctrine hydration.
  278.      *
  279.      * @param File|\Symfony\Component\HttpFoundation\File\UploadedFile|null $file
  280.      */
  281.     public function setFile(?File $file = null): void
  282.     {
  283.         $this->file = $file;
  284.         
  285.         if (null !== $file) {
  286.             // It is required that at least one field changes if you are using doctrine
  287.             // otherwise the event listeners won't be called and the file is lost
  288.             $this->updatedAt = new \DateTimeImmutable();
  289.         }
  290.     }
  292.     public function getFile(): ?File
  293.     {
  294.         return $this->file;
  295.     }
  297.     public function setName(?string $name): void
  298.     {
  299.         $this->name = $name;
  300.     }
  302.     public function getName(): ?string
  303.     {
  304.         return $this->name;
  305.     }
  307.     public function setDescription(?string $description): void
  308.     {
  309.         $this->description = $description;
  310.     }
  312.     public function getDescription(): ?string
  313.     {
  314.         if($this->description !== "") {
  315.             return $this->description;
  316.         } else {
  317.             return $this->name;
  318.         }
  319.     }
  320.     
  321.     public function setSize(?int $size): void
  322.     {
  323.         $this->size = $size;
  324.     }
  326.     public function getSize(): ?int
  327.     {
  328.         return $this->size;
  329.     }
  331.     public function getCreatedAt(): ?\DateTimeInterface
  332.     {
  333.         return $this->createdAt;
  334.     }
  336.     public function setCreatedAt(?\DateTimeInterface $createdAt): self
  337.     {
  338.         $this->createdAt = $createdAt;
  340.         return $this;
  341.     }
  343.     public function getUpdatedAt(): ?\DateTimeInterface
  344.     {
  345.         return $this->updatedAt;
  346.     }
  348.     public function setUpdatedAt(\DateTimeInterface $updatedAt): self
  349.     {
  350.         $this->updatedAt = $updatedAt;
  352.         return $this;
  353.     }
  355.     public function getRole(): ?string
  356.     {
  357.         return $this->role;
  358.     }
  360.     public function setRole(string $role): self
  361.     {
  362.         if(! in_array($role, self::ROLES) ) $role = array_values(self::ROLES)[0];
  363.         $this->role = $role;
  365.         return $this;
  366.     }
  368.     public function getTypes(): ?array
  369.     {
  370.         return $this->types;
  371.     }
  373.     public function setTypes(array $types): self
  374.     {
  375.         $this->types = $types;
  377.         return $this;
  378.     }
  379.     
  381.     /**
  382.      * @return Collection|Article[]
  383.      */
  384.     public function getArticles(): Collection
  385.     {
  386.         return $this->articles;
  387.     }
  389.     public function addArticle(Article $article): self
  390.     {
  391.         if (!$this->articles->contains($article)) {
  392.             $this->articles[] = $article;
  393.         }
  394.         $type = "article";
  395.         if (! in_array($type, $this->types) ) {
  396.             $this->types[] = $type;
  397.         }
  398.         return $this;
  399.     }
  401.     public function removeArticle(Article $article): self
  402.     {
  403.         if ($this->articles->contains($article)) {
  404.             $this->articles->removeElement($article);
  405.         }
  407.         return $this;
  408.     }
  410.     /**
  411.      * @return Collection|Event[]
  412.      */
  413.     public function getEvents(): Collection
  414.     {
  415.         return $this->events;
  416.     }
  418.     public function addEvent(Event $event): self
  419.     {
  420.         if (!$this->events->contains($event)) {
  421.             $this->events[] = $event;
  422.         }
  423.         $type = "event";
  424.         if (! in_array($type, $this->types) ) {
  425.             $this->types[] = $type;
  426.         }
  428.         return $this;
  429.     }
  431.     public function removeEvent(Event $event): self
  432.     {
  433.         if ($this->events->contains($event)) {
  434.             $this->events->removeElement($event);
  435.         }
  437.         return $this;
  438.     }
  440.     /**
  441.      * @return Collection|Newsletter[]
  442.      */
  443.     public function getNewsletters(): Collection
  444.     {
  445.         return $this->newsletters;
  446.     }
  448.     public function addNewsletter(Newsletter $newsletter): self
  449.     {
  450.         if (!$this->newsletters->contains($newsletter)) {
  451.             $this->newsletters[] = $newsletter;
  452.         }
  453.         $type = "newsletter";
  454.         if (! in_array($type, $this->types) ) {
  455.             $this->types[] = $type;
  456.         }
  458.         return $this;
  459.     }
  461.     public function removeNewsletter(Newsletter $newsletter): self
  462.     {
  463.         if ($this->newsletters->contains($newsletter)) {
  464.             $this->newsletters->removeElement($newsletter);
  465.         }
  467.         return $this;
  468.     }
  470.     /**
  471.      * @return Collection|Page[]
  472.      */
  473.     public function getPages(): Collection
  474.     {
  475.         return $this->pages;
  476.     }
  478.     public function addPage(Page $page): self
  479.     {
  480.         if (!$this->pages->contains($page)) {
  481.             $this->pages[] = $page;
  482.         }
  483.         $type = "page";
  484.         if (! in_array($type, $this->types) ) {
  485.             $this->types[] = $type;
  486.         }
  488.         return $this;
  489.     }
  491.     public function removePage(Page $page): self
  492.     {
  493.         if ($this->pages->contains($page)) {
  494.             $this->pages->removeElement($page);
  495.         }
  497.         return $this;
  498.     }
  500.     /**
  501.      * @return Collection|QuestionAnswer[]
  502.      */
  503.     public function getQuestionAnswers(): Collection
  504.     {
  505.         return $this->questionAnswers;
  506.     }
  508.     public function addQuestionAnswer(QuestionAnswer $questionAnswer): self
  509.     {
  510.         if (!$this->questionAnswers->contains($questionAnswer)) {
  511.             $this->questionAnswers[] = $questionAnswer;
  512.         }
  513.         $type = "questionAnswer";
  514.         if (! in_array($type, $this->types) ) {
  515.             $this->types[] = $type;
  516.         }
  518.         return $this;
  519.     }
  521.     public function removeQuestionAnswer(QuestionAnswer $questionAnswer): self
  522.     {
  523.         if ($this->questionAnswers->contains($questionAnswer)) {
  524.             $this->questionAnswers->removeElement($questionAnswer);
  525.         }
  527.         return $this;
  528.     }
  530.     /**
  531.      * @return Collection|Structure[]
  532.      */
  533.     public function getStructures(): Collection
  534.     {
  535.         return $this->structures;
  536.     }
  538.     public function addStructure(Structure $structure): self
  539.     {
  540.         if (!$this->structures->contains($structure)) {
  541.             $this->structures[] = $structure;
  542.         }
  543.         $type = "structure";
  544.         if (! in_array($type, $this->types) ) {
  545.             $this->types[] = $type;
  546.         }
  548.         return $this;
  549.     }
  551.     public function removeStructure(Structure $structure): self
  552.     {
  553.         if ($this->structures->contains($structure)) {
  554.             $this->structures->removeElement($structure);
  555.         }
  557.         return $this;
  558.     }
  560.     public function getTheme(): ?Theme
  561.     {
  562.         return $this->theme;
  563.     }
  565.     public function setTheme(?Theme $theme): self
  566.     {
  567.         $this->theme = $theme;
  568.         $type = "theme";
  569.         if (! in_array($type, $this->types) ) {
  570.             $this->types[] = $type;
  571.         }
  573.         return $this;
  574.     }
  576. }