src/Entity/Workspace.php line 14

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\StripeTransactionRepository;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\ORM\Mapping as ORM;
  10. /**
  11.  * @ORM\Entity(repositoryClass="App\Repository\WorkspaceRepository")
  12.  * @ORM\HasLifecycleCallbacks()
  13.  */
  14. class Workspace
  15. {
  16.     public const PAYMENT_NOT_SELECTED = 0;
  17.     public const PAYMENT_TYPE_PAYPAL = 1;
  18.     public const PAYMENT_TYPE_STRIPE = 2;
  20.     /**
  21.      * @ORM\Id()
  22.      * @ORM\GeneratedValue()
  23.      * @ORM\Column(type="integer")
  24.      */
  25.     private $id;
  27.     /**
  28.      * @ORM\OneToOne(targetEntity="App\Entity\User")
  29.      */
  30.     private $owner;
  33.     /**
  34.      * @ORM\OneToMany(targetEntity="App\Entity\UserGroup", mappedBy="workspace")
  35.      */
  36.     private $userGroup;
  38.     /**
  39.      * @ORM\OneToMany(targetEntity="App\Entity\User", mappedBy="workspace")
  40.      */
  41.     private $users;
  43.     /**
  44.      * @ORM\OneToMany(targetEntity="App\Entity\Rollout", mappedBy="workspace")
  45.      */
  46.     private $rollouts;
  48.     /**
  49.      * @ORM\OneToMany(targetEntity="App\Entity\DeviceGroup", mappedBy="workspace")
  50.      */
  51.     private $deviceGroups;
  53.     /**
  54.      * @ORM\OneToMany(targetEntity="App\Entity\Device", mappedBy="workspace")
  55.      */
  56.     private $devices;
  58.     /**
  59.      * @ORM\OneToMany(targetEntity="App\Entity\Invoice", mappedBy="workspace")
  60.      */
  61.     private $invoices;
  63.     /**
  64.      * @ORM\OneToMany(targetEntity="App\Entity\FileGroup", mappedBy="workspace")
  65.      */
  66.     private $fileGroups;
  68.     /**
  69.      * @ORM\OneToMany(targetEntity="App\Entity\File", mappedBy="workspace")
  70.      */
  71.     private $files;
  73.     /**
  74.      * @ORM\OneToMany(targetEntity="App\Entity\Support", mappedBy="workspace")
  75.      */
  76.     private $supports;
  78.     /**
  79.      * @ORM\Column(type="string", nullable=true)
  80.      */
  81.     private $customerKey;
  83.     /**
  84.      * @ORM\OneToMany(targetEntity="App\Entity\DeviceKey", mappedBy="workspace")
  85.      */
  86.     private $deviceKeys;
  88.     /**
  89.      * @ORM\OneToMany(targetEntity="App\Entity\SandboxRollout", mappedBy="workspace")
  90.      */
  91.     private $sandboxRollouts;
  93.     /**
  94.      * @ORM\OneToMany(targetEntity="App\Entity\SandboxDeviceGroup", mappedBy="workspace")
  95.      */
  96.     private $sandboxDeviceGroups;
  98.     /**
  99.      * @ORM\OneToMany(targetEntity="App\Entity\SandboxDevice", mappedBy="workspace")
  100.      */
  101.     private $sandboxDevices;
  103.     /**
  104.      * @ORM\OneToMany(targetEntity="App\Entity\SandboxFileGroup", mappedBy="workspace")
  105.      */
  106.     private $sandboxFileGroups;
  108.     /**
  109.      * @ORM\OneToMany(targetEntity="App\Entity\SandboxFile", mappedBy="workspace")
  110.      */
  111.     private $sandboxFiles;
  113.     /**
  114.      * @ORM\Column(type="boolean", options={"default" : false}))
  115.      */
  116.     private $disabled = false;
  118.     /**
  119.      * @ORM\Column(type="boolean", options={"default" : false}))
  120.      */
  121.     private $deleted = false;
  123.     /**
  124.      * @ORM\ManyToMany(targetEntity="App\Entity\Plan")
  125.      * @ORM\JoinTable(name="workspace_plan",
  126.      *      joinColumns={@ORM\JoinColumn(name="workspace_id", referencedColumnName="id")},
  127.      *      inverseJoinColumns={@ORM\JoinColumn(name="plan_id", referencedColumnName="id")}
  128.      *      )
  129.      */
  130.     private $plans;
  132.     /**
  133.      * @ORM\OneToMany(targetEntity=PayPalTransaction::class, mappedBy="workspace", orphanRemoval=true)
  134.      */
  135.     private $payPalTransactions;
  137.     /**
  138.      * @ORM\OneToMany(targetEntity=StripeTransaction::class, mappedBy="workspace", orphanRemoval=true)
  139.      */
  140.     private $stripeTransactions;
  142.     /**
  143.      * @ORM\OneToMany(targetEntity=PlanChange::class, mappedBy="workspace", orphanRemoval=true)
  144.      */
  145.     private $planChanges;
  147.     /**
  148.      * @ORM\Column(type="datetime", nullable=true)
  149.      */
  150.     private $lastAvailableUpdatesMailSent = null;
  152.     /**
  153.      * @ORM\Column(type="integer", options={"default": 0}))
  154.      */
  155.     private $paymentType = 0;
  157.     public function __construct()
  158.     {
  159.         $this->userGroup = new ArrayCollection();
  160.         $this->users = new ArrayCollection();
  161.         $this->rollouts = new ArrayCollection();
  162.         $this->deviceGroups = new ArrayCollection();
  163.         $this->devices = new ArrayCollection();
  164.         $this->invoices = new ArrayCollection();
  165.         $this->fileGroups = new ArrayCollection();
  166.         $this->files = new ArrayCollection();
  167.         $this->supports = new ArrayCollection();
  168.         $this->sandboxRollouts = new ArrayCollection();
  169.         $this->sandboxDeviceGroups = new ArrayCollection();
  170.         $this->sandboxDevices = new ArrayCollection();
  171.         $this->sandboxFileGroups = new ArrayCollection();
  172.         $this->sandboxFiles = new ArrayCollection();
  173.         $this->plans = new ArrayCollection();
  174.         $this->payPalTransactions = new ArrayCollection();
  175.         $this->planChanges = new ArrayCollection();
  176.         $this->deviceKeys = new ArrayCollection();
  177.     }
  179.     public function getId(): ?int
  180.     {
  181.         return $this->id;
  182.     }
  184.     public function getOwner(): ?User
  185.     {
  186.         return $this->owner;
  187.     }
  189.     public function setOwner(?User $owner): self
  190.     {
  191.         $this->owner = $owner;
  193.         return $this;
  194.     }
  196.     /**
  197.      * @return Collection|UserGroup[]
  198.      */
  199.     public function getUserGroup(): Collection
  200.     {
  201.         return $this->userGroup;
  202.     }
  204.     public function addUserGroup(UserGroup $userGroup): self
  205.     {
  206.         if (!$this->userGroup->contains($userGroup)) {
  207.             $this->userGroup[] = $userGroup;
  208.             $userGroup->setWorkspace($this);
  209.         }
  211.         return $this;
  212.     }
  214.     public function removeUserGroup(UserGroup $userGroup): self
  215.     {
  216.         if ($this->userGroup->contains($userGroup)) {
  217.             $this->userGroup->removeElement($userGroup);
  218.             // set the owning side to null (unless already changed)
  219.             if ($userGroup->getWorkspace() === $this) {
  220.                 $userGroup->setWorkspace(null);
  221.             }
  222.         }
  224.         return $this;
  225.     }
  227.     /**
  228.      * @return Collection|User[]
  229.      */
  230.     public function getUsers(): Collection
  231.     {
  232.         return $this->users;
  233.     }
  235.     public function addUser(User $user): self
  236.     {
  237.         if (!$this->users->contains($user)) {
  238.             $this->users->add($user);
  239.             $user->setWorkspace($this);
  240.         }
  242.         return $this;
  243.     }
  245.     public function removeUser(User $user): self
  246.     {
  247.         if ($this->users->contains($user)) {
  248.             $this->users->removeElement($user);
  249.             // set the owning side to null (unless already changed)
  250.             if ($user->getWorkspace() === $this) {
  251.                 $user->setWorkspace(null);
  252.             }
  253.         }
  255.         return $this;
  256.     }
  258.     /**
  259.      * @return int
  260.      */
  261.     public function getAvailableUpdates(): int
  262.     {
  263.         if (is_object($this->getPlan())) {
  264.             $allowed = $this->getPlan()->getAllowedDevices();
  265.             $countDevices = count($this->getFilteredUsedDevices());
  266.             return ((($allowed - $countDevices) < 0) ? 0 : ($allowed - $countDevices));
  267.         }
  268.         return 0;
  269.     }
  271.     /**
  272.      * @return int
  273.      */
  274.     public function getActiveDevices(): int
  275.     {
  276.         return count($this->getFilteredUsedDevices());
  277.     }
  279.     /**
  280.      * @return int
  281.      */
  282.     public function getUsedDevices(): int
  283.     {
  284.         if (is_object($this->getPlan())) {
  285.             return count($this->getFilteredUsedDevices());
  286.         }
  287.         return 0;
  288.     }
  290.     /**
  291.      * @return Collection
  292.      */
  293.     private function getFilteredUsedDevices(): Collection
  294.     {
  295.         return $this->getDevices()->filter(function (Device $device) {
  296.             return (
  297.                 ($device->getBlackListed() === false && $device->getTransactionId() !== null)
  298.                 or
  299.                 ($device->getBlackListed() === false && $device->getDeviceGroup() !== null)
  300.             );
  302.         });
  303.     }
  306.     /**
  307.      * @return Collection|Rollout[]
  308.      */
  309.     public function getRollouts(): Collection
  310.     {
  311.         return $this->rollouts;
  312.     }
  314.     /**
  315.      * @param Rollout $rollout
  316.      * @return $this
  317.      */
  318.     public function addRollout(Rollout $rollout): self
  319.     {
  320.         if (!$this->rollouts->contains($rollout)) {
  321.             $this->rollouts->add($rollout);
  322.             $rollout->setWorkspace($this);
  323.         }
  325.         return $this;
  326.     }
  328.     public function removeRollout(Rollout $rollout): self
  329.     {
  330.         if ($this->rollouts->contains($rollout)) {
  331.             $this->rollouts->removeElement($rollout);
  332.             // set the owning side to null (unless already changed)
  333.             if ($rollout->getWorkspace() === $this) {
  334.                 $rollout->setWorkspace(null);
  335.             }
  336.         }
  338.         return $this;
  339.     }
  341.     /**
  342.      * @return Collection|DeviceGroup[]
  343.      */
  344.     public function getDeviceGroups(): Collection
  345.     {
  346.         return $this->deviceGroups;
  347.     }
  349.     /**
  350.      * @param DeviceGroup $deviceGroup
  351.      * @return $this
  352.      */
  353.     public function addDeviceGroup(DeviceGroup $deviceGroup): self
  354.     {
  355.         if (!$this->deviceGroups->contains($deviceGroup)) {
  356.             $this->deviceGroups->add($deviceGroup);
  357.             $deviceGroup->setWorkspace($this);
  358.         }
  360.         return $this;
  361.     }
  363.     /**
  364.      * @param DeviceGroup $deviceGroup
  365.      * @return $this
  366.      */
  367.     public function removeDeviceGroup(DeviceGroup $deviceGroup): self
  368.     {
  369.         if ($this->deviceGroups->contains($deviceGroup)) {
  370.             $this->deviceGroups->removeElement($deviceGroup);
  371.             if ($deviceGroup->getWorkspace() === $this) {
  372.                 $deviceGroup->setWorkspace(null);
  373.             }
  374.         }
  376.         return $this;
  377.     }
  379.     /**
  380.      * @return Collection|Device[]
  381.      */
  382.     public function getDevices(): Collection
  383.     {
  384.         return $this->devices;
  385.     }
  387.     /**
  388.      * @param Device $device
  389.      * @return $this
  390.      */
  391.     public function addDevice(Device $device): self
  392.     {
  393.         if (!$this->devices->contains($device)) {
  394.             $this->devices->add($device);
  395.             $device->setWorkspace($this);
  396.         }
  398.         return $this;
  399.     }
  401.     /**
  402.      * @param Device $device
  403.      * @return $this
  404.      */
  405.     public function removeDevice(Device $device): self
  406.     {
  407.         if ($this->devices->contains($device)) {
  408.             $this->devices->removeElement($device);
  409.             if ($device->getWorkspace() === $this) {
  410.                 $device->setWorkspace(null);
  411.             }
  412.         }
  414.         return $this;
  415.     }
  417.     /**
  418.      * @return Collection|FileGroup[]
  419.      */
  420.     public function getFileGroups(): Collection
  421.     {
  422.         return $this->fileGroups;
  423.     }
  425.     /**
  426.      * @param FileGroup $fileGroup
  427.      * @return $this
  428.      */
  429.     public function addFileGroup(FileGroup $fileGroup): self
  430.     {
  431.         if (!$this->fileGroups->contains($fileGroup)) {
  432.             $this->fileGroups->add($fileGroup);
  433.             $fileGroup->setWorkspace($this);
  434.         }
  436.         return $this;
  437.     }
  439.     /**
  440.      * @param FileGroup $fileGroup
  441.      * @return $this
  442.      */
  443.     public function removeFileGroup(FileGroup $fileGroup): self
  444.     {
  445.         if ($this->fileGroups->contains($fileGroup)) {
  446.             $this->fileGroups->removeElement($fileGroup);
  447.             if ($fileGroup->getWorkspace() === $this) {
  448.                 $fileGroup->setWorkspace(null);
  449.             }
  450.         }
  452.         return $this;
  453.     }
  455.     /**
  456.      * @return Collection|File[]
  457.      */
  458.     public function getFiles(): Collection
  459.     {
  460.         return $this->files;
  461.     }
  463.     /**
  464.      * @param File $file
  465.      * @return $this
  466.      */
  467.     public function addFile(File $file): self
  468.     {
  469.         if (!$this->files->contains($file)) {
  470.             $this->files->add($file);
  471.             $file->setWorkspace($this);
  472.         }
  474.         return $this;
  475.     }
  477.     /**
  478.      * @param File $file
  479.      * @return $this
  480.      */
  481.     public function removeFile(File $file): self
  482.     {
  483.         if ($this->files->contains($file)) {
  484.             $this->files->removeElement($file);
  485.             if ($file->getWorkspace() === $this) {
  486.                 $file->setWorkspace(null);
  487.             }
  488.         }
  490.         return $this;
  491.     }
  493.     public function getCustomerKey(): ?string
  494.     {
  495.         return $this->customerKey;
  496.     }
  498.     public function setCustomerKey(?string $customerKey): self
  499.     {
  500.         $this->customerKey = $customerKey;
  502.         return $this;
  503.     }
  505.     public function getDeviceKey(): ?string
  506.     {
  507.         if (count($this->deviceKeys) > 0) {
  508.             /** @var DeviceKey $deviceKey */
  509.             $deviceKey = $this->deviceKeys->first();
  510.             return $deviceKey->getDeviceKey();
  511.         }
  512.         return null;
  513.     }
  516.     /**
  517.      * @return Collection|Support[]
  518.      */
  519.     public function getSupports(): Collection
  520.     {
  521.         return $this->supports;
  522.     }
  524.     /**
  525.      * @param Support $support
  526.      * @return $this
  527.      */
  528.     public function addSupport(Support $support): self
  529.     {
  530.         if (!$this->supports->contains($support)) {
  531.             $this->supports->add($support);
  532.             $support->setWorkspace($this);
  533.         }
  535.         return $this;
  536.     }
  538.     /**
  539.      * @param Support $support
  540.      * @return $this
  541.      */
  542.     public function removeSupport(Support $support): self
  543.     {
  544.         if ($this->supports->contains($support)) {
  545.             $this->supports->removeElement($support);
  546.             if ($support->getWorkspace() === $this) {
  547.                 $support->setWorkspace(null);
  548.             }
  549.         }
  551.         return $this;
  552.     }
  555.     /**
  556.      * @return Collection|SandboxRollout[]
  557.      */
  558.     public function getSandboxRollouts(): Collection
  559.     {
  560.         return $this->sandboxRollouts;
  561.     }
  563.     /**
  564.      * @param SandboxRollout $sandboxRollout
  565.      * @return $this
  566.      */
  567.     public function addSandboxRollout(SandboxRollout $sandboxRollout): self
  568.     {
  569.         if (!$this->sandboxRollouts->contains($sandboxRollout)) {
  570.             $this->sandboxRollouts->add($sandboxRollout);
  571.             $sandboxRollout->setWorkspace($this);
  572.         }
  574.         return $this;
  575.     }
  577.     /**
  578.      * @param SandboxRollout $sandboxRollout
  579.      * @return $this
  580.      */
  581.     public function removeSandboxRollout(SandboxRollout $sandboxRollout): self
  582.     {
  583.         if ($this->sandboxRollouts->contains($sandboxRollout)) {
  584.             $this->sandboxRollouts->removeElement($sandboxRollout);
  585.             // set the owning side to null (unless already changed)
  586.             if ($sandboxRollout->getWorkspace() === $this) {
  587.                 $sandboxRollout->setWorkspace(null);
  588.             }
  589.         }
  591.         return $this;
  592.     }
  594.     /**
  595.      * @return Collection|SandboxDeviceGroup[]
  596.      */
  597.     public function getSandboxDeviceGroups(): Collection
  598.     {
  599.         return $this->sandboxDeviceGroups;
  600.     }
  602.     /**
  603.      * @param SandboxDeviceGroup $sandboxDeviceGroup
  604.      * @return $this
  605.      */
  606.     public function addSandboxDeviceGroup(SandboxDeviceGroup $sandboxDeviceGroup): self
  607.     {
  608.         if (!$this->sandboxDeviceGroups->contains($sandboxDeviceGroup)) {
  609.             $this->sandboxDeviceGroups->add($sandboxDeviceGroup);
  610.             $sandboxDeviceGroup->setWorkspace($this);
  611.         }
  613.         return $this;
  614.     }
  616.     /**
  617.      * @param SandboxDeviceGroup $sandboxDeviceGroup
  618.      * @return $this
  619.      */
  620.     public function removeSandboxDeviceGroup(SandboxDeviceGroup $sandboxDeviceGroup): self
  621.     {
  622.         if ($this->sandboxDeviceGroups->contains($sandboxDeviceGroup)) {
  623.             $this->sandboxDeviceGroups->removeElement($sandboxDeviceGroup);
  624.             if ($sandboxDeviceGroup->getWorkspace() === $this) {
  625.                 $sandboxDeviceGroup->setWorkspace(null);
  626.             }
  627.         }
  629.         return $this;
  630.     }
  632.     /**
  633.      * @return Collection|SandboxDeviceGroup[]
  634.      */
  635.     public function getSandboxDevices(): Collection
  636.     {
  637.         return $this->sandboxDevices;
  638.     }
  640.     /**
  641.      * @param SandboxDevice $sandboxDevice
  642.      * @return $this
  643.      */
  644.     public function addSandboxDevice(SandboxDevice $sandboxDevice): self
  645.     {
  646.         if (!$this->sandboxDevices->contains($sandboxDevice)) {
  647.             $this->sandboxDevices->add($sandboxDevice);
  648.             $sandboxDevice->setWorkspace($this);
  649.         }
  651.         return $this;
  652.     }
  654.     /**
  655.      * @param SandboxDevice $sandboxDevice
  656.      * @return $this
  657.      */
  658.     public function removeSandboxDevice(SandboxDevice $sandboxDevice): self
  659.     {
  660.         if ($this->sandboxDevices->contains($sandboxDevice)) {
  661.             $this->sandboxDevices->removeElement($sandboxDevice);
  662.             if ($sandboxDevice->getWorkspace() === $this) {
  663.                 $sandboxDevice->setWorkspace(null);
  664.             }
  665.         }
  667.         return $this;
  668.     }
  670.     /**
  671.      * @return Collection|SandboxFileGroup[]
  672.      */
  673.     public function getSandboxFileGroups(): Collection
  674.     {
  675.         return $this->sandboxFileGroups;
  676.     }
  678.     /**
  679.      * @param SandboxFileGroup $sandboxFileGroup
  680.      * @return $this
  681.      */
  682.     public function addSandboxFileGroup(SandboxFileGroup $sandboxFileGroup): self
  683.     {
  684.         if (!$this->sandboxFileGroups->contains($sandboxFileGroup)) {
  685.             $this->sandboxFileGroups->add($sandboxFileGroup);
  686.             $sandboxFileGroup->setWorkspace($this);
  687.         }
  689.         return $this;
  690.     }
  692.     /**
  693.      * @param SandboxFileGroup $sandboxFileGroup
  694.      * @return $this
  695.      */
  696.     public function removeSandboxFileGroup(SandboxFileGroup $sandboxFileGroup): self
  697.     {
  698.         if ($this->sandboxFileGroups->contains($sandboxFileGroup)) {
  699.             $this->sandboxFileGroups->removeElement($sandboxFileGroup);
  700.             if ($sandboxFileGroup->getWorkspace() === $this) {
  701.                 $sandboxFileGroup->setWorkspace(null);
  702.             }
  703.         }
  705.         return $this;
  706.     }
  708.     /**
  709.      * @return Collection|SandboxFile[]
  710.      */
  711.     public function getSandboxFiles(): Collection
  712.     {
  713.         return $this->sandboxFiles;
  714.     }
  716.     /**
  717.      * @param SandboxFile $sandboxFile
  718.      * @return $this
  719.      */
  720.     public function addSandboxFile(SandboxFile $sandboxFile): self
  721.     {
  722.         if (!$this->sandboxFiles->contains($sandboxFile)) {
  723.             $this->sandboxFiles->add($sandboxFile);
  724.             $sandboxFile->setWorkspace($this);
  725.         }
  727.         return $this;
  728.     }
  730.     /**
  731.      * @param SandboxFile $sandboxFile
  732.      * @return $this
  733.      */
  734.     public function removeSandboxFile(SandboxFile $sandboxFile): self
  735.     {
  736.         if ($this->sandboxFiles->contains($sandboxFile)) {
  737.             $this->sandboxFiles->removeElement($sandboxFile);
  738.             if ($sandboxFile->getWorkspace() === $this) {
  739.                 $sandboxFile->setWorkspace(null);
  740.             }
  741.         }
  743.         return $this;
  744.     }
  747.     /**
  748.      * @return bool
  749.      */
  750.     public function isDisabled(): bool
  751.     {
  752.         return $this->disabled;
  753.     }
  755.     /**
  756.      * @param bool $disabled
  757.      */
  758.     public function setDisabled(bool $disabled): void
  759.     {
  760.         $this->disabled = $disabled;
  761.     }
  764.     /**
  765.      * @return Plan|null
  766.      */
  767.     public function getPlan(): ?Plan
  768.     {
  769.         if (count($this->plans) > 0) {
  770.             return $this->plans->first();
  771.         }
  772.         return null;
  773.     }
  775.     /**
  776.      * @param Plan $plan
  777.      * @return $this
  778.      */
  779.     public function setPlan(Plan $plan): self
  780.     {
  781.         if (!$this->plans->contains($plan)) {
  782.             $this->plans->clear();
  783.             $this->plans->add($plan);
  784.         }
  786.         return $this;
  787.     }
  789.     /**
  790.      * @return Collection|PayPalTransaction[]
  791.      */
  792.     public function getPayPalTransactions(): Collection
  793.     {
  794.         return $this->payPalTransactions;
  795.     }
  797.     public function addPayPalTransaction(PayPalTransaction $payPalTransaction): self
  798.     {
  799.         if (!$this->payPalTransactions->contains($payPalTransaction)) {
  800.             $this->payPalTransactions[] = $payPalTransaction;
  801.             $payPalTransaction->setWorkspace($this);
  802.         }
  804.         return $this;
  805.     }
  807.     public function removePayPalTransaction(PayPalTransaction $payPalTransaction): self
  808.     {
  809.         if ($this->payPalTransactions->removeElement($payPalTransaction)) {
  810.             // set the owning side to null (unless already changed)
  811.             if ($payPalTransaction->getWorkspace() === $this) {
  812.                 $payPalTransaction->setWorkspace(null);
  813.             }
  814.         }
  816.         return $this;
  817.     }
  819.     /**
  820.      * @param string|null $planId
  821.      * @return bool
  822.      */
  823.     public function hasAuthorization(?string $planId): bool
  824.     {
  825.         if ($this->getPaymentType() == Workspace::PAYMENT_TYPE_PAYPAL) {
  826.             /** @var PayPalTransaction $transaction */
  827.             foreach ($this->payPalTransactions as $transaction) {
  828.                 if (
  829.                     $transaction->getStatus() === PayPalTransaction::STATUS_SUCCESS
  830.                     && $transaction->getType() === PayPalTransaction::AUTHORIZE &&
  831.                     $transaction->getPayPalPlanId() === $planId
  832.                     &&
  833.                     !empty($transaction->getAuthId())
  834.                 ) {
  835.                     return true;
  836.                 }
  837.             }
  838.         } elseif ($this->getPaymentType() == Workspace::PAYMENT_TYPE_STRIPE) {
  839.                 /** @var StripeTransaction $transaction */
  840.                 foreach ($this->stripeTransactions as $transaction) {
  841.                     if (
  842.                         $transaction->getStatus() === StripeTransaction::STATUS_SUCCESS
  843.                         && $transaction->getType() === StripeTransaction::AUTHORIZE &&
  844.                         $transaction->getStripePlanId() === $planId
  845.                         &&
  846.                         !empty($transaction->getSessionId())
  847.                     ) {
  848.                         return true;
  849.                     }
  850.             }
  851.         }
  853.         return false;
  854.     }
  856.     /**
  857.      * @param string|null $planId
  858.      * @return PayPalTransaction|StripeTransaction|null
  859.      */
  860.     public function getActiveAuthorization(?string $planId)
  861.     {
  862.         if ($this->getPaymentType() == Workspace::PAYMENT_TYPE_PAYPAL) {
  863.             /** @var PayPalTransaction $transaction */
  864.             foreach ($this->payPalTransactions as $transaction) {
  865.                 if (
  866.                     $transaction->getStatus() === PayPalTransaction::STATUS_SUCCESS
  867.                     && $transaction->getType() === PayPalTransaction::AUTHORIZE &&
  868.                     $transaction->getPayPalPlanId() === $planId
  869.                     &&
  870.                     !empty($transaction->getAuthId())
  871.                 ) {
  872.                     return $transaction;
  873.                 }
  874.             }
  875.         } elseif ($this->getPaymentType() == Workspace::PAYMENT_TYPE_STRIPE) {
  876.             /** @var StripeTransaction $transaction */
  877.             foreach ($this->stripeTransactions as $transaction) {
  878.                 if (
  879.                     $transaction->getStatus() === StripeTransaction::STATUS_SUCCESS
  880.                     && $transaction->getType() === StripeTransaction::AUTHORIZE &&
  881.                     $transaction->getStripePlanId() === $planId
  882.                     &&
  883.                     !empty($transaction->getSessionId())
  884.                 ) {
  885.                     return $transaction;
  886.                 }
  887.             }
  888.         }
  890.         return null;
  891.     }
  893.     /**
  894.      * @param string|null $payPalPlanId
  895.      * @return PayPalTransaction|null
  896.      */
  897.     public function getPendingAuthorization(?string $payPalPlanId): ?PayPalTransaction
  898.     {
  900.         /** @var PayPalTransaction $transaction */
  901.         foreach ($this->payPalTransactions as $transaction) {
  902.             if (
  903.                 $transaction->getStatus() === PayPalTransaction::STATUS_PENDING
  904.                 && $transaction->getType() === PayPalTransaction::AUTHORIZE &&
  905.                 $transaction->getPayPalPlanId() === $payPalPlanId &&
  906.                 !empty($transaction->getAuthId())
  907.             ) {
  908.                 return $transaction;
  909.             }
  910.         }
  912.         return null;
  913.     }
  915.     /**
  916.      * @return Collection|PlanChange[]
  917.      */
  918.     public function getPlanChanges(): Collection
  919.     {
  920.         return $this->planChanges;
  921.     }
  923.     public function addPlanChange(PlanChange $planChange): self
  924.     {
  925.         if (!$this->planChanges->contains($planChange)) {
  926.             $this->planChanges[] = $planChange;
  927.             $planChange->setWorkspace($this);
  928.         }
  930.         return $this;
  931.     }
  933.     public function removePlanChange(PlanChange $planChange): self
  934.     {
  935.         if ($this->planChanges->removeElement($planChange)) {
  936.             // set the owning side to null (unless already changed)
  937.             if ($planChange->getWorkspace() === $this) {
  938.                 $planChange->setWorkspace(null);
  939.             }
  940.         }
  942.         return $this;
  943.     }
  945.     /**
  946.      * @return bool
  947.      */
  948.     public function hasOpenedPlanChange(): bool
  949.     {
  950.         /** @var PlanChange $planChange */
  951.         foreach ($this->planChanges as $planChange) {
  952.             if ($planChange->getClosed() === false) {
  953.                 return true;
  954.             }
  955.         }
  956.         return false;
  957.     }
  959.     /**
  960.      * @return PlanChange|null
  961.      */
  962.     public function getOpenedPlanChange(): ?PlanChange
  963.     {
  964.         /** @var PlanChange $planChange */
  965.         foreach ($this->planChanges as $planChange) {
  966.             if ($planChange->getClosed() === false) {
  967.                 return $planChange;
  968.             }
  969.         }
  970.         return null;
  971.     }
  974.     /**
  975.      * @return Collection|Invoice[]
  976.      */
  977.     public function getInvoices(): Collection
  978.     {
  979.         return $this->invoices;
  980.     }
  982.     /**
  983.      * @param Invoice $invoice
  984.      * @return $this
  985.      */
  986.     public function addInvoice(Invoice $invoice): self
  987.     {
  988.         if (!$this->invoices->contains($invoice)) {
  989.             $this->invoices->add($invoice);
  990.             $invoice->setWorkspace($this);
  991.         }
  993.         return $this;
  994.     }
  996.     /**
  997.      * @param Invoice $invoice
  998.      * @return $this
  999.      */
  1000.     public function removeInvoice(Invoice $invoice): self
  1001.     {
  1002.         if ($this->invoices->contains($invoice)) {
  1003.             $this->invoices->removeElement($invoice);
  1004.             if ($invoice->getWorkspace() === $this) {
  1005.                 $invoice->setWorkspace(null);
  1006.             }
  1007.         }
  1009.         return $this;
  1010.     }
  1012.     /**
  1013.      * @return bool
  1014.      */
  1015.     public function isDeleted(): bool
  1016.     {
  1017.         return $this->deleted;
  1018.     }
  1020.     /**
  1021.      * @param bool $deleted
  1022.      */
  1023.     public function setDeleted(bool $deleted): void
  1024.     {
  1025.         $this->deleted = $deleted;
  1026.     }
  1028.     /**
  1029.      * @return null
  1030.      */
  1031.     public function getLastAvailableUpdatesMailSent()
  1032.     {
  1033.         return $this->lastAvailableUpdatesMailSent;
  1034.     }
  1036.     /**
  1037.      * @param null $lastAvailableUpdatesMailSent
  1038.      */
  1039.     public function setLastAvailableUpdatesMailSent($lastAvailableUpdatesMailSent): void
  1040.     {
  1041.         $this->lastAvailableUpdatesMailSent = $lastAvailableUpdatesMailSent;
  1042.     }
  1044.     /**
  1045.      * @return Collection|DeviceKey[]
  1046.      */
  1047.     public function getDeviceKeys(): Collection
  1048.     {
  1049.         return $this->deviceKeys;
  1050.     }
  1052.     /**
  1053.      * @param DeviceKey $deviceKey
  1054.      * @return $this
  1055.      */
  1056.     public function addDeviceKey(DeviceKey $deviceKey): self
  1057.     {
  1058.         if (!$this->deviceKeys->contains($deviceKey)) {
  1059.             $this->deviceKeys->add($deviceKey);
  1060.             $deviceKey->setWorkspace($this);
  1061.         }
  1063.         return $this;
  1064.     }
  1066.     /**
  1067.      * @param DeviceKey $deviceKey
  1068.      * @return $this
  1069.      */
  1070.     public function removeDeviceKey(DeviceKey $deviceKey): self
  1071.     {
  1072.         if ($this->deviceKeys->contains($deviceKey)) {
  1073.             $this->deviceKeys->removeElement($deviceKey);
  1074.         }
  1076.         return $this;
  1077.     }
  1079.     /**
  1080.      * @return mixed
  1081.      */
  1082.     public function getStripeTransactions()
  1083.     {
  1084.         return $this->stripeTransactions;
  1085.     }
  1087.     /**
  1088.      * @param mixed $stripeTransactions
  1089.      */
  1090.     public function setStripeTransactions($stripeTransactions): void
  1091.     {
  1092.         $this->stripeTransactions = $stripeTransactions;
  1093.     }
  1095.     /**
  1096.      * @return mixed
  1097.      */
  1098.     public function getPaymentType()
  1099.     {
  1100.         return $this->paymentType;
  1101.     }
  1103.     /**
  1104.      * @param mixed $paymentType
  1105.      */
  1106.     public function setPaymentType($paymentType): void
  1107.     {
  1108.         $this->paymentType = $paymentType;
  1109.     }
  1111. }