src/Entity/Posts/Categorieposts.php line 25

Open in your IDE?
  1. <?php
  3. namespace App\Entity\Posts;
  5. use DateTime;
  6. use DateTimeImmutable;
  7. use Doctrine\Common\Collections\ArrayCollection;
  8. use Doctrine\Common\Collections\Collection;
  9. use Doctrine\ORM\Mapping as ORM;
  10. use Doctrine\ORM\Mapping\Table;
  11. use Exception;
  12. use Gedmo\Mapping\Annotation as Gedmo;
  13. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  14. use Symfony\Component\HttpFoundation\File\File;
  15. use Symfony\Component\HttpFoundation\File\UploadedFile;
  16. use Vich\UploaderBundle\Mapping\Annotation as Vich;
  17. use Symfony\Component\Validator\Constraints as Assert;
  19. /**
  20.  * @ORM\Entity(repositoryClass="App\Repository\Posts\CategoriepostsRepository")
  21.  * @Table (name="categorieposts")
  22.  * @UniqueEntity("name")
  23.  * @Vich\Uploadable
  24.  */
  25. class Categorieposts
  26. {
  27.     const MENU = [
  28.         0 => "OU DORMIR",
  29.         1 => "OU ALLER",
  30.         2 => "OU MANGER",
  31.         3 => "LOCATION",
  32.     ];
  34.     /**
  35.      * @ORM\Id()
  36.      * @ORM\GeneratedValue()
  37.      * @ORM\Column(type="integer")
  38.      */
  39.     private $id;
  41.     /**
  42.      * @ORM\Column(type="string", length=255)
  43.      * @Assert\NotBlank(message="Veuillez saisir le nom de la catégorie")
  44.      */
  45.     private $name;
  47.     /**
  48.      * @ORM\Column(type="string", length=255)
  49.      * @Gedmo\Slug(fields={"name"})
  50.      */
  51.     private $slug;
  53.     /**
  54.      * @ORM\Column(type="text", nullable=true)
  55.      */
  56.     private $description;
  58.     /**
  59.      * NOTE: This is not a mapped field of entity metadata, just a simple property.
  60.      *
  61.      * @Vich\UploadableField(mapping="categories_image", fileNameProperty="filename")
  62.      * @var File|null
  63.      * @Assert\Image(
  64.      *     mimeTypes={"image/jpeg", "image/png"},
  65.      *
  66.      *     maxHeight=982,
  67.      *     maxWidth=1920,
  68.      *     maxHeightMessage="Votre image doit faire 982 d'hauteur",
  69.      *     maxWidthMessage="Votre image doit faire 1920 de largeur"
  70.      * )
  71.      */
  72.     private $imageFile;
  74.     /**
  75.      * @ORM\Column(type="string", length=255, nullable=true)
  76.      */
  77.     private $filename;
  79.     /**
  80.      * NOTE: This is not a mapped field of entity metadata, just a simple property.
  81.      *
  82.      * @Vich\UploadableField(mapping="categories_image", fileNameProperty="filenamecover")
  83.      * @var File|null
  84.      * @Assert\Image(
  85.      *     mimeTypes={"image/jpeg", "image/png"},
  86.      *     maxHeight=1280,
  87.      *     maxWidth=1920,
  88.      *     maxHeightMessage="Votre image doit faire 1280 d'hauteur",
  89.      *     maxWidthMessage="Votre image doit faire 1920 de largeur"
  90.      * )
  91.      */
  92.     private $imageCover;
  94.     /**
  95.      * @ORM\Column(type="string", length=255, nullable=true)
  96.      */
  97.     private $filenamecover;
  99.     /**
  100.      * NOTE: This is not a mapped field of entity metadata, just a simple property.
  101.      *
  102.      * @Vich\UploadableField(mapping="documents_files", fileNameProperty="documents")
  103.      * @var File|null
  104.      * @Assert\File(
  105.      *     mimeTypes={"application/pdf", "application/x-pdf"}
  106.      * )
  107.      */
  108.     private $documentsFile;
  110.     /**
  111.      * @var string|null
  112.      * @ORM\Column(type="string", length=255, nullable=true)
  113.      */
  114.     private $documents;
  116.     /**
  117.      * NOTE: This is not a mapped field of entity metadata, just a simple property.
  118.      *
  119.      * @Vich\UploadableField(mapping="categories_image", fileNameProperty="documentcover")
  120.      * @var File|null
  121.      * @Assert\Image(
  122.      *     mimeTypes={"image/jpeg", "image/png"},
  123.      *     maxHeight=500,
  124.      *     maxWidth=500,
  125.      *     maxHeightMessage="Votre image doit faire 500 d'hauteur",
  126.      *     maxWidthMessage="Votre image doit faire 500 de largeur"
  127.      * )
  128.      */
  129.     private $fileCover;
  131.     /**
  132.      * @ORM\Column(type="string", length=255, nullable=true)
  133.      */
  134.     private $documentcover;
  136.     /**
  137.      * @ORM\Column(type="integer", nullable=true, options={"default": 0})
  138.      */
  139.     private $ordre;
  141.     /**
  142.      * @ORM\Column(type="boolean", nullable=true)
  143.      */
  144.     private $online;
  146.     /**
  147.      * @ORM\Column(type="integer")
  148.      */
  149.     private $menu;
  151.     /**
  152.      * @var DateTime $updatedAt
  153.      * @ORM\Column(type="datetime", nullable=true)
  154.      *
  155.      * @Gedmo\Timestampable(on="update")
  156.      */
  157.     private $updatedAt;
  159.     /**
  160.      * @ORM\OneToMany(targetEntity="App\Entity\Posts\Posts", mappedBy="categories")
  161.      */
  162.     private $posts;
  164.     /**
  165.      * @ORM\Column(type="string", length=255, nullable=true)
  166.      */
  167.     private $role;
  169.     public function __construct()
  170.     {
  171.         $this->posts = new ArrayCollection();
  172.     }
  174.     public function getId(): ?int
  175.     {
  176.         return $this->id;
  177.     }
  179.     public function getName(): ?string
  180.     {
  181.         return $this->name;
  182.     }
  184.     public function setName(string $name): self
  185.     {
  186.         $this->name = $name;
  188.         return $this;
  189.     }
  191.     public function getSlug(): ?string
  192.     {
  193.         return $this->slug;
  194.     }
  196.     public function getDescription(): ?string
  197.     {
  198.         return $this->description;
  199.     }
  201.     public function setDescription(?string $description): self
  202.     {
  203.         $this->description = $description;
  205.         return $this;
  206.     }
  208.     /**
  209.      * @return File|null
  210.      */
  211.     public function getImageFile(): ?File
  212.     {
  213.         return $this->imageFile;
  214.     }
  216.     /**
  217.      * @param File|null $imageFile
  218.      * @return Categorieposts
  219.      * @throws Exception
  220.      */
  221.     public function setImageFile(?File $imageFile): Categorieposts
  222.     {
  223.         $this->imageFile = $imageFile;
  224.         if ($this->imageFile instanceof UploadedFile) {
  225.             // It is required that at least one field changes if you are using doctrine
  226.             // otherwise the event listeners won't be called and the file is lost
  227.             $this->updatedAt = new DateTimeImmutable('now');
  228.         }
  229.         return $this;
  230.     }
  232.     public function getFilename(): ?string
  233.     {
  234.         return $this->filename;
  235.     }
  237.     public function setFilename(?string $filename): self
  238.     {
  239.         $this->filename = $filename;
  241.         return $this;
  242.     }
  244.     /**
  245.      * @return File|null
  246.      */
  247.     public function getImageCover(): ?File
  248.     {
  249.         return $this->imageCover;
  250.     }
  252.     /**
  253.      * @param File|null $imageCover
  254.      * @return Categorieposts
  255.      * @throws Exception
  256.      */
  257.     public function setImageCover(?File $imageCover): Categorieposts
  258.     {
  259.         $this->imageCover = $imageCover;
  260.         if ($this->imageCover instanceof UploadedFile) {
  261.             // It is required that at least one field changes if you are using doctrine
  262.             // otherwise the event listeners won't be called and the file is lost
  263.             $this->updatedAt = new DateTimeImmutable('now');
  264.         }
  265.         return $this;
  266.     }
  268.     public function getFilenamecover(): ?string
  269.     {
  270.         return $this->filenamecover;
  271.     }
  273.     public function setFilenamecover(?string $filenamecover): self
  274.     {
  275.         $this->filenamecover = $filenamecover;
  277.         return $this;
  278.     }
  280.     public function getOrdre(): ?int
  281.     {
  282.         return $this->ordre;
  283.     }
  285.     public function setOrdre(int $ordre): self
  286.     {
  287.         $this->ordre = $ordre;
  289.         return $this;
  290.     }
  292.     public function getMenu(): ?int
  293.     {
  294.         return $this->menu;
  295.     }
  297.     public function setMenu(int $menu): self
  298.     {
  299.         $this->menu = $menu;
  301.         return $this;
  302.     }
  304.     public function getMenuType(): string {
  305.         return self::MENU[$this->menu];
  306.     }
  308.     public function getUpdatedAt(): ?\DateTimeInterface
  309.     {
  310.         return $this->updatedAt;
  311.     }
  313.     public function __toString()
  314.     {
  315.         return $this->name;
  316.     }
  318.     /**
  319.      * @return Collection|Posts[]
  320.      */
  321.     public function getPosts(): Collection
  322.     {
  323.         return $this->posts;
  324.     }
  326.     public function addPost(Posts $post): self
  327.     {
  328.         if (!$this->posts->contains($post)) {
  329.             $this->posts[] = $post;
  330.             $post->setCategories($this);
  331.         }
  333.         return $this;
  334.     }
  336.     public function removePost(Posts $post): self
  337.     {
  338.         if ($this->posts->contains($post)) {
  339.             $this->posts->removeElement($post);
  340.             // set the owning side to null (unless already changed)
  341.             if ($post->getCategories() === $this) {
  342.                 $post->setCategories(null);
  343.             }
  344.         }
  346.         return $this;
  347.     }
  349.     public function getRole(): ?string
  350.     {
  351.         return $this->role;
  352.     }
  354.     public function setRole(?string $role): self
  355.     {
  356.         $this->role = $role;
  358.         return $this;
  359.     }
  361.     /**
  362.      * @return mixed
  363.      */
  364.     public function getOnline()
  365.     {
  366.         return $this->online;
  367.     }
  369.     /**
  370.      * @param mixed $online
  371.      * @return Categorieposts
  372.      */
  373.     public function setOnline($online): Categorieposts
  374.     {
  375.         $this->online = $online;
  376.         return $this;
  377.     }
  379.     /**
  380.      * @return File|null
  381.      */
  382.     public function getDocumentsFile(): ?File
  383.     {
  384.         return $this->documentsFile;
  385.     }
  387.     /**
  388.      * @param File|null $documentsFile
  389.      * @return Categorieposts
  390.      * @throws Exception
  391.      */
  392.     public function setDocumentsFile(?File $documentsFile): Categorieposts
  393.     {
  394.         $this->documentsFile = $documentsFile;
  395.         if ($this->documentsFile instanceof UploadedFile) {
  396.             // It is required that at least one field changes if you are using doctrine
  397.             // otherwise the event listeners won't be called and the file is lost
  398.             $this->updatedAt = new DateTimeImmutable('now');
  399.         }
  400.         return $this;
  401.     }
  403.     public function getDocuments(): ?string
  404.     {
  405.         return $this->documents;
  406.     }
  408.     public function setDocuments(string $documents): self
  409.     {
  410.         $this->documents = $documents;
  412.         return $this;
  413.     }
  415.     /**
  416.      * @return File|null
  417.      */
  418.     public function getFileCover(): ?File
  419.     {
  420.         return $this->fileCover;
  421.     }
  423.     /**
  424.      * @param File|null $fileCover
  425.      * @return Categorieposts
  426.      * @throws Exception
  427.      */
  428.     public function setFileCover(?File $fileCover): Categorieposts
  429.     {
  430.         $this->fileCover = $fileCover;
  431.         if ($this->fileCover instanceof UploadedFile) {
  432.             // It is required that at least one field changes if you are using doctrine
  433.             // otherwise the event listeners won't be called and the file is lost
  434.             $this->updatedAt = new DateTimeImmutable('now');
  435.         }
  436.         return $this;
  437.     }
  439.     public function getDocumentcover(): ?string
  440.     {
  441.         return $this->documentcover;
  442.     }
  444.     public function setDocumentcover(string $documentcover): self
  445.     {
  446.         $this->documentcover = $documentcover;
  448.         return $this;
  449.     }
  450. }