src/Entity/Accounts.php line 38

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use ApiPlatform\Metadata\ApiResource;
  6. use App\Repository\AccountsRepository;
  7. use Doctrine\Common\Collections\ArrayCollection;
  8. use Doctrine\Common\Collections\Collection;
  9. use Doctrine\DBAL\Types\Types;
  10. use Doctrine\ORM\Mapping as ORM;
  11. use ApiPlatform\Metadata\ApiFilter;
  12. use ApiPlatform\Doctrine\Orm\Filter\SearchFilter;
  13. use Symfony\Component\Serializer\Annotation\Groups;
  14. use Symfony\Component\Serializer\Annotation\MaxDepth;
  15. use ApiPlatform\Core\Annotation\ApiProperty;
  19. #[ORM\Entity(repositoryClass: AccountsRepository::class)]
  20. #[ApiResource(
  21.     normalizationContext: ['groups' => ['account:read']],
  22.     denormalizationContext: ['groups' => ['account:write']],
  23.     order: ['id' => 'DESC'],
  24. )]
  25. #[ApiFilter(SearchFilter::class, properties: [
  26.     'name' => 'ipartial', 
  27.     'code1c' => 'exact',
  28.     'edrpou' => 'exact', 
  29.     'user.id' => 'exact', 
  30.     'manager.id' => 'exact', 
  31.     'manager.firstName' => 'ipartial',
  32.     'phone' => 'exact',
  33.     'accountJobsLists.id' => 'exact',
  34.     'accountJobsLists.name' => 'exact',
  35.     'accountJobsLists.status' => 'exact',
  36.     ])]
  38. class Accounts
  39. {
  40.     #[ORM\Id]
  41.     #[ORM\GeneratedValue]
  42.     #[ORM\Column]
  43.     #[Groups(['account:read', 'order:read', 'order_product:read', 'pre_order_product:read', 'pre_order:read', 'load_invoice:read', 'load_invocie:read', 'read', 'account:write', 'write', 'agreements:read', 'user:read', 'job:read', 'worker:read', 'account_job:read', 'account_worker:read'])]
  44.     private ?int $id = null;
  46.     #[ORM\Column(length: 255)]
  47.     #[Groups(['account:read', 'order:read', 'order_product:read', 'pre_order_product:read', 'pre_order:read', 'load_invoice:read', 'load_invocie:read', 'read', 'account:write', 'write', 'agreements:read', 'user:read', 'job:read', 'worker:read', 'account_job:read', 'account_worker:read'])]
  48.     private ?string $name = null;
  50.     #[Groups(['account:read', 'read', 'account:write', 'write'])]
  51.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  52.     private ?\DateTimeInterface $date_entered = null;
  54.     #[Groups(['account:read', 'read', 'account:write', 'write'])]
  55.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  56.     private ?\DateTimeInterface $date_modified = null;
  58.     #[Groups(['account:read', 'read', 'account:write', 'write'])]
  59.     #[ORM\Column(nullable: true)]
  60.     private ?int $modified_user_id = null;
  62.     #[Groups(['account:read', 'read', 'account:write', 'write'])]
  63.     #[ORM\Column(nullable: true)]
  64.     private ?int $created_by = null;
  66.     #[Groups(['account:read', 'read', 'account:write', 'write'])]
  67.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  68.     private ?string $description = null;
  70.     #[ORM\Column(nullable: true)]
  71.     private ?int $deleted = null;
  73.     #[Groups(['account:read', 'read', 'account:write', 'write'])]
  74.     #[ORM\Column(nullable: true)]
  75.     private ?int $assigned_user_id = null;
  77.     #[Groups(['account:read', 'read', 'account:write', 'write', 'user:read', 'account_job:read', 'account_worker:read'])]
  78.     #[ORM\Column(length: 100, nullable: true)]
  79.     private ?string $edrpou = null;
  81.     #[Groups(['account:read', 'read', 'account:write', 'write', 'user:read'])]
  82.     #[ORM\Column(length: 255, nullable: true)]
  83.     private ?string $billing_address_city = null;
  85.     #[Groups(['account:read', 'read', 'account:write', 'write', 'user:read'])]
  86.     #[ORM\Column(length: 255, nullable: true)]
  87.     private ?string $billing_address_state = null;
  89.     #[Groups(['account:read', 'read', 'account:write', 'write', 'user:read'])]
  90.     #[ORM\Column(length: 255, nullable: true)]
  91.     private ?string $billing_address_country = null;
  93.     #[Groups(['account:read', 'read', 'account:write', 'write', 'user:read'])]
  94.     #[ORM\Column(length: 255, nullable: true)]
  95.     private ?string $billing_address_street = null;
  97.     #[Groups(['account:read', 'read', 'account:write', 'write', 'user:read'])]
  98.     #[ORM\Column(length: 50, nullable: true)]
  99.     private ?string $phone = null;
  101.     #[Groups(['read', 'account:write', 'write'])]
  102.     #[ORM\OneToMany(mappedBy: 'account', targetEntity: Orders::class, cascade:['persist', 'remove'])]
  103.     private Collection $orders;
  105.     #[MaxDepth(1)]
  106.     #[ApiProperty(writable: true)]
  107.     #[ORM\ManyToOne(inversedBy: 'accounts')]
  108.     #[Groups(['account:read', 'account:write', 'write'])]
  109.     private ?User $user = null;
  111.     #[Groups(['read', 'account:write', 'write'])]
  112.     #[ORM\OneToMany(mappedBy: 'supplier', targetEntity: IncomingInvoice::class, cascade:['persist', 'remove'])]
  113.     private Collection $invoice_supplier;
  115.     #[Groups(['account:read', 'read', 'account:write', 'write', 'user:read'])]
  116.     #[ORM\Column(length: 100, nullable: true)]
  117.     private ?string $ipn = null;
  119.     #[Groups(['account:read', 'read', 'account:write', 'write', 'user:read'])]
  120.     #[ORM\Column(length: 20, nullable: true)]
  121.     private ?string $type = null;
  123.     #[MaxDepth(1)]
  124.     #[Groups(['account:read', 'read', 'account:write', 'write'])]
  125.     #[ORM\ManyToOne(targetEntity: self::class, inversedBy: 'accounts')]
  126.     private ?self $parent = null;
  128.     #[Groups(['account:write'])]
  129.     #[MaxDepth(2)]
  130.     #[ORM\OneToMany(mappedBy: 'parent', targetEntity: self::class)]
  131.     private Collection $accounts;
  133.     #[Groups(['account:read', 'read', 'account:write', 'write'])]
  134.     #[ORM\Column(length: 100, nullable: true)]
  135.     private ?string $director = null;
  137.     #[Groups(['account:read', 'order:read', 'order_product:read', 'pre_order_product:read', 'pre_order:read', 'load_invoice:read', 'load_invocie:read', 'read', 'account:write', 'write', 'user:read', 'worker:read', 'job:read', 'account_job:read', 'account_worker:read'])]
  138.     #[ORM\Column(length: 20, nullable: true)]
  139.     private ?string $code1c = '';
  141.     #[Groups(['account:read', 'read', 'account:write', 'write'])]
  142.     #[ORM\OneToMany(mappedBy: 'account', targetEntity: Contacts::class, cascade:['persist', 'remove'])]
  143.     private Collection $contacts;
  145.     #[MaxDepth(1)]
  146.     #[ORM\ManyToOne(inversedBy: 'managerAccounts')]
  147.     #[Groups(['account:read', 'account:write', 'order:read',  'pre_order:read'])]
  148.     private ?User $manager = null;
  150.     #[Groups(['read', 'account:write', 'write'])]
  151.     #[MaxDepth(2)]
  152.     #[ORM\OneToMany(mappedBy: 'account', targetEntity: PreOrder::class)]
  153.     private Collection $preOrders;
  155.     #[ORM\OneToMany(mappedBy: 'account', targetEntity: LoadInvoice::class)]
  156.     private Collection $loadInvoices;
  158.     #[ORM\OneToMany(mappedBy: 'organization', targetEntity: Agreements::class)]
  159.     private Collection $organization;
  161.     #[Groups(['account:read', 'read', 'account:write', 'write','user:read', 'worker:read', 'job:read'])]
  162.     #[ORM\OneToMany(mappedBy: 'account', targetEntity: Agreements::class, cascade:['persist', 'remove'])]
  163.     private Collection $agreements;
  165.     #[Groups(['account:read', 'account:write'])]
  166.     #[ORM\ManyToOne(inversedBy: 'accounts')]
  167.     private ?Agreements $virtualAgreementSpecfication = null;
  169.     #[Groups(['account:read', 'account:write'])]
  170.     #[ORM\OneToMany(mappedBy: 'account', targetEntity: AccountAddress::class)]
  171.     private Collection $accountAddresses;
  173.     #[ORM\OneToMany(mappedBy: 'account', targetEntity: AccountWorker::class, orphanRemoval: true)]
  174.     private Collection $accountWorkers;
  176.     #[ORM\OneToMany(mappedBy: 'account', targetEntity: Jobs::class)]
  177.     private Collection $jobs;
  179.     #[ORM\OneToMany(mappedBy: 'account', targetEntity: AccountJobsList::class)]
  180.     private Collection $accountJobsLists;
  182.     public function __construct()
  183.     {
  184.         $this->orders = new ArrayCollection();
  185.         $this->invoice_supplier = new ArrayCollection();
  186.         $this->accounts = new ArrayCollection();
  187.         $this->contacts = new ArrayCollection();
  188.         $this->preOrders = new ArrayCollection();
  189.         $this->loadInvoices = new ArrayCollection();
  190.         $this->organization = new ArrayCollection();
  191.         $this->agreements = new ArrayCollection();
  192.         $this->accountAddresses = new ArrayCollection();
  193.         $this->accountWorkers = new ArrayCollection();
  194.         $this->jobs = new ArrayCollection();
  195.         $this->accountJobsLists = new ArrayCollection();
  196.     }
  198.     public function getId(): ?int
  199.     {
  200.         return $this->id;
  201.     }
  203.     public function getName(): ?string
  204.     {
  205.         return $this->name;
  206.     }
  208.     public function setName(string $name): self
  209.     {
  210.         $this->name = $name;
  212.         return $this;
  213.     }
  215.     public function getDateEntered(): ?\DateTimeInterface
  216.     {
  217.         return $this->date_entered;
  218.     }
  220.     public function setDateEntered(?\DateTimeInterface $date_entered): self
  221.     {
  222.         $this->date_entered = $date_entered;
  224.         return $this;
  225.     }
  227.     public function getDateModified(): ?\DateTimeInterface
  228.     {
  229.         return $this->date_modified;
  230.     }
  232.     public function setDateModified(?\DateTimeInterface $date_modified): self
  233.     {
  234.         $this->date_modified = $date_modified;
  236.         return $this;
  237.     }
  239.     public function getModifiedUserId(): ?int
  240.     {
  241.         return $this->modified_user_id;
  242.     }
  244.     public function setModifiedUserId(?int $modified_user_id): self
  245.     {
  246.         $this->modified_user_id = $modified_user_id;
  248.         return $this;
  249.     }
  251.     public function getCreatedBy(): ?int
  252.     {
  253.         return $this->created_by;
  254.     }
  256.     public function setCreatedBy(int $created_by): self
  257.     {
  258.         $this->created_by = $created_by;
  260.         return $this;
  261.     }
  263.     public function getDescription(): ?string
  264.     {
  265.         return $this->description;
  266.     }
  268.     public function setDescription(?string $description): self
  269.     {
  270.         $this->description = $description;
  272.         return $this;
  273.     }
  275.     public function getDeleted(): ?int
  276.     {
  277.         return $this->deleted;
  278.     }
  280.     public function setDeleted(?int $deleted): self
  281.     {
  282.         $this->deleted = $deleted;
  284.         return $this;
  285.     }
  287.     public function getAssignedUserId(): ?int
  288.     {
  289.         return $this->assigned_user_id;
  290.     }
  292.     public function setAssignedUserId(?int $assigned_user_id): self
  293.     {
  294.         $this->assigned_user_id = $assigned_user_id;
  296.         return $this;
  297.     }
  299.     public function getEdrpou(): ?string
  300.     {
  301.         return $this->edrpou;
  302.     }
  304.     public function setEdrpou(?string $edrpou): self
  305.     {
  306.         $this->edrpou = $edrpou;
  308.         return $this;
  309.     }
  311.     public function getBillingAddressCity(): ?string
  312.     {
  313.         return $this->billing_address_city;
  314.     }
  316.     public function setBillingAddressCity(?string $billing_address_city): self
  317.     {
  318.         $this->billing_address_city = $billing_address_city;
  320.         return $this;
  321.     }
  323.     public function getBillingAddressState(): ?string
  324.     {
  325.         return $this->billing_address_state;
  326.     }
  328.     public function setBillingAddressState(?string $billing_address_state): self
  329.     {
  330.         $this->billing_address_state = $billing_address_state;
  332.         return $this;
  333.     }
  335.     public function getBillingAddressCountry(): ?string
  336.     {
  337.         return $this->billing_address_country;
  338.     }
  340.     public function setBillingAddressCountry(?string $billing_address_country): self
  341.     {
  342.         $this->billing_address_country = $billing_address_country;
  344.         return $this;
  345.     }
  347.     public function getBillingAddressStreet(): ?string
  348.     {
  349.         return $this->billing_address_street;
  350.     }
  352.     public function setBillingAddressStreet(?string $billing_address_street): self
  353.     {
  354.         $this->billing_address_street = $billing_address_street;
  356.         return $this;
  357.     }
  359.     public function getPhone(): ?string
  360.     {
  361.         return $this->phone;
  362.     }
  364.     public function setPhone(?string $phone): self
  365.     {
  366.         $this->phone = $phone;
  368.         return $this;
  369.     }
  371.     /**
  372.      * @return Collection<int, Orders>
  373.      */
  374.     public function getOrders(): Collection
  375.     {
  376.         return $this->orders;
  377.     }
  379.     public function addOrder(Orders $order): self
  380.     {
  381.         if (!$this->orders->contains($order)) {
  382.             $this->orders->add($order);
  383.             $order->setAccountId($this);
  384.         }
  386.         return $this;
  387.     }
  389.     public function removeOrder(Orders $order): self
  390.     {
  391.         if ($this->orders->removeElement($order)) {
  392.             // set the owning side to null (unless already changed)
  393.             if ($order->getAccountId() === $this) {
  394.                 $order->setAccountId(null);
  395.             }
  396.         }
  398.         return $this;
  399.     }
  401.     public function getUser(): ?User
  402.     {
  403.         return $this->user;
  404.     }
  406.     public function setUser(?User $user): self
  407.     {
  408.         $this->user = $user;
  410.         return $this;
  411.     }
  413.     /**
  414.      * @return Collection<int, IncomingInvoice>
  415.      */
  416.     public function getInvoiceSupplier(): Collection
  417.     {
  418.         return $this->invoice_supplier;
  419.     }
  421.     public function addInvoiceSupplier(IncomingInvoice $invoiceSupplier): self
  422.     {
  423.         if (!$this->invoice_supplier->contains($invoiceSupplier)) {
  424.             $this->invoice_supplier->add($invoiceSupplier);
  425.             $invoiceSupplier->setSupplier($this);
  426.         }
  428.         return $this;
  429.     }
  431.     public function removeInvoiceSupplier(IncomingInvoice $invoiceSupplier): self
  432.     {
  433.         if ($this->invoice_supplier->removeElement($invoiceSupplier)) {
  434.             // set the owning side to null (unless already changed)
  435.             if ($invoiceSupplier->getSupplier() === $this) {
  436.                 $invoiceSupplier->setSupplier(null);
  437.             }
  438.         }
  440.         return $this;
  441.     }
  443.     public function getIpn(): ?string
  444.     {
  445.         return $this->ipn;
  446.     }
  448.     public function setIpn(?string $ipn): self
  449.     {
  450.         $this->ipn = $ipn;
  452.         return $this;
  453.     }
  455.     public function getType(): ?string
  456.     {
  457.         return $this->type;
  458.     }
  460.     public function setType(?string $type): self
  461.     {
  462.         $this->type = $type;
  464.         return $this;
  465.     }
  467.     public function getParent(): ?self
  468.     {
  469.         return $this->parent;
  470.     }
  472.     public function setParent(?self $parent): self
  473.     {
  474.         $this->parent = $parent;
  476.         return $this;
  477.     }
  479.     /**
  480.      * @return Collection<int, self>
  481.      */
  482.     public function getAccounts(): Collection
  483.     {
  484.         return $this->accounts;
  485.     }
  487.     public function addAccount(self $account): self
  488.     {
  489.         if (!$this->accounts->contains($account)) {
  490.             $this->accounts->add($account);
  491.             $account->setParent($this);
  492.         }
  494.         return $this;
  495.     }
  497.     public function removeAccount(self $account): self
  498.     {
  499.         if ($this->accounts->removeElement($account)) {
  500.             // set the owning side to null (unless already changed)
  501.             if ($account->getParent() === $this) {
  502.                 $account->setParent(null);
  503.             }
  504.         }
  506.         return $this;
  507.     }
  509.     public function getDirector(): ?string
  510.     {
  511.         return $this->director;
  512.     }
  514.     public function setDirector(?string $director): self
  515.     {
  516.         $this->director = $director;
  518.         return $this;
  519.     }
  521.     public function getCode1c(): ?string
  522.     {
  523.         return $this->code1c;
  524.     }
  526.     public function setCode1c(?string $code1c): self
  527.     {
  528.         $this->code1c = $code1c;
  530.         return $this;
  531.     }
  533.     /**
  534.      * @return Collection<int, Contacts>
  535.      */
  536.     public function getContacts(): Collection
  537.     {
  538.         return $this->contacts;
  539.     }
  541.     public function addContact(Contacts $contact): self
  542.     {
  543.         if (!$this->contacts->contains($contact)) {
  544.             $this->contacts->add($contact);
  545.             $contact->setAccount($this);
  546.         }
  548.         return $this;
  549.     }
  551.     public function removeContact(Contacts $contact): self
  552.     {
  553.         if ($this->contacts->removeElement($contact)) {
  554.             // set the owning side to null (unless already changed)
  555.             if ($contact->getAccount() === $this) {
  556.                 $contact->setAccount(null);
  557.             }
  558.         }
  560.         return $this;
  561.     }
  563.     public function getManager(): ?User
  564.     {
  565.         return $this->manager;
  566.     }
  568.     public function setManager(?User $manager): self
  569.     {
  570.         $this->manager = $manager;
  572.         return $this;
  573.     }
  575.     /**
  576.      * @return Collection<int, PreOrder>
  577.      */
  578.     public function getPreOrders(): Collection
  579.     {
  580.         return $this->preOrders;
  581.     }
  583.     public function addPreOrder(PreOrder $preOrder): self
  584.     {
  585.         if (!$this->preOrders->contains($preOrder)) {
  586.             $this->preOrders->add($preOrder);
  587.             $preOrder->setAccount($this);
  588.         }
  590.         return $this;
  591.     }
  593.     public function removePreOrder(PreOrder $preOrder): self
  594.     {
  595.         if ($this->preOrders->removeElement($preOrder)) {
  596.             // set the owning side to null (unless already changed)
  597.             if ($preOrder->getAccount() === $this) {
  598.                 $preOrder->setAccount(null);
  599.             }
  600.         }
  602.         return $this;
  603.     }
  605.     /**
  606.      * @return Collection<int, LoadInvoice>
  607.      */
  608.     public function getLoadInvoices(): Collection
  609.     {
  610.         return $this->loadInvoices;
  611.     }
  613.     public function addLoadInvoice(LoadInvoice $loadInvoice): self
  614.     {
  615.         if (!$this->loadInvoices->contains($loadInvoice)) {
  616.             $this->loadInvoices->add($loadInvoice);
  617.             $loadInvoice->setAccount($this);
  618.         }
  620.         return $this;
  621.     }
  623.     public function removeLoadInvoice(LoadInvoice $loadInvoice): self
  624.     {
  625.         if ($this->loadInvoices->removeElement($loadInvoice)) {
  626.             // set the owning side to null (unless already changed)
  627.             if ($loadInvoice->getAccount() === $this) {
  628.                 $loadInvoice->setAccount(null);
  629.             }
  630.         }
  632.         return $this;
  633.     }
  635.     /**
  636.      * @return Collection<int, Agreements>
  637.      */
  638.     public function getOrganization(): Collection
  639.     {
  640.         return $this->organization;
  641.     }
  643.     public function addOrganization(Agreements $organization): self
  644.     {
  645.         if (!$this->organization->contains($organization)) {
  646.             $this->organization->add($organization);
  647.             $organization->setOrganization($this);
  648.         }
  650.         return $this;
  651.     }
  653.     public function removeOrganization(Agreements $organization): self
  654.     {
  655.         if ($this->organization->removeElement($organization)) {
  656.             // set the owning side to null (unless already changed)
  657.             if ($organization->getOrganization() === $this) {
  658.                 $organization->setOrganization(null);
  659.             }
  660.         }
  662.         return $this;
  663.     }
  665.     /**
  666.      * @return Collection<int, Agreements>
  667.      */
  668.     public function getAgreements(): Collection
  669.     {
  670.         return $this->agreements;
  671.     }
  673.     public function addAgreement(Agreements $agreement): self
  674.     {
  675.         if (!$this->agreements->contains($agreement)) {
  676.             $this->agreements->add($agreement);
  677.             $agreement->setAccount($this);
  678.         }
  680.         return $this;
  681.     }
  683.     public function removeAgreement(Agreements $agreement): self
  684.     {
  685.         if ($this->agreements->removeElement($agreement)) {
  686.             // set the owning side to null (unless already changed)
  687.             if ($agreement->getAccount() === $this) {
  688.                 $agreement->setAccount(null);
  689.             }
  690.         }
  692.         return $this;
  693.     }
  695.     public function getVirtualAgreementSpecfication(): ?Agreements
  696.     {
  697.         return $this->virtualAgreementSpecfication;
  698.     }
  700.     public function setVirtualAgreementSpecfication(?Agreements $virtualAgreementSpecfication): static
  701.     {
  702.         $this->virtualAgreementSpecfication = $virtualAgreementSpecfication;
  704.         return $this;
  705.     }
  707.     /**
  708.      * @return Collection<int, AccountAddress>
  709.      */
  710.     public function getAccountAddresses(): Collection
  711.     {
  712.         return $this->accountAddresses;
  713.     }
  715.     public function addAccountAddress(AccountAddress $accountAddress): self
  716.     {
  717.         if (!$this->accountAddresses->contains($accountAddress)) {
  718.             $this->accountAddresses->add($accountAddress);
  719.             $accountAddress->setAccount($this);
  720.         }
  722.         return $this;
  723.     }
  725.     public function removeAccountAddress(AccountAddress $accountAddress): self
  726.     {
  727.         if ($this->accountAddresses->removeElement($accountAddress)) {
  728.             // set the owning side to null (unless already changed)
  729.             if ($accountAddress->getAccount() === $this) {
  730.                 $accountAddress->setAccount(null);
  731.             }
  732.         }
  734.         return $this;
  735.     }
  737.     /**
  738.      * @return Collection<int, AccountWorker>
  739.      */
  740.     public function getAccountWorkers(): Collection
  741.     {
  742.         return $this->accountWorkers;
  743.     }
  745.     public function addAccountWorker(AccountWorker $accountWorker): self
  746.     {
  747.         if (!$this->accountWorkers->contains($accountWorker)) {
  748.             $this->accountWorkers->add($accountWorker);
  749.             $accountWorker->setAccount($this);
  750.         }
  752.         return $this;
  753.     }
  755.     public function removeAccountWorker(AccountWorker $accountWorker): self
  756.     {
  757.         if ($this->accountWorkers->removeElement($accountWorker)) {
  758.             // set the owning side to null (unless already changed)
  759.             if ($accountWorker->getAccount() === $this) {
  760.                 $accountWorker->setAccount(null);
  761.             }
  762.         }
  764.         return $this;
  765.     }
  767.     /**
  768.      * @return Collection<int, Jobs>
  769.      */
  770.     public function getJobs(): Collection
  771.     {
  772.         return $this->jobs;
  773.     }
  775.     public function addJob(Jobs $job): self
  776.     {
  777.         if (!$this->jobs->contains($job)) {
  778.             $this->jobs->add($job);
  779.             $job->setAccount($this);
  780.         }
  782.         return $this;
  783.     }
  785.     public function removeJob(Jobs $job): self
  786.     {
  787.         if ($this->jobs->removeElement($job)) {
  788.             // set the owning side to null (unless already changed)
  789.             if ($job->getAccount() === $this) {
  790.                 $job->setAccount(null);
  791.             }
  792.         }
  794.         return $this;
  795.     }
  797.     /**
  798.      * @return Collection<int, AccountJobsList>
  799.      */
  800.     public function getAccountJobsLists(): Collection
  801.     {
  802.         return $this->accountJobsLists;
  803.     }
  805.     public function addAccountJobsList(AccountJobsList $accountJobsList): self
  806.     {
  807.         if (!$this->accountJobsLists->contains($accountJobsList)) {
  808.             $this->accountJobsLists->add($accountJobsList);
  809.             $accountJobsList->setAccount($this);
  810.         }
  812.         return $this;
  813.     }
  815.     public function removeAccountJobsList(AccountJobsList $accountJobsList): self
  816.     {
  817.         if ($this->accountJobsLists->removeElement($accountJobsList)) {
  818.             // set the owning side to null (unless already changed)
  819.             if ($accountJobsList->getAccount() === $this) {
  820.                 $accountJobsList->setAccount(null);
  821.             }
  822.         }
  824.         return $this;
  825.     }
  826. }