src/Entity/Club.php line 95

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use ApiPlatform\Core\Annotation\ApiResource;
  6. use App\Controller\Api\Ad\GetAdsFromClubController;
  7. use App\Controller\Api\Club\GetClubHomepageController;
  8. use App\Controller\Api\Club\GetClubLocalizeController;
  9. use App\Controller\Api\Club\GetClubWidgetController;
  10. use App\Controller\Api\Company\GetCompaniesFromClubController;
  11. use App\Controller\Api\Post\GetPostsFromClubController;
  12. use App\Controller\Api\User\GetUsersFromClubController;
  13. use App\Repository\ClubRepository;
  14. use Doctrine\Common\Collections\ArrayCollection;
  15. use Doctrine\Common\Collections\Collection;
  16. use Doctrine\DBAL\Types\Types;
  17. use Doctrine\ORM\Mapping as ORM;
  18. use Symfony\Component\Serializer\Annotation\Groups;
  19. use Symfony\Component\Validator\Constraints as Assert;
  21. #[ORM\Entity(repositoryClass: ClubRepository::class)]
  22. #[ApiResource(
  23.     itemOperations: [
  24.         'get',
  25.         'put',
  26.         'delete',
  27.         'get_companies' => [
  28.             'normalization_context' => [
  29.                 'groups' => 'read:club:collection:getCompanies',
  30.             ],
  31.             'controller' => GetCompaniesFromClubController::class,
  32.             'method' => 'POST',
  33.             'path' => '/public/clubs/{id}/companies',
  34.         ],
  35.         'get_club_localize' => [
  36.             'normalization_context' => [
  37.                 'groups' => 'read:club:collection:getClubLocalize',
  38.             ],
  39.             'controller' => GetClubLocalizeController::class,
  40.             'method' => 'POST',
  41.             'path' => '/public/localize',
  42.             'read' => false,
  43.         ],
  44.         'get_posts' => [
  45.             'normalization_context' => [
  46.                 'groups' => 'read:club:collection:getPosts',
  47.             ],
  48.             'controller' => GetPostsFromClubController::class,
  49.             'method' => 'POST',
  50.             'path' => '/public/clubs/{id}/posts',
  51.         ],
  52.         'get_widgets' => [
  53.             'normalization_context' => [
  54.                 'groups' => 'read:club:collection:getWidgets',
  55.             ],
  56.             'controller' => GetClubWidgetController::class,
  57.             'method' => 'POST',
  58.             'path' => '/public/clubs/{id}/widgets',
  59.         ],
  60.         'get_homepage' => [
  61.             'controller' => GetClubHomepageController::class,
  62.             'method' => 'POST',
  63.             'path' => '/public/clubs/{id}/homepage',
  64.             'read' => false,
  65.         ],
  66.         'get_ads' => [
  67.             'normalization_context' => [
  68.                 'groups' => 'read:club:collection:getAds',
  69.             ],
  70.             'controller' => GetAdsFromClubController::class,
  71.             'method' => 'POST',
  72.             'path' => '/public/clubs/{id}/ads',
  73.         ],
  74.         'post_alert' => [
  75.             'normalization_context' => [
  76.                 'groups' => 'read:club:collection:getUsers',
  77.             ],
  78.             'controller' => GetUsersFromClubController::class,
  79.             'method' => 'POST',
  80.             'path' => '/clubs/{id}/users',
  81.         ],
  82.         'get_users' => [
  83.             'normalization_context' => [
  84.                 'groups' => 'read:club:collection:getUsers',
  85.             ],
  86.             'controller' => GetUsersFromClubController::class,
  87.             'method' => 'POST',
  88.             'path' => '/clubs/{id}/users',
  89.         ],
  90.     ],
  91.     normalizationContext: [
  92.         'groups' => 'read:club:collection',
  93.     ]
  94. )]
  95. class Club
  96. {
  97.     #[ORM\Id]
  98.     #[ORM\GeneratedValue]
  99.     #[ORM\Column]
  100.     #[Groups([
  101.         'read:user:item:me',
  102.         'read:club:collection:getCompanies',
  103.         'read:club:collection',
  104.         'read:club:collection:getClubLocalize',
  105.         'read:company:collection:get',
  106.     ])]
  107.     private ?int $id = null;
  109.     #[ORM\Column(length: 255)]
  110.     #[Groups([
  111.         'read:user:item:me',
  112.         'read:club:collection:getCompanies',
  113.         'read:club:collection:getClubLocalize',
  114.         'read:company:collection:get',
  115.     ])]
  116.     #[Assert\Length(
  117.         max: 255,
  118.         maxMessage: "Le lien doit faire maximum 255 caractères.",
  119.     )]
  120.     private ?string $name = null;
  122.     #[ORM\OneToMany(mappedBy: 'club', targetEntity: Post::class, cascade: ["persist"])]
  123.     private Collection $posts;
  125.     #[ORM\OneToMany(mappedBy: 'club', targetEntity: Membership::class, cascade: ["persist"])]
  126.     private Collection $memberships;
  128.     #[ORM\OneToMany(mappedBy: 'club', targetEntity: Photo::class, cascade: ["persist"])]
  129.     private Collection $photos;
  131.     #[ORM\OneToMany(mappedBy: 'club', targetEntity: Ad::class)]
  132.     private Collection $ads;
  134.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  135.     private ?string $theme = null;
  137.     #[ORM\ManyToOne(inversedBy: 'clubs', cascade: ["remove"])]
  138.     #[ORM\JoinColumn(nullable: true, onDelete: "SET NULL")]
  139.     #[Groups([
  140.         'read:user:item:me',
  141.         'read:club:collection:getClubLocalize',
  142.     ])]
  143.     private ?Address $address = null;
  145.     #[Groups([
  146.         'read:user:item:me',
  147.         'read:club:collection:getClubLocalize',
  148.     ])]
  149.     private ?float $distance = null;
  151.     #[ORM\OneToMany(mappedBy: 'club', targetEntity: UserClub::class)]
  152.     private Collection $userClubs;
  154.     #[ORM\OneToMany(mappedBy: 'club', targetEntity: Widget::class)]
  155.     #[Groups([
  156.         'read:club:collection:getWidgets',
  157.     ])]
  158.     private Collection $widgets;
  160.     #[Groups([
  161.         'read:user:item:me',
  162.         'read:club:collection:getClubLocalize',
  163.     ])]
  164.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  165.     private ?string $homeMessage = null;
  167.     #[ORM\OneToMany(mappedBy: 'club', targetEntity: Deal::class)]
  168.     private Collection $deals;
  170.     #[ORM\OneToMany(mappedBy: 'club', targetEntity: ClubManager::class, cascade: ["persist"])]
  171.     private Collection $clubManagers;
  173.     #[ORM\OneToMany(mappedBy: 'club', targetEntity: Alert::class, orphanRemoval: true)]
  174.     private Collection $alerts;
  176.     #[ORM\OneToMany(mappedBy: 'club', targetEntity: ClubPresentation::class, orphanRemoval: true)]
  177.     private Collection $clubPresentations;
  179.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  180.     #[Groups([
  181.         'read:user:item:me',
  182.         'read:club:collection:getClubLocalize',
  183.     ])]
  184.     #[Assert\Url(
  185.         message: "Ce lien {{ value }} n'est pas un lien valide.",
  186.     )]
  187.     private ?string $website = null;
  189.     #[ORM\Column(length: 255, nullable: true)]
  190.     #[Groups([
  191.         'read:user:item:me',
  192.         'read:club:collection:getClubLocalize',
  193.     ])]
  194.     #[Assert\Regex(
  195.         pattern: '/^[0-9]{10}$/',
  196.         message: 'Doit être composé de 10 chiffres sans espace ni point'
  197.     )]
  198.     private ?string $phone = null;
  200.     #[ORM\Column(length: 255, nullable: true)]
  201.     #[Groups([
  202.         'read:user:item:me',
  203.         'read:club:collection:getClubLocalize',
  204.     ])]
  205.     #[Assert\Email(
  206.         message: "Cet Email {{ value }} n'est pas un email valide.",
  207.     )]
  208.     private ?string $email = null;
  210.     public function __construct()
  211.     {
  212.         $this->posts = new ArrayCollection();
  213.         $this->memberships = new ArrayCollection();
  214.         $this->photos = new ArrayCollection();
  215.         $this->ads = new ArrayCollection();
  216.         $this->userClubs = new ArrayCollection();
  217.         $this->widgets = new ArrayCollection();
  218.         $this->deals = new ArrayCollection();
  219.         $this->clubManagers = new ArrayCollection();
  220.         $this->alerts = new ArrayCollection();
  221.         $this->clubPresentations = new ArrayCollection();
  222.     }
  224.     public function __toString(): string
  225.     {
  226.         return $this->name;
  227.     }
  229.     public function getDistance(): ?float
  230.     {
  231.         return $this->distance;
  232.     }
  234.     public function setDistance(?float $distance): self
  235.     {
  236.         $this->distance = $distance;
  238.         return $this;
  239.     }
  241.     #[Groups([
  242.         'read:user:item:me',
  243.         'read:club:collection:getCompanies',
  244.         'read:club:collection:getClubLocalize',
  245.     ])]
  246.     public function getLogoUrl(): string
  247.     {
  248.         $mainPhoto = $this->getMainPhoto();
  249.         if ($mainPhoto) {
  250.             return $mainPhoto->getImageLarge()->getUrl();
  251.         }
  253.         return 'https://localbeez.ri7.fr/assets/img/image_placeholder.jpg';
  254.     }
  256.     public function getMainPhoto()
  257.     {
  258.         foreach ($this->photos as $p) {
  259.             if ($p->isMain()) {
  260.                 return $p;
  261.             }
  262.         }
  264.         if (sizeof($this->photos) > 0) {
  265.             return $this->photos[0];
  266.         }
  268.         return false;
  269.     }
  271.     #[Groups([
  272.         'read:user:item:me',
  273.         'read:club:collection:getClubLocalize',
  274.         'read:company:collection:get',
  275.     ])]
  276.     public function getSmallLogoUrl(): string
  277.     {
  278.         $mainPhoto = $this->getMainPhoto();
  279.         if ($mainPhoto) {
  280.             return $mainPhoto->getImageMedium()->getUrl();
  281.         }
  283.         return 'https://localbeez.ri7.fr/assets/img/image_placeholder.jpg';
  284.     }
  286.     #[Groups([
  287.         'read:user:item:me',
  288.     ])]
  289.     public function getMediumLogoUrl(): string
  290.     {
  291.         $mainPhoto = $this->getMainPhoto();
  292.         if ($mainPhoto) {
  293.             return $mainPhoto->getImageMedium()->getUrl();
  294.         }
  296.         return 'https://localbeez.ri7.fr/assets/img/image_placeholder.jpg';
  297.     }
  299.     #[Groups([
  300.         'read:user:item:me',
  301.         'read:club:collection:getClubLocalize',
  302.     ])]
  303.     public function getJsonTheme(): mixed
  304.     {
  305.         return json_decode($this->theme, true);
  306.     }
  308.     public function getId(): ?int
  309.     {
  310.         return $this->id;
  311.     }
  313.     public function getName(): ?string
  314.     {
  315.         return $this->name;
  316.     }
  318.     public function setName(string $name): self
  319.     {
  320.         $this->name = $name;
  322.         return $this;
  323.     }
  325.     /**
  326.      * @return Collection<int, Post>
  327.      */
  328.     public function getPosts(): Collection
  329.     {
  330.         return $this->posts;
  331.     }
  333.     public function addPost(Post $post): self
  334.     {
  335.         if (!$this->posts->contains($post)) {
  336.             $this->posts->add($post);
  337.             $post->setClub($this);
  338.         }
  340.         return $this;
  341.     }
  343.     public function removePost(Post $post): self
  344.     {
  345.         if ($this->posts->removeElement($post)) {
  346.             // set the owning side to null (unless already changed)
  347.             if ($post->getClub() === $this) {
  348.                 $post->setClub(null);
  349.             }
  350.         }
  352.         return $this;
  353.     }
  355.     /**
  356.      * @return Collection<int, Membership>
  357.      */
  358.     public function getMemberships(): Collection
  359.     {
  360.         return $this->memberships;
  361.     }
  363.     public function addMembership(Membership $membership): self
  364.     {
  365.         if (!$this->memberships->contains($membership)) {
  366.             $this->memberships->add($membership);
  367.             $membership->setClub($this);
  368.         }
  370.         return $this;
  371.     }
  373.     public function removeMembership(Membership $membership): self
  374.     {
  375.         if ($this->memberships->removeElement($membership)) {
  376.             // set the owning side to null (unless already changed)
  377.             if ($membership->getClub() === $this) {
  378.                 $membership->setClub(null);
  379.             }
  380.         }
  382.         return $this;
  383.     }
  385.     /**
  386.      * @return Collection<int, Photo>
  387.      */
  388.     public function getPhotos(): Collection
  389.     {
  390.         return $this->photos;
  391.     }
  393.     public function addPhoto(Photo $photo): self
  394.     {
  395.         if (!$this->photos->contains($photo)) {
  396.             $this->photos->add($photo);
  397.             $photo->setClub($this);
  398.         }
  400.         return $this;
  401.     }
  403.     public function removePhoto(Photo $photo): self
  404.     {
  405.         if ($this->photos->removeElement($photo)) {
  406.             // set the owning side to null (unless already changed)
  407.             if ($photo->getClub() === $this) {
  408.                 $photo->setClub(null);
  409.             }
  410.         }
  412.         return $this;
  413.     }
  415.     /**
  416.      * @return Collection<int, Ad>
  417.      */
  418.     public function getAds(): Collection
  419.     {
  420.         return $this->ads;
  421.     }
  423.     public function addAd(Ad $ad): self
  424.     {
  425.         if (!$this->ads->contains($ad)) {
  426.             $this->ads->add($ad);
  427.             $ad->setClub($this);
  428.         }
  430.         return $this;
  431.     }
  433.     public function removeAd(Ad $ad): self
  434.     {
  435.         if ($this->ads->removeElement($ad)) {
  436.             // set the owning side to null (unless already changed)
  437.             if ($ad->getClub() === $this) {
  438.                 $ad->setClub(null);
  439.             }
  440.         }
  442.         return $this;
  443.     }
  445.     public function getTheme(): mixed
  446.     {
  447.         return $this->theme;
  448.     }
  450.     public function setTheme(?string $theme): self
  451.     {
  452.         $this->theme = $theme;
  454.         return $this;
  455.     }
  457.     public function getAddress(): ?Address
  458.     {
  459.         return $this->address;
  460.     }
  462.     public function setAddress(?Address $address): self
  463.     {
  464.         $this->address = $address;
  466.         return $this;
  467.     }
  469.     /**
  470.      * @return Collection<int, UserClub>
  471.      */
  472.     public function getUserClubs(): Collection
  473.     {
  474.         return $this->userClubs;
  475.     }
  477.     public function addUserClub(UserClub $userClub): self
  478.     {
  479.         if (!$this->userClubs->contains($userClub)) {
  480.             $this->userClubs->add($userClub);
  481.             $userClub->setClub($this);
  482.         }
  484.         return $this;
  485.     }
  487.     public function removeUserClub(UserClub $userClub): self
  488.     {
  489.         if ($this->userClubs->removeElement($userClub)) {
  490.             // set the owning side to null (unless already changed)
  491.             if ($userClub->getClub() === $this) {
  492.                 $userClub->setClub(null);
  493.             }
  494.         }
  496.         return $this;
  497.     }
  499.     /**
  500.      * @return Collection<int, Widget>
  501.      */
  502.     public function getWidgets(): Collection
  503.     {
  504.         return $this->widgets;
  505.     }
  507.     public function addWidget(Widget $widget): self
  508.     {
  509.         if (!$this->widgets->contains($widget)) {
  510.             $this->widgets->add($widget);
  511.             $widget->setClub($this);
  512.         }
  514.         return $this;
  515.     }
  517.     public function removeWidget(Widget $widget): self
  518.     {
  519.         if ($this->widgets->removeElement($widget)) {
  520.             // set the owning side to null (unless already changed)
  521.             if ($widget->getClub() === $this) {
  522.                 $widget->setClub(null);
  523.             }
  524.         }
  526.         return $this;
  527.     }
  529.     public function getHomeMessage(): ?string
  530.     {
  531.         return $this->homeMessage;
  532.     }
  534.     public function setHomeMessage(?string $homeMessage): self
  535.     {
  536.         $this->homeMessage = $homeMessage;
  538.         return $this;
  539.     }
  541.     /**
  542.      * @return Collection<int, Deal>
  543.      */
  544.     public function getDeals(): Collection
  545.     {
  546.         return $this->deals;
  547.     }
  549.     public function addDeal(Deal $deal): self
  550.     {
  551.         if (!$this->deals->contains($deal)) {
  552.             $this->deals->add($deal);
  553.             $deal->setClub($this);
  554.         }
  556.         return $this;
  557.     }
  559.     public function removeDeal(Deal $deal): self
  560.     {
  561.         if ($this->deals->removeElement($deal)) {
  562.             // set the owning side to null (unless already changed)
  563.             if ($deal->getClub() === $this) {
  564.                 $deal->setClub(null);
  565.             }
  566.         }
  568.         return $this;
  569.     }
  571.     /**
  572.      * @return Collection<int, ClubManager>
  573.      */
  574.     public function getClubManagers(): Collection
  575.     {
  576.         return $this->clubManagers;
  577.     }
  579.     public function addClubManager(ClubManager $clubManager): static
  580.     {
  581.         if (!$this->clubManagers->contains($clubManager)) {
  582.             $this->clubManagers->add($clubManager);
  583.             $clubManager->setClub($this);
  584.         }
  586.         return $this;
  587.     }
  589.     public function removeClubManager(ClubManager $clubManager): static
  590.     {
  591.         if ($this->clubManagers->removeElement($clubManager)) {
  592.             // set the owning side to null (unless already changed)
  593.             if ($clubManager->getClub() === $this) {
  594.                 $clubManager->setClub(null);
  595.             }
  596.         }
  598.         return $this;
  599.     }
  601.     /**
  602.      * @return Collection<int, Alert>
  603.      */
  604.     public function getAlerts(): Collection
  605.     {
  606.         return $this->alerts;
  607.     }
  609.     public function addAlert(Alert $alert): static
  610.     {
  611.         if (!$this->alerts->contains($alert)) {
  612.             $this->alerts->add($alert);
  613.             $alert->setClub($this);
  614.         }
  616.         return $this;
  617.     }
  619.     public function removeAlert(Alert $alert): static
  620.     {
  621.         if ($this->alerts->removeElement($alert)) {
  622.             // set the owning side to null (unless already changed)
  623.             if ($alert->getClub() === $this) {
  624.                 $alert->setClub(null);
  625.             }
  626.         }
  628.         return $this;
  629.     }
  631.     /**
  632.      * @return Collection<int, ClubPresentation>
  633.      */
  634.     public function getClubPresentations(): Collection
  635.     {
  636.         return $this->clubPresentations;
  637.     }
  639.     public function addClubPresentation(ClubPresentation $clubPresentation): static
  640.     {
  641.         if (!$this->clubPresentations->contains($clubPresentation)) {
  642.             $this->clubPresentations->add($clubPresentation);
  643.             $clubPresentation->setClub($this);
  644.         }
  646.         return $this;
  647.     }
  649.     public function removeClubPresentation(ClubPresentation $clubPresentation): static
  650.     {
  651.         if ($this->clubPresentations->removeElement($clubPresentation)) {
  652.             // set the owning side to null (unless already changed)
  653.             if ($clubPresentation->getClub() === $this) {
  654.                 $clubPresentation->setClub(null);
  655.             }
  656.         }
  658.         return $this;
  659.     }
  661.     public function getWebsite(): ?string
  662.     {
  663.         return $this->website;
  664.     }
  666.     public function setWebsite(?string $website): static
  667.     {
  668.         $this->website = $website;
  670.         return $this;
  671.     }
  673.     public function getPhone(): ?string
  674.     {
  675.         return $this->phone;
  676.     }
  678.     public function setPhone(?string $phone): static
  679.     {
  680.         $this->phone = $phone;
  682.         return $this;
  683.     }
  685.     public function getEmail(): ?string
  686.     {
  687.         return $this->email;
  688.     }
  690.     public function setEmail(?string $email): static
  691.     {
  692.         $this->email = $email;
  694.         return $this;
  695.     }
  696. }