src/Entity/User.php line 26

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\EmailTemplateRepository;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\ORM\Mapping as ORM;
  9. use Doctrine\ORM\Mapping\AttributeOverrides;
  10. use Doctrine\ORM\Mapping\AttributeOverride;
  11. use Doctrine\ORM\Mapping\Column;
  12. use Symfony\Component\Security\Core\User\UserInterface;
  13. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  14. use Symfony\Component\Validator\Constraints as Assert;
  15. use Symfony\Component\HttpFoundation\File\File;
  16. use Vich\UploaderBundle\Mapping\Annotation as Vich;
  17. use Serializable;
  18. use Doctrine\Common\Collections\Criteria;
  20. /**
  21. * @ORM\Entity(repositoryClass="App\Repository\UserRepository")
  22. * @ORM\HasLifecycleCallbacks()
  23. * @UniqueEntity("username")
  24. * @Vich\Uploadable
  25. */
  26. class User implements \Utixodev\FicBundle\Entity\UserInterface, UserInterface, Serializable
  27. {
  28. const STATUS_ACTIVE = 'active';
  29. const STATUS_SUSPENDED = 'suspended';
  30. const STATUS_TERMINATED = 'terminated';
  32. /**
  33. * @ORM\Id()
  34. * @ORM\GeneratedValue()
  35. * @ORM\Column(type="integer")
  36. */
  37. private $id;
  39. /**
  40. * @ORM\Column(type="string", length=180, unique=true)
  41. * @Assert\NotNull()
  42. */
  43. private $username;
  45. /**
  46. * @ORM\Column(type="json")
  47. */
  48. private $roles = [];
  50. /**
  51. * @var string The hashed password
  52. * @ORM\Column(type="string")
  53. * @Assert\NotNull()
  54. */
  55. private $password;
  57. /**
  58. * @ORM\Column(type="string", length=255)
  59. * @Assert\Email()
  60. * @Assert\NotNull()
  61. */
  62. private $email;
  64. /**
  65. * @ORM\Column(type="datetime")
  66. */
  67. private $created_at;
  69. /**
  70. * @ORM\Column(type="datetime", nullable=true)
  71. * @Assert\NotNull
  72. */
  73. private $last_login;
  75. /**
  76. * @ORM\OneToMany(targetEntity="App\Entity\Contact", mappedBy="user", fetch="EXTRA_LAZY")
  77. */
  78. private $contacts;
  80. /**
  81. * @ORM\OneToMany(targetEntity="App\Entity\Email", mappedBy="user")
  82. */
  83. private $emails;
  85. /**
  86. * @ORM\OneToMany(targetEntity="App\Entity\Campaign", mappedBy="user", orphanRemoval=true)
  87. */
  88. private $campaigns;
  90. /**
  91. * @ORM\OneToMany(targetEntity="App\Entity\ContactGroup", mappedBy="user", orphanRemoval=true)
  92. */
  93. private $contactGroups;
  95. /**
  96. * @ORM\Column(type="string", length=255, nullable=true)
  97. */
  98. private $company;
  100. /**
  101. * @ORM\Column(type="string", length=255, nullable=true)
  102. */
  103. private $website;
  105. /**
  106. * @ORM\Column(type="string", length=255, nullable=true)
  107. */
  108. private $logo;
  110. /**
  111. * @Vich\UploadableField(mapping="uploads", fileNameProperty="logo")
  112. */
  113. private $logo_file;
  115. /**
  116. * @ORM\Column(type="datetime")
  117. */
  118. private $updated_at;
  120. /**
  121. * @ORM\Column(type="string", length=255, nullable=true)
  122. */
  123. private $address;
  125. /**
  126. * @ORM\Column(type="string", length=255, nullable=true)
  127. */
  128. private $from_address;
  130. /**
  131. * @ORM\OneToMany(targetEntity="App\Entity\ApiToken", mappedBy="user", orphanRemoval=true)
  132. */
  133. private $apiTokens;
  135. /**
  136. * @ORM\OneToMany(targetEntity="App\Entity\Form", mappedBy="user", orphanRemoval=true)
  137. */
  138. private $forms;
  140. /**
  141. * @ORM\Column(type="json")
  142. */
  143. private $send_count;
  145. /**
  146. * @ORM\ManyToOne(targetEntity="App\Entity\Plan", inversedBy="users")
  147. * @Assert\NotNull()
  148. */
  149. private $plan;
  151. /**
  152. * @ORM\OneToMany(targetEntity="App\Entity\Task", mappedBy="user")
  153. * @ORM\OrderBy({"created_at" = "DESC"})
  154. */
  155. private $tasks;
  157. /**
  158. * @ORM\OneToMany(targetEntity=Notification::class, mappedBy="user")
  159. */
  160. private $notifications;
  162. /**
  163. * @ORM\OneToMany(targetEntity=EmailTemplate::class, mappedBy="user")
  164. */
  165. private $emailTemplates;
  167. /**
  168. * @ORM\OneToMany(targetEntity=Upload::class, mappedBy="user", orphanRemoval=true)
  169. */
  170. private $uploads;
  172. /**
  173. * @ORM\Column(type="string", length=255)
  174. */
  175. private $status;
  177. /**
  178. * @ORM\OneToMany(targetEntity=Domain::class, mappedBy="user", orphanRemoval=true)
  179. */
  180. private $domains;
  182. /**
  183. * @ORM\OneToOne(targetEntity=CustomFields::class, mappedBy="user", cascade={"persist", "remove"})
  184. */
  185. private $customFields;
  187. /**
  188. * @ORM\ManyToMany(targetEntity=Addon::class, inversedBy="users")
  189. */
  190. private $addons;
  193. public function __construct()
  194. {
  195. $this->contacts = new ArrayCollection();
  196. $this->emails = new ArrayCollection();
  197. $this->campaigns = new ArrayCollection();
  198. $this->contactGroups = new ArrayCollection();
  199. $this->apiTokens = new ArrayCollection();
  200. $this->forms = new ArrayCollection();
  201. $this->tasks = new ArrayCollection();
  202. $this->notifications = new ArrayCollection();
  203. $this->emailTemplates = new ArrayCollection();
  204. $this->uploads = new ArrayCollection();
  205. $this->domains = new ArrayCollection();
  206. $this->addons = new ArrayCollection();
  207. }
  209. public function getId(): ?int
  210. {
  211. return $this->id;
  212. }
  214. /**
  215. * A visual identifier that represents this user.
  216. *
  217. * @see UserInterface
  218. */
  219. public function getUsername(): string
  220. {
  221. return (string) $this->username;
  222. }
  224. public function setUsername(string $username): self
  225. {
  226. $this->username = $username;
  228. return $this;
  229. }
  231. /**
  232. * @see UserInterface
  233. */
  234. public function getRoles(): array
  235. {
  236. $roles = $this->roles;
  237. // guarantee every user at least has ROLE_USER
  238. $roles[] = 'ROLE_USER';
  240. return array_unique($roles);
  241. }
  243. public function setRoles(array $roles): self
  244. {
  245. $this->roles = $roles;
  247. return $this;
  248. }
  250. /**
  251. * @see UserInterface
  252. */
  253. public function getPassword(): string
  254. {
  255. return (string) $this->password;
  256. }
  258. public function setPassword(string $password): self
  259. {
  260. $this->password = $password;
  262. return $this;
  263. }
  265. /**
  266. * @see UserInterface
  267. */
  268. public function getSalt()
  269. {
  270. // not needed when using the "bcrypt" algorithm in security.yaml
  271. }
  273. /**
  274. * @see UserInterface
  275. */
  276. public function eraseCredentials()
  277. {
  278. // If you store any temporary, sensitive data on the user, clear it here
  279. // $this->plainPassword = null;
  280. }
  282. public function getEmail(): ?string
  283. {
  284. return $this->email;
  285. }
  287. public function setEmail(string $email): self
  288. {
  289. $this->email = $email;
  291. return $this;
  292. }
  294. public function getCreatedAt(): ?\DateTimeInterface
  295. {
  296. return $this->created_at;
  297. }
  299. public function setCreatedAt(\DateTimeInterface $created_at): self
  300. {
  301. $this->created_at = $created_at;
  303. return $this;
  304. }
  306. /**
  307. * Gets triggered only on insert
  309. * @ORM\PrePersist
  310. */
  311. public function setCreatedAtValue()
  312. {
  313. $this->setCreatedAt(new \DateTime());
  314. }
  316. /**
  317. * Gets triggered only on update
  319. * @ORM\PreUpdate
  320. */
  321. public function updateLastLoginValue(){
  322. $this->setLastLogin(new \DateTime());
  323. }
  325. public function getLastLogin(): ?\DateTimeInterface
  326. {
  327. return $this->last_login;
  328. }
  330. public function setLastLogin(?\DateTimeInterface $last_login): self
  331. {
  332. $this->last_login = $last_login;
  334. return $this;
  335. }
  337. /**
  338. * @param Bool $showDeleted
  339. * @return Collection|Contact[]
  340. */
  341. public function getContacts(bool $showDeleted = false): Collection
  342. {
  343. if($showDeleted){
  344. return $this->contacts;
  345. } else {
  346. return $this->contacts->filter(function(Contact $contact){
  347. return $contact->getStatus() != 'deleted' && $contact->getStatus() != 'unsubscribed';
  348. });
  349. }
  350. }
  352. /**
  353. * @param String $status
  354. * @return Collection|Contact[]
  355. */
  356. public function getContactsByStatus($status): Collection
  357. {
  358. $criteria = Criteria::create()->where(Criteria::expr()->eq('status', $status));
  360. return $this->getContacts(true)->matching($criteria);
  361. }
  363. public function addContact(Contact $contact): self
  364. {
  365. if (!$this->contacts->contains($contact)) {
  366. $this->contacts[] = $contact;
  367. $contact->setUser($this);
  368. }
  370. return $this;
  371. }
  373. public function removeContact(Contact $contact): self
  374. {
  375. if ($this->contacts->contains($contact)) {
  376. $this->contacts->removeElement($contact);
  377. // set the owning side to null (unless already changed)
  378. if ($contact->getUser() === $this) {
  379. $contact->setUser(null);
  380. }
  381. }
  383. return $this;
  384. }
  386. /**
  387. * @return Collection|Email[]
  388. */
  389. public function getEmails(): Collection
  390. {
  391. return $this->emails;
  392. }
  394. public function addEmail(Email $email): self
  395. {
  396. if (!$this->emails->contains($email)) {
  397. $this->emails[] = $email;
  398. $email->setUser($this);
  399. }
  401. return $this;
  402. }
  404. public function removeEmail(Email $email): self
  405. {
  406. if ($this->emails->contains($email)) {
  407. $this->emails->removeElement($email);
  408. // set the owning side to null (unless already changed)
  409. if ($email->getUser() === $this) {
  410. $email->setUser(null);
  411. }
  412. }
  414. return $this;
  415. }
  417. /**
  418. * @return Collection|Campaign[]
  419. */
  420. public function getCampaigns(): Collection
  421. {
  422. return $this->campaigns;
  423. }
  425. /**
  426. * @return Collection|Campaign[]
  427. */
  428. public function getActiveCampaigns(): Collection
  429. {
  430. return $this->campaigns->filter(function(Campaign $campaign){
  431. return $campaign->getActive() === true;
  432. });
  433. }
  435. /**
  436. * @return Collection|Campaign[]
  437. */
  438. public function getCampaignsToSend(): Collection
  439. {
  440. return $this->campaigns->filter(function(Campaign $campaign){
  441. return ($campaign->getActive() === true && $campaign->isSent() === false);
  442. });
  443. }
  445. public function addCampaign(Campaign $campaign): self
  446. {
  447. if (!$this->campaigns->contains($campaign)) {
  448. $this->campaigns[] = $campaign;
  449. $campaign->setUser($this);
  450. }
  452. return $this;
  453. }
  455. public function removeCampaign(Campaign $campaign): self
  456. {
  457. if ($this->campaigns->contains($campaign)) {
  458. $this->campaigns->removeElement($campaign);
  459. // set the owning side to null (unless already changed)
  460. if ($campaign->getUser() === $this) {
  461. $campaign->setUser(null);
  462. }
  463. }
  465. return $this;
  466. }
  468. /**
  469. * @return Collection|ContactGroup[]
  470. */
  471. public function getContactGroups(): Collection
  472. {
  473. return $this->contactGroups;
  474. }
  476. public function addContactGroup(ContactGroup $contactGroup): self
  477. {
  478. if (!$this->contactGroups->contains($contactGroup)) {
  479. $this->contactGroups[] = $contactGroup;
  480. $contactGroup->setUser($this);
  481. }
  483. return $this;
  484. }
  486. public function removeContactGroup(ContactGroup $contactGroup): self
  487. {
  488. if ($this->contactGroups->contains($contactGroup)) {
  489. $this->contactGroups->removeElement($contactGroup);
  490. // set the owning side to null (unless already changed)
  491. if ($contactGroup->getUser() === $this) {
  492. $contactGroup->setUser(null);
  493. }
  494. }
  496. return $this;
  497. }
  499. public function getCompany(): ?string
  500. {
  501. return $this->company;
  502. }
  504. public function setCompany(string $company): self
  505. {
  506. $this->company = $company;
  508. return $this;
  509. }
  511. public function getWebsite(): ?string
  512. {
  513. return $this->website;
  514. }
  516. public function setWebsite(?string $website): self
  517. {
  518. $this->website = $website;
  520. return $this;
  521. }
  523. public function getLogo(): ?string
  524. {
  525. return $this->logo;
  526. }
  528. public function setLogo(?string $logo): self
  529. {
  530. $this->logo = $logo;
  532. return $this;
  533. }
  535. public function getLogoFile(): ?File
  536. {
  537. return $this->logo_file;
  538. }
  540. /**
  541. * If manually uploading a file (i.e. not using Symfony Form) ensure an instance
  542. * of 'UploadedFile' is injected into this setter to trigger the update. If this
  543. * bundle's configuration parameter 'inject_on_load' is set to 'true' this setter
  544. * must be able to accept an instance of 'File' as the bundle will inject one here
  545. * during Doctrine hydration.
  546. *
  547. * @param File|\Symfony\Component\HttpFoundation\File\UploadedFile $imageFile
  548. */
  549. public function setLogoFile(?File $imageFile = null): void
  550. {
  551. $this->logo_file = $imageFile;
  553. if (null !== $imageFile) {
  554. // It is required that at least one field changes if you are using doctrine
  555. // otherwise the event listeners won't be called and the file is lost
  556. $this->updated_at = new \DateTimeImmutable();
  557. }
  558. }
  560. public function getUpdatedAt(): ?\DateTimeInterface
  561. {
  562. return $this->updated_at;
  563. }
  565. public function setUpdatedAt(\DateTimeInterface $updated_at): self
  566. {
  567. $this->updated_at = $updated_at;
  569. return $this;
  570. }
  572. public function serialize()
  573. {
  574. return serialize([
  575. $this->id,
  576. $this->username,
  577. $this->password,
  578. $this->roles,
  579. $this->email,
  580. $this->created_at,
  581. $this->updated_at,
  582. $this->last_login,
  583. //$this->contacts,
  584. $this->emails,
  585. //$this->campaigns,
  586. //$this->contactGroups,
  587. $this->website,
  588. $this->company,
  589. $this->logo
  590. ]);
  591. }
  593. public function unserialize($serialized)
  594. {
  595. list(
  596. $this->id,
  597. $this->username,
  598. $this->password,
  599. $this->roles,
  600. $this->email,
  601. $this->created_at,
  602. $this->updated_at,
  603. $this->last_login,
  604. //$this->contacts,
  605. $this->emails,
  606. //$this->campaigns,
  607. //$this->contactGroups,
  608. $this->website,
  609. $this->company,
  610. $this->logo
  611. ) = unserialize($serialized);
  612. }
  614. public function getAddress(): ?string
  615. {
  616. return $this->address;
  617. }
  619. public function setAddress(string $address): self
  620. {
  621. $this->address = $address;
  623. return $this;
  624. }
  626. public function getFromAddress(): ?string
  627. {
  628. return $this->from_address;
  629. }
  631. public function setFromAddress(string $from_address): self
  632. {
  633. $this->from_address = $from_address;
  635. return $this;
  636. }
  638. /**
  639. * @return Collection|ApiToken[]
  640. */
  641. public function getApiTokens(): Collection
  642. {
  643. return $this->apiTokens;
  644. }
  646. public function addApiToken(ApiToken $apiToken): self
  647. {
  648. if (!$this->apiTokens->contains($apiToken)) {
  649. $this->apiTokens[] = $apiToken;
  650. $apiToken->setUser($this);
  651. }
  653. return $this;
  654. }
  656. public function removeApiToken(ApiToken $apiToken): self
  657. {
  658. if ($this->apiTokens->contains($apiToken)) {
  659. $this->apiTokens->removeElement($apiToken);
  660. // set the owning side to null (unless already changed)
  661. if ($apiToken->getUser() === $this) {
  662. $apiToken->setUser(null);
  663. }
  664. }
  666. return $this;
  667. }
  669. /**
  670. * @return Collection|Form[]
  671. */
  672. public function getForms(): Collection
  673. {
  674. return $this->forms;
  675. }
  677. public function addForm(Form $form): self
  678. {
  679. if (!$this->forms->contains($form)) {
  680. $this->forms[] = $form;
  681. $form->setUser($this);
  682. }
  684. return $this;
  685. }
  687. public function removeForm(Form $form): self
  688. {
  689. if ($this->forms->contains($form)) {
  690. $this->forms->removeElement($form);
  691. // set the owning side to null (unless already changed)
  692. if ($form->getUser() === $this) {
  693. $form->setUser(null);
  694. }
  695. }
  697. return $this;
  698. }
  700. public function getSendCount(): ?array
  701. {
  702. if(is_array($this->send_count) && count($this->send_count) === 31){
  703. return $this->send_count;
  704. } else {
  705. return [];
  706. }
  707. }
  709. public function resetSendCount(): self
  710. {
  711. $sendCount = array();
  712. for($i = 0; $i < 31; $i++){
  713. $sendCount[] = 0;
  714. }
  715. $this->setSendCount($sendCount);
  716. return $this;
  717. }
  719. public function setSendCount(array $send_count): self
  720. {
  721. $this->send_count = $send_count;
  722. return $this;
  723. }
  725. public function getPlan(): ?Plan
  726. {
  727. return $this->plan;
  728. }
  730. public function setPlan(?Plan $plan): self
  731. {
  732. $this->plan = $plan;
  734. return $this;
  735. }
  737. public function updatePlan(?Plan $plan): self
  738. {
  739. /** @var Plan $currentPlan */
  740. $currentPlan = $this->plan;
  742. // if upgrade
  743. if ($plan->getMonthlyLimit() > $currentPlan->getMonthlyLimit()) {
  744. $this->plan = $plan;
  745. } else {
  746. // TODO if downgrade, only change plan at the end of plan cycle?
  747. $this->plan = $plan;
  748. }
  750. return $this;
  751. }
  753. public function increaseSendCount(int $add = 1): self
  754. {
  755. // Get daily counts array
  756. $sendCount = $this->getSendCount();
  758. // Get last element of send count, increase count and put it back in array
  759. $latestCount = array_pop($sendCount);
  760. $sendCount[] = $latestCount + $add;
  762. $this->setSendCount($sendCount);
  764. return $this;
  765. }
  767. public function sendingAllowanceBalanced(): array
  768. {
  769. $allowance = array();
  771. $plan = $this->getPlan();
  772. $sendCount = $this->getSendCount();
  774. if($plan->getDailyLimit() != 0){
  775. $dayCount = $sendCount[count($sendCount) - 1];
  776. $allowance['day'] = $dayAllowance = $plan->getDailyLimit() - $dayCount;
  777. }
  779. if($plan->getWeeklyLimit() != 0){
  780. $i = count($sendCount) - 1;
  781. $weekCount = 0;
  782. while($i >= count($sendCount) - 7){
  783. $weekCount += $sendCount[$i];
  784. $i--;
  785. }
  786. $allowance['week'] = $weekAllowance = $plan->getWeeklyLimit() - $weekCount;
  787. }
  789. if($plan->getMonthlyLimit() != 0){
  790. // Get number of days to this day the last month
  791. $today = new \DateTime();
  792. $monthAgo = new \DateTime();
  793. $monthAgo->sub(new \DateInterval('P1M'));
  794. $diff = date_diff($today, $monthAgo);
  795. $monthDays = $diff->days;
  797. $i = count($sendCount) - 1;
  798. $monthCount = 0;
  799. while($i >= count($sendCount) - $monthDays){
  800. $monthCount += $sendCount[$i];
  801. $i--;
  802. }
  803. $allowance['month'] = $monthAllowance = $plan->getMonthlyLimit() - $monthCount;
  804. }
  806. return $allowance;
  807. }
  809. public function sendingAllowanceCyclic(): array
  810. {
  811. $allowance = array();
  813. $plan = $this->getPlan();
  814. $sendCount = $this->getSendCount();
  816. $baseDate = $this->getCreatedAt();
  817. $now = new \DateTime();
  818. $baseDate->setTime(0,0);
  819. $now->setTime(0,0);
  821. $diff = $baseDate->diff($now);
  823. if($plan->getDailyLimit() != 0){
  824. $dayCount = $sendCount[count($sendCount) - 1];
  825. $allowance['day'] = $dayAllowance = $plan->getDailyLimit() - $dayCount;
  826. }
  828. if($plan->getWeeklyLimit() != 0){
  829. $i = count($sendCount) - 1;
  830. $weekCount = 0;
  831. while($i >= count($sendCount) - ($diff->days % 7)){
  832. $weekCount += $sendCount[$i];
  833. $i--;
  834. }
  835. $allowance['week'] = $weekAllowance = $plan->getWeeklyLimit() - $weekCount;
  836. }
  838. if($plan->getMonthlyLimit() != 0){
  839. $i = count($sendCount) - 1;
  840. $monthCount = 0;
  841. while($i >= count($sendCount) - ($diff->d)){
  842. $monthCount += $sendCount[$i];
  843. $i--;
  844. }
  845. $allowance['month'] = $monthAllowance = $plan->getMonthlyLimit() - $monthCount;
  846. }
  848. return $allowance;
  849. }
  851. public function sendingAllowanceCyclicDates(): array
  852. {
  853. $allowanceDates = array();
  855. $plan = $this->getPlan();
  856. $sendCount = $this->getSendCount();
  858. $baseDate = $this->getCreatedAt();
  859. $now = new \DateTime();
  860. $baseDate->setTime(0,0);
  861. $now->setTime(0,0);
  863. $diff = $baseDate->diff($now);
  865. if($plan->getDailyLimit() != 0){
  866. $dayDate = clone $now;
  867. $allowanceDates['day'] = $dayDate->add(new \DateInterval('P1D'));
  868. }
  870. if($plan->getWeeklyLimit() != 0){
  871. $weekDate = clone $now;
  872. $allowanceDates['week'] = $weekDate->add(new \DateInterval('P' . (7 - ($diff->days % 7)) . 'D'));
  873. }
  875. if($plan->getMonthlyLimit() != 0){
  876. $monthDate = clone $now;
  877. $allowanceDates['month'] = $monthDate->sub(new \DateInterval('P' . $diff->d . 'D'))->add(new \DateInterval('P1M'));
  878. }
  880. return $allowanceDates;
  882. }
  884. /**
  885. * @return Collection|Task[]
  886. */
  887. public function getTasks(): Collection
  888. {
  889. return $this->tasks;
  890. }
  892. /**
  893. * @return Collection|Task[]
  894. */
  895. public function getTasksNotUnfreeze(): Collection
  896. {
  897. return $this->tasks->filter(function (Task $task){
  898. return $task->getType() != Task::TYPE_CAMPAIGN_UNFREEZE;
  899. });
  900. }
  902. /**
  903. * @return Collection|Task[]
  904. */
  905. public function getPendingTasks(): Collection
  906. {
  907. return $this->tasks->filter(function (Task $task) {
  908. return !$task->isFinished();
  909. });
  910. }
  912. /**
  913. * @return Collection|Task[]
  914. */
  915. public function getPendingTasksNotUnfreeze(): Collection
  916. {
  917. return $this->tasks->filter(function (Task $task) {
  918. return !$task->isFinished() && $task->getType() != Task::TYPE_CAMPAIGN_UNFREEZE;
  919. });
  920. }
  922. /**
  923. * @return Collection|Task[]
  924. */
  925. public function getFinishedTasks(): Collection
  926. {
  927. return $this->tasks->filter(function (Task $task){
  928. return $task->isFinished();
  929. });
  930. }
  932. /**
  933. * @return Collection|Task[]
  934. */
  935. public function getFinishedTasksNotUnfreeze(): Collection
  936. {
  937. return $this->tasks->filter(function (Task $task){
  938. return $task->isFinished() && $task->getType() != Task::TYPE_CAMPAIGN_UNFREEZE;
  939. });
  940. }
  942. public function addTask(Task $task): self
  943. {
  944. if (!$this->tasks->contains($task)) {
  945. $this->tasks[] = $task;
  946. $task->setUser($this);
  947. }
  949. return $this;
  950. }
  952. public function removeTask(Task $task): self
  953. {
  954. if ($this->tasks->contains($task)) {
  955. $this->tasks->removeElement($task);
  956. // set the owning side to null (unless already changed)
  957. if ($task->getUser() === $this) {
  958. $task->setUser(null);
  959. }
  960. }
  962. return $this;
  963. }
  965. /**
  966. * @return Collection|Notification[]
  967. */
  968. public function getNotifications(): Collection
  969. {
  970. return $this->notifications;
  971. }
  973. public function addNotification(Notification $notification): self
  974. {
  975. if (!$this->notifications->contains($notification)) {
  976. $this->notifications[] = $notification;
  977. $notification->setUser($this);
  978. }
  980. return $this;
  981. }
  983. public function removeNotification(Notification $notification): self
  984. {
  985. if ($this->notifications->contains($notification)) {
  986. $this->notifications->removeElement($notification);
  987. // set the owning side to null (unless already changed)
  988. if ($notification->getUser() === $this) {
  989. $notification->setUser(null);
  990. }
  991. }
  993. return $this;
  994. }
  996. /**
  997. * @return Collection|EmailTemplate[]
  998. */
  999. public function getEmailTemplates(?bool $publishedOnly, ?string $version): Collection
  1000. {
  1001. $emailTemplates = $this->emailTemplates;
  1002. if ($publishedOnly === true) $emailTemplates = $emailTemplates->matching(EmailTemplateRepository::isPublishedCriteria());
  1003. if (isset($version)) $emailTemplates = $emailTemplates->matching(EmailTemplateRepository::editorVersionCriteria($version));
  1004. return $emailTemplates;
  1005. }
  1007. public function addEmailTemplate(EmailTemplate $emailTemplate): self
  1008. {
  1009. if (!$this->emailTemplates->contains($emailTemplate)) {
  1010. $this->emailTemplates[] = $emailTemplate;
  1011. $emailTemplate->setUser($this);
  1012. }
  1014. return $this;
  1015. }
  1017. public function removeEmailTemplate(EmailTemplate $emailTemplate): self
  1018. {
  1019. if ($this->emailTemplates->contains($emailTemplate)) {
  1020. $this->emailTemplates->removeElement($emailTemplate);
  1021. // set the owning side to null (unless already changed)
  1022. if ($emailTemplate->getUser() === $this) {
  1023. $emailTemplate->setUser(null);
  1024. }
  1025. }
  1027. return $this;
  1028. }
  1030. /**
  1031. * @return Collection|Upload[]
  1032. */
  1033. public function getUploads(): Collection
  1034. {
  1035. return $this->uploads;
  1036. }
  1038. public function addUpload(Upload $upload): self
  1039. {
  1040. if (!$this->uploads->contains($upload)) {
  1041. $this->uploads[] = $upload;
  1042. $upload->setUser($this);
  1043. }
  1045. return $this;
  1046. }
  1048. public function removeUpload(Upload $upload): self
  1049. {
  1050. if ($this->uploads->contains($upload)) {
  1051. $this->uploads->removeElement($upload);
  1052. // set the owning side to null (unless already changed)
  1053. if ($upload->getUser() === $this) {
  1054. $upload->setUser(null);
  1055. }
  1056. }
  1058. return $this;
  1059. }
  1061. public function getStatus(): ?string
  1062. {
  1063. return $this->status;
  1064. }
  1066. public function setStatus(string $status): self
  1067. {
  1068. $this->status = $status;
  1070. return $this;
  1071. }
  1073. /**
  1074. * @return Collection|Domain[]
  1075. */
  1076. public function getDomains(): Collection
  1077. {
  1078. return $this->domains;
  1079. }
  1081. public function addDomain(Domain $domain): self
  1082. {
  1083. if (!$this->domains->contains($domain)) {
  1084. $this->domains[] = $domain;
  1085. $domain->setUser($this);
  1086. }
  1088. return $this;
  1089. }
  1091. public function removeDomain(Domain $domain): self
  1092. {
  1093. if ($this->domains->removeElement($domain)) {
  1094. // set the owning side to null (unless already changed)
  1095. if ($domain->getUser() === $this) {
  1096. $domain->setUser(null);
  1097. }
  1098. }
  1100. return $this;
  1101. }
  1103. public function getCustomFields(): ?CustomFields
  1104. {
  1105. return $this->customFields;
  1106. }
  1108. public function setCustomFields(CustomFields $customFields): self
  1109. {
  1110. // set the owning side of the relation if necessary
  1111. if ($customFields->getUser() !== $this) {
  1112. $customFields->setUser($this);
  1113. }
  1115. $this->customFields = $customFields;
  1117. return $this;
  1118. }
  1120. /**
  1121. * @return Collection<int, Addon>
  1122. */
  1123. public function getAddons(): Collection
  1124. {
  1125. return $this->addons;
  1126. }
  1128. /**
  1129. * @return $this
  1130. */
  1131. public function clearAddons() : self
  1132. {
  1133. $this->addons->clear();
  1134. return $this;
  1135. }
  1137. public function addAddon(Addon $addon): self
  1138. {
  1139. if (!$this->addons->contains($addon)) {
  1140. $this->addons[] = $addon;
  1141. }
  1143. return $this;
  1144. }
  1146. public function removeAddon(Addon $addon): self
  1147. {
  1148. $this->addons->removeElement($addon);
  1150. return $this;
  1151. }
  1153. public function hasAddon($addon) : bool
  1154. {
  1155. if ($addon instanceof Addon) {
  1156. return $this->addons->contains($addon);
  1157. } else {
  1158. foreach ($this->addons as $userAddon) {
  1159. if ($userAddon->getName() === $addon) {
  1160. return true;
  1161. }
  1162. }
  1163. return false;
  1164. }
  1165. }
  1167. }