src/Entity/Tenant/Subscription.php line 48

  1. <?php
  3. namespace App\Entity\Tenant;
  5. use ApiPlatform\Metadata\ApiFilter;
  6. use ApiPlatform\Metadata\ApiProperty;
  7. use ApiPlatform\Metadata\ApiResource;
  8. use ApiPlatform\Metadata\Delete;
  9. use ApiPlatform\Metadata\Get;
  10. use ApiPlatform\Metadata\GetCollection;
  11. use ApiPlatform\Metadata\Patch;
  12. use ApiPlatform\Metadata\Post;
  13. use ApiPlatform\Metadata\Put;
  14. use App\Controller\Api\CreateSubscriptionController;
  15. use App\Controller\Api\UpdateSubscriptionController;
  16. use App\DTO\SubscriptionInputDTO;
  17. use App\DTO\UpdateSubscriptionInputDTO;
  18. use App\DTO\SubscriptionOutputDTO;
  19. use App\Repository\Tenant\SubscriptionRepository;
  20. use App\Service\ApiPlatform\GeneralSearchFilter;
  21. use Doctrine\Common\Collections\ArrayCollection;
  22. use Doctrine\Common\Collections\Collection;
  23. use Doctrine\DBAL\Types\Types;
  24. use Doctrine\ORM\Mapping as ORM;
  25. use Symfony\Component\Serializer\Annotation\Groups;
  27. #[ORM\Entity(repositoryClass: SubscriptionRepository::class)]
  28. #[ApiFilter(GeneralSearchFilter::class)]
  29. #[ApiResource(
  30.     operations: [
  31.         new Post(
  32.             controller: CreateSubscriptionController::class,
  33.             input: SubscriptionInputDTO::class,
  34.             output: SubscriptionOutputDTO::class
  35.         ),
  36.         new Patch(
  37.             inputFormats: ['json' => 'application/json'],
  38.             controller: UpdateSubscriptionController::class,
  39.             input: UpdateSubscriptionInputDTO::class,
  40.             output: SubscriptionOutputDTO::class
  41.         ),
  42.         new Get(),
  43.         new GetCollection(),
  44.         new Delete(),
  45.         new Put()
  46.     ]
  47. )]
  48. class Subscription
  49. {
  50.     /**
  51.      * visible :list;order:1;
  52.      */
  53.     #[ORM\Id]
  54.     #[ORM\GeneratedValue]
  55.     #[ORM\Column]
  56.     #[Groups(['read'])]
  57.     #[ApiProperty(identifier: true)]
  58.     private ?int $id = null;
  60.     /**
  61.      * visible :list;order:1;
  62.      */
  63.     #[ORM\Column]
  64.     #[Groups(['read'])]
  65.     private ?\DateTimeImmutable $createdAt = null;
  67.     /**
  68.      * visible :list;order:1;
  69.      */
  70.     #[ORM\Column]
  71.     #[Groups(['read'])]
  72.     private ?\DateTimeImmutable $updatedAt = null;
  74.     /**
  75.      * visible :list, form;order:2;
  76.      */
  77.     #[ORM\Column(length: 255)]
  78.     #[Groups(['read', 'write'])]
  79.     private ?string $status = null;
  81.     /**
  82.      * visible :list, form;order:3;
  83.      */
  84.     #[ORM\Column]
  85.     #[Groups(['read', 'write'])]
  86.     private ?bool $serviceEnabled = null;
  88.     /**
  89.      * visible :form;order:6;
  90.      */
  91.     #[ORM\Column]
  92.     #[Groups(['read', 'write'])]
  93.     private ?bool $cancelled = null;
  95.     /**
  96.      * visible :list, form;order:4;
  97.      */
  98.     #[ORM\Column(type: Types::DATE_IMMUTABLE, nullable: true)]
  99.     #[Groups(['read', 'write'])]
  100.     private ?\DateTimeImmutable $nextRenewalDate = null;
  102.     /**
  103.      * visible :list, form;order:5;
  104.      */
  105.     #[ORM\Column(type: Types::DATE_IMMUTABLE, nullable: true)]
  106.     #[Groups(['read', 'write'])]
  107.     private ?\DateTimeImmutable $lastRenewalDate = null;
  109.     /**
  110.      * visible :form;order:7;oneToOne:true
  111.      */
  112.     #[ORM\OneToOne(inversedBy: 'subscription', cascade: ['persist', 'remove'])]
  113.     #[ORM\JoinColumn(nullable: false)]
  114.     private ?Subscriber $subscriber = null;
  116.     /**
  117.      * visible :form;order:9;oneToMany:true
  118.      */
  119.     #[ORM\OneToMany(mappedBy: 'subscription', targetEntity: Event::class)]
  120.     private Collection $events;
  122.     /**
  123.      * visible :form;order:8;manyToOne:true
  124.      */
  125.     #[ORM\ManyToOne(inversedBy: 'subscriptions')]
  126.     #[ORM\JoinColumn(nullable: false)]
  127.     private ?Plan $plan = null;
  129.     /**
  130.      * visible :form;order:10;oneToMany:true
  131.      */
  132.     #[ORM\OneToMany(mappedBy: 'subscription', targetEntity: Renewal::class)]
  133.     private Collection $renewals;
  135.     #[ORM\ManyToMany(targetEntity: Module::class, mappedBy: 'subscriptions')]
  136.     private Collection $modules;
  138.     public function __construct()
  139.     {
  140.         $this->updatedAt = new \DateTimeImmutable();
  141.         $this->createdAt = new \DateTimeImmutable();
  142.         $this->events = new ArrayCollection();
  143.         $this->renewals = new ArrayCollection();
  144.         $this->modules = new ArrayCollection();
  145.     }
  147.     public function getId(): ?int
  148.     {
  149.         return $this->id;
  150.     }
  152.     public function getCreatedAt(): ?\DateTimeImmutable
  153.     {
  154.         return $this->createdAt;
  155.     }
  157.     public function setCreatedAt(\DateTimeImmutable $createdAt): self
  158.     {
  159.         $this->createdAt = $createdAt;
  161.         return $this;
  162.     }
  164.     public function getUpdatedAt(): ?\DateTimeImmutable
  165.     {
  166.         return $this->updatedAt;
  167.     }
  169.     public function setUpdatedAt(\DateTimeImmutable $updatedAt): self
  170.     {
  171.         $this->updatedAt = $updatedAt;
  173.         return $this;
  174.     }
  176.     public function getStatus(): ?string
  177.     {
  178.         return $this->status;
  179.     }
  181.     public function setStatus(string $status): self
  182.     {
  183.         $this->status = $status;
  185.         return $this;
  186.     }
  188.     public function isServiceEnabled(): ?bool
  189.     {
  190.         return $this->serviceEnabled;
  191.     }
  193.     public function setServiceEnabled(bool $serviceEnabled): self
  194.     {
  195.         $this->serviceEnabled = $serviceEnabled;
  197.         return $this;
  198.     }
  200.     public function isCancelled(): ?bool
  201.     {
  202.         return $this->cancelled;
  203.     }
  205.     public function setCancelled(bool $cancelled): self
  206.     {
  207.         $this->cancelled = $cancelled;
  209.         return $this;
  210.     }
  212.     public function getNextRenewalDate(): ?\DateTimeImmutable
  213.     {
  214.         return $this->nextRenewalDate;
  215.     }
  217.     public function setNextRenewalDate(?\DateTimeImmutable $nextRenewalDate): self
  218.     {
  219.         $this->nextRenewalDate = $nextRenewalDate;
  221.         return $this;
  222.     }
  224.     public function getLastRenewalDate(): ?\DateTimeImmutable
  225.     {
  226.         return $this->lastRenewalDate;
  227.     }
  229.     public function setLastRenewalDate(?\DateTimeImmutable $lastRenewalDate): self
  230.     {
  231.         $this->lastRenewalDate = $lastRenewalDate;
  233.         return $this;
  234.     }
  236.     public function getSubscriber(): ?Subscriber
  237.     {
  238.         return $this->subscriber;
  239.     }
  241.     public function setSubscriber(Subscriber $subscriber): self
  242.     {
  243.         $this->subscriber = $subscriber;
  245.         return $this;
  246.     }
  248.     /**
  249.      * @return Collection<int, Event>
  250.      */
  251.     public function getEvents(): Collection
  252.     {
  253.         return $this->events;
  254.     }
  256.     public function addEvent(Event $event): self
  257.     {
  258.         if (!$this->events->contains($event)) {
  259.             $this->events->add($event);
  260.             $event->setSubscription($this);
  261.         }
  263.         return $this;
  264.     }
  266.     public function removeEvent(Event $event): self
  267.     {
  268.         if ($this->events->removeElement($event)) {
  269.             // set the owning side to null (unless already changed)
  270.             if ($event->getSubscription() === $this) {
  271.                 $event->setSubscription(null);
  272.             }
  273.         }
  275.         return $this;
  276.     }
  278.     public function getPlan(): ?Plan
  279.     {
  280.         return $this->plan;
  281.     }
  283.     public function setPlan(?Plan $plan): self
  284.     {
  285.         $this->plan = $plan;
  287.         return $this;
  288.     }
  290.     /**
  291.      * @return Collection<int, Renewal>
  292.      */
  293.     public function getRenewals(): Collection
  294.     {
  295.         return $this->renewals;
  296.     }
  298.     public function addRenewal(Renewal $renewal): self
  299.     {
  300.         if (!$this->renewals->contains($renewal)) {
  301.             $this->renewals->add($renewal);
  302.             $renewal->setSubscription($this);
  303.         }
  305.         return $this;
  306.     }
  308.     public function removeRenewal(Renewal $renewal): self
  309.     {
  310.         if ($this->renewals->removeElement($renewal)) {
  311.             // set the owning side to null (unless already changed)
  312.             if ($renewal->getSubscription() === $this) {
  313.                 $renewal->setSubscription(null);
  314.             }
  315.         }
  317.         return $this;
  318.     }
  320.     /**
  321.      * @return Collection<int, Module>
  322.      */
  323.     public function getModules(): Collection
  324.     {
  325.         return $this->modules;
  326.     }
  328.     public function addModule(Module $module): static
  329.     {
  330.         if (!$this->modules->contains($module)) {
  331.             $this->modules->add($module);
  332.             $module->addSubscription($this);
  333.         }
  335.         return $this;
  336.     }
  338.     public function removeModule(Module $module): static
  339.     {
  340.         if ($this->modules->removeElement($module)) {
  341.             $module->removeSubscription($this);
  342.         }
  344.         return $this;
  345.     }
  346. }