src/Entity/Accounts.php line 34

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.     'user.id' => 'exact', 
  29.     'manager.id' => 'exact', 
  30.     'manager.firstName' => 'ipartial',
  31.     'phone' => 'exact',
  32. ])]
  34. class Accounts
  35. {
  36.     #[ORM\Id]
  37.     #[ORM\GeneratedValue]
  38.     #[ORM\Column]
  39.     #[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'])]
  40.     private ?int $id = null;
  42.     #[ORM\Column(length: 255)]
  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'])]
  44.     private ?string $name = null;
  46.     #[Groups(['account:read', 'read', 'account:write', 'write'])]
  47.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  48.     private ?\DateTimeInterface $date_entered = null;
  50.     #[Groups(['account:read', 'read', 'account:write', 'write'])]
  51.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  52.     private ?\DateTimeInterface $date_modified = null;
  54.     #[Groups(['account:read', 'read', 'account:write', 'write'])]
  55.     #[ORM\Column(nullable: true)]
  56.     private ?int $modified_user_id = null;
  58.     #[Groups(['account:read', 'read', 'account:write', 'write'])]
  59.     #[ORM\Column(nullable: true)]
  60.     private ?int $created_by = null;
  62.     #[Groups(['account:read', 'read', 'account:write', 'write'])]
  63.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  64.     private ?string $description = null;
  66.     #[ORM\Column(nullable: true)]
  67.     private ?int $deleted = null;
  69.     #[Groups(['account:read', 'read', 'account:write', 'write'])]
  70.     #[ORM\Column(nullable: true)]
  71.     private ?int $assigned_user_id = null;
  73.     #[Groups(['account:read', 'read', 'account:write', 'write', 'user:read'])]
  74.     #[ORM\Column(length: 100, nullable: true)]
  75.     private ?string $edrpou = null;
  77.     #[Groups(['account:read', 'read', 'account:write', 'write', 'user:read'])]
  78.     #[ORM\Column(length: 255, nullable: true)]
  79.     private ?string $billing_address_city = null;
  81.     #[Groups(['account:read', 'read', 'account:write', 'write', 'user:read'])]
  82.     #[ORM\Column(length: 255, nullable: true)]
  83.     private ?string $billing_address_state = null;
  85.     #[Groups(['account:read', 'read', 'account:write', 'write', 'user:read'])]
  86.     #[ORM\Column(length: 255, nullable: true)]
  87.     private ?string $billing_address_country = null;
  89.     #[Groups(['account:read', 'read', 'account:write', 'write', 'user:read'])]
  90.     #[ORM\Column(length: 255, nullable: true)]
  91.     private ?string $billing_address_street = null;
  93.     #[Groups(['account:read', 'read', 'account:write', 'write', 'user:read'])]
  94.     #[ORM\Column(length: 50, nullable: true)]
  95.     private ?string $phone = null;
  97.     #[Groups(['account:read', 'read', 'account:write', 'write'])]
  98.     #[ORM\OneToMany(mappedBy: 'account', targetEntity: Orders::class)]
  99.     private Collection $orders;
  101.     #[MaxDepth(1)]
  102.     #[ApiProperty(writable: true)]
  103.     #[ORM\ManyToOne(inversedBy: 'accounts')]
  104.     #[Groups(['account:read', 'read', 'account:write', 'write'])]
  105.     private ?User $user = null;
  107.     #[Groups(['account:read', 'read', 'account:write', 'write'])]
  108.     #[ORM\OneToMany(mappedBy: 'supplier', targetEntity: IncomingInvoice::class)]
  109.     private Collection $invoice_supplier;
  111.     #[Groups(['account:read', 'read', 'account:write', 'write', 'user:read'])]
  112.     #[ORM\Column(length: 100, nullable: true)]
  113.     private ?string $ipn = null;
  115.     #[Groups(['account:read', 'read', 'account:write', 'write', 'user:read'])]
  116.     #[ORM\Column(length: 20, nullable: true)]
  117.     private ?string $type = null;
  119.     #[MaxDepth(1)]
  120.     #[Groups(['account:read', 'read', 'account:write', 'write'])]
  121.     #[ORM\ManyToOne(targetEntity: self::class, inversedBy: 'accounts')]
  122.     private ?self $parent = null;
  124.     #[Groups(['account:read', 'read', 'account:write', 'write'])]
  125.     #[MaxDepth(2)]
  126.     #[ORM\OneToMany(mappedBy: 'parent', targetEntity: self::class)]
  127.     private Collection $accounts;
  129.     #[Groups(['account:read', 'read', 'account:write', 'write'])]
  130.     #[ORM\Column(length: 100, nullable: true)]
  131.     private ?string $director = null;
  133.     #[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'])]
  134.     #[ORM\Column(length: 20, nullable: true)]
  135.     private ?string $code1c = null;
  137.     #[Groups(['account:read', 'read', 'account:write', 'write'])]
  138.     #[ORM\OneToMany(mappedBy: 'account', targetEntity: Contacts::class)]
  139.     private Collection $contacts;
  141.     #[MaxDepth(1)]
  142.     #[ORM\ManyToOne(inversedBy: 'managerAccounts')]
  143.     // #[Groups(['account:read', 'read', 'account:write', 'write', 'pre_order_product:read', 'pre_order:read','user:read'])]
  144.     private ?User $manager = null;
  146.     #[Groups(['account:read', 'read', 'account:write', 'write'])]
  147.     #[MaxDepth(2)]
  148.     #[ORM\OneToMany(mappedBy: 'account', targetEntity: PreOrder::class)]
  149.     private Collection $preOrders;
  151.     #[ORM\OneToMany(mappedBy: 'account', targetEntity: LoadInvoice::class)]
  152.     private Collection $loadInvoices;
  154.     #[ORM\OneToMany(mappedBy: 'organization', targetEntity: Agreements::class)]
  155.     private Collection $organization;
  157.     #[Groups(['account:read', 'read', 'account:write', 'write', 'pre_order_product:read', 'pre_order:read','user:read'])]
  158.     #[ORM\OneToMany(mappedBy: 'account', targetEntity: Agreements::class)]
  159.     private Collection $agreements;
  161.     #[Groups(['account:read'])]
  162.     #[ORM\ManyToOne(inversedBy: 'accounts')]
  163.     private ?Agreements $virtualAgreementSpecfication = null;
  165.     #[ORM\OneToMany(mappedBy: 'account', targetEntity: AccountAddress::class)]
  166.     private Collection $accountAddresses;
  168.     #[ORM\OneToMany(mappedBy: 'account', targetEntity: AccountWorker::class, orphanRemoval: true)]
  169.     private Collection $accountWorkers;
  171.     #[ORM\OneToMany(mappedBy: 'account', targetEntity: Jobs::class)]
  172.     private Collection $jobs;
  174.     public function __construct()
  175.     {
  176.         $this->orders = new ArrayCollection();
  177.         $this->invoice_supplier = new ArrayCollection();
  178.         $this->accounts = new ArrayCollection();
  179.         $this->contacts = new ArrayCollection();
  180.         $this->preOrders = new ArrayCollection();
  181.         $this->loadInvoices = new ArrayCollection();
  182.         $this->organization = new ArrayCollection();
  183.         $this->agreements = new ArrayCollection();
  184.         $this->accountAddresses = new ArrayCollection();
  185.         $this->accountWorkers = new ArrayCollection();
  186.         $this->jobs = new ArrayCollection();
  187.     }
  189.     public function getId(): ?int
  190.     {
  191.         return $this->id;
  192.     }
  194.     public function getName(): ?string
  195.     {
  196.         return $this->name;
  197.     }
  199.     public function setName(string $name): self
  200.     {
  201.         $this->name = $name;
  203.         return $this;
  204.     }
  206.     public function getDateEntered(): ?\DateTimeInterface
  207.     {
  208.         return $this->date_entered;
  209.     }
  211.     public function setDateEntered(?\DateTimeInterface $date_entered): self
  212.     {
  213.         $this->date_entered = $date_entered;
  215.         return $this;
  216.     }
  218.     public function getDateModified(): ?\DateTimeInterface
  219.     {
  220.         return $this->date_modified;
  221.     }
  223.     public function setDateModified(?\DateTimeInterface $date_modified): self
  224.     {
  225.         $this->date_modified = $date_modified;
  227.         return $this;
  228.     }
  230.     public function getModifiedUserId(): ?int
  231.     {
  232.         return $this->modified_user_id;
  233.     }
  235.     public function setModifiedUserId(?int $modified_user_id): self
  236.     {
  237.         $this->modified_user_id = $modified_user_id;
  239.         return $this;
  240.     }
  242.     public function getCreatedBy(): ?int
  243.     {
  244.         return $this->created_by;
  245.     }
  247.     public function setCreatedBy(int $created_by): self
  248.     {
  249.         $this->created_by = $created_by;
  251.         return $this;
  252.     }
  254.     public function getDescription(): ?string
  255.     {
  256.         return $this->description;
  257.     }
  259.     public function setDescription(?string $description): self
  260.     {
  261.         $this->description = $description;
  263.         return $this;
  264.     }
  266.     public function getDeleted(): ?int
  267.     {
  268.         return $this->deleted;
  269.     }
  271.     public function setDeleted(?int $deleted): self
  272.     {
  273.         $this->deleted = $deleted;
  275.         return $this;
  276.     }
  278.     public function getAssignedUserId(): ?int
  279.     {
  280.         return $this->assigned_user_id;
  281.     }
  283.     public function setAssignedUserId(?int $assigned_user_id): self
  284.     {
  285.         $this->assigned_user_id = $assigned_user_id;
  287.         return $this;
  288.     }
  290.     public function getEdrpou(): ?string
  291.     {
  292.         return $this->edrpou;
  293.     }
  295.     public function setEdrpou(?string $edrpou): self
  296.     {
  297.         $this->edrpou = $edrpou;
  299.         return $this;
  300.     }
  302.     public function getBillingAddressCity(): ?string
  303.     {
  304.         return $this->billing_address_city;
  305.     }
  307.     public function setBillingAddressCity(?string $billing_address_city): self
  308.     {
  309.         $this->billing_address_city = $billing_address_city;
  311.         return $this;
  312.     }
  314.     public function getBillingAddressState(): ?string
  315.     {
  316.         return $this->billing_address_state;
  317.     }
  319.     public function setBillingAddressState(?string $billing_address_state): self
  320.     {
  321.         $this->billing_address_state = $billing_address_state;
  323.         return $this;
  324.     }
  326.     public function getBillingAddressCountry(): ?string
  327.     {
  328.         return $this->billing_address_country;
  329.     }
  331.     public function setBillingAddressCountry(?string $billing_address_country): self
  332.     {
  333.         $this->billing_address_country = $billing_address_country;
  335.         return $this;
  336.     }
  338.     public function getBillingAddressStreet(): ?string
  339.     {
  340.         return $this->billing_address_street;
  341.     }
  343.     public function setBillingAddressStreet(?string $billing_address_street): self
  344.     {
  345.         $this->billing_address_street = $billing_address_street;
  347.         return $this;
  348.     }
  350.     public function getPhone(): ?string
  351.     {
  352.         return $this->phone;
  353.     }
  355.     public function setPhone(?string $phone): self
  356.     {
  357.         $this->phone = $phone;
  359.         return $this;
  360.     }
  362.     /**
  363.      * @return Collection<int, Orders>
  364.      */
  365.     public function getOrders(): Collection
  366.     {
  367.         return $this->orders;
  368.     }
  370.     public function addOrder(Orders $order): self
  371.     {
  372.         if (!$this->orders->contains($order)) {
  373.             $this->orders->add($order);
  374.             $order->setAccountId($this);
  375.         }
  377.         return $this;
  378.     }
  380.     public function removeOrder(Orders $order): self
  381.     {
  382.         if ($this->orders->removeElement($order)) {
  383.             // set the owning side to null (unless already changed)
  384.             if ($order->getAccountId() === $this) {
  385.                 $order->setAccountId(null);
  386.             }
  387.         }
  389.         return $this;
  390.     }
  392.     public function getUser(): ?User
  393.     {
  394.         return $this->user;
  395.     }
  397.     public function setUser(?User $user): self
  398.     {
  399.         $this->user = $user;
  401.         return $this;
  402.     }
  404.     /**
  405.      * @return Collection<int, IncomingInvoice>
  406.      */
  407.     public function getInvoiceSupplier(): Collection
  408.     {
  409.         return $this->invoice_supplier;
  410.     }
  412.     public function addInvoiceSupplier(IncomingInvoice $invoiceSupplier): self
  413.     {
  414.         if (!$this->invoice_supplier->contains($invoiceSupplier)) {
  415.             $this->invoice_supplier->add($invoiceSupplier);
  416.             $invoiceSupplier->setSupplier($this);
  417.         }
  419.         return $this;
  420.     }
  422.     public function removeInvoiceSupplier(IncomingInvoice $invoiceSupplier): self
  423.     {
  424.         if ($this->invoice_supplier->removeElement($invoiceSupplier)) {
  425.             // set the owning side to null (unless already changed)
  426.             if ($invoiceSupplier->getSupplier() === $this) {
  427.                 $invoiceSupplier->setSupplier(null);
  428.             }
  429.         }
  431.         return $this;
  432.     }
  434.     public function getIpn(): ?string
  435.     {
  436.         return $this->ipn;
  437.     }
  439.     public function setIpn(?string $ipn): self
  440.     {
  441.         $this->ipn = $ipn;
  443.         return $this;
  444.     }
  446.     public function getType(): ?string
  447.     {
  448.         return $this->type;
  449.     }
  451.     public function setType(?string $type): self
  452.     {
  453.         $this->type = $type;
  455.         return $this;
  456.     }
  458.     public function getParent(): ?self
  459.     {
  460.         return $this->parent;
  461.     }
  463.     public function setParent(?self $parent): self
  464.     {
  465.         $this->parent = $parent;
  467.         return $this;
  468.     }
  470.     /**
  471.      * @return Collection<int, self>
  472.      */
  473.     public function getAccounts(): Collection
  474.     {
  475.         return $this->accounts;
  476.     }
  478.     public function addAccount(self $account): self
  479.     {
  480.         if (!$this->accounts->contains($account)) {
  481.             $this->accounts->add($account);
  482.             $account->setParent($this);
  483.         }
  485.         return $this;
  486.     }
  488.     public function removeAccount(self $account): self
  489.     {
  490.         if ($this->accounts->removeElement($account)) {
  491.             // set the owning side to null (unless already changed)
  492.             if ($account->getParent() === $this) {
  493.                 $account->setParent(null);
  494.             }
  495.         }
  497.         return $this;
  498.     }
  500.     public function getDirector(): ?string
  501.     {
  502.         return $this->director;
  503.     }
  505.     public function setDirector(?string $director): self
  506.     {
  507.         $this->director = $director;
  509.         return $this;
  510.     }
  512.     public function getCode1c(): ?string
  513.     {
  514.         return $this->code1c;
  515.     }
  517.     public function setCode1c(?string $code1c): self
  518.     {
  519.         $this->code1c = $code1c;
  521.         return $this;
  522.     }
  524.     /**
  525.      * @return Collection<int, Contacts>
  526.      */
  527.     public function getContacts(): Collection
  528.     {
  529.         return $this->contacts;
  530.     }
  532.     public function addContact(Contacts $contact): self
  533.     {
  534.         if (!$this->contacts->contains($contact)) {
  535.             $this->contacts->add($contact);
  536.             $contact->setAccount($this);
  537.         }
  539.         return $this;
  540.     }
  542.     public function removeContact(Contacts $contact): self
  543.     {
  544.         if ($this->contacts->removeElement($contact)) {
  545.             // set the owning side to null (unless already changed)
  546.             if ($contact->getAccount() === $this) {
  547.                 $contact->setAccount(null);
  548.             }
  549.         }
  551.         return $this;
  552.     }
  554.     public function getManager(): ?User
  555.     {
  556.         return $this->manager;
  557.     }
  559.     public function setManager(?User $manager): self
  560.     {
  561.         $this->manager = $manager;
  563.         return $this;
  564.     }
  566.     /**
  567.      * @return Collection<int, PreOrder>
  568.      */
  569.     public function getPreOrders(): Collection
  570.     {
  571.         return $this->preOrders;
  572.     }
  574.     public function addPreOrder(PreOrder $preOrder): self
  575.     {
  576.         if (!$this->preOrders->contains($preOrder)) {
  577.             $this->preOrders->add($preOrder);
  578.             $preOrder->setAccount($this);
  579.         }
  581.         return $this;
  582.     }
  584.     public function removePreOrder(PreOrder $preOrder): self
  585.     {
  586.         if ($this->preOrders->removeElement($preOrder)) {
  587.             // set the owning side to null (unless already changed)
  588.             if ($preOrder->getAccount() === $this) {
  589.                 $preOrder->setAccount(null);
  590.             }
  591.         }
  593.         return $this;
  594.     }
  596.     /**
  597.      * @return Collection<int, LoadInvoice>
  598.      */
  599.     public function getLoadInvoices(): Collection
  600.     {
  601.         return $this->loadInvoices;
  602.     }
  604.     public function addLoadInvoice(LoadInvoice $loadInvoice): self
  605.     {
  606.         if (!$this->loadInvoices->contains($loadInvoice)) {
  607.             $this->loadInvoices->add($loadInvoice);
  608.             $loadInvoice->setAccount($this);
  609.         }
  611.         return $this;
  612.     }
  614.     public function removeLoadInvoice(LoadInvoice $loadInvoice): self
  615.     {
  616.         if ($this->loadInvoices->removeElement($loadInvoice)) {
  617.             // set the owning side to null (unless already changed)
  618.             if ($loadInvoice->getAccount() === $this) {
  619.                 $loadInvoice->setAccount(null);
  620.             }
  621.         }
  623.         return $this;
  624.     }
  626.     /**
  627.      * @return Collection<int, Agreements>
  628.      */
  629.     public function getOrganization(): Collection
  630.     {
  631.         return $this->organization;
  632.     }
  634.     public function addOrganization(Agreements $organization): self
  635.     {
  636.         if (!$this->organization->contains($organization)) {
  637.             $this->organization->add($organization);
  638.             $organization->setOrganization($this);
  639.         }
  641.         return $this;
  642.     }
  644.     public function removeOrganization(Agreements $organization): self
  645.     {
  646.         if ($this->organization->removeElement($organization)) {
  647.             // set the owning side to null (unless already changed)
  648.             if ($organization->getOrganization() === $this) {
  649.                 $organization->setOrganization(null);
  650.             }
  651.         }
  653.         return $this;
  654.     }
  656.     /**
  657.      * @return Collection<int, Agreements>
  658.      */
  659.     public function getAgreements(): Collection
  660.     {
  661.         return $this->agreements;
  662.     }
  664.     public function addAgreement(Agreements $agreement): self
  665.     {
  666.         if (!$this->agreements->contains($agreement)) {
  667.             $this->agreements->add($agreement);
  668.             $agreement->setAccount($this);
  669.         }
  671.         return $this;
  672.     }
  674.     public function removeAgreement(Agreements $agreement): self
  675.     {
  676.         if ($this->agreements->removeElement($agreement)) {
  677.             // set the owning side to null (unless already changed)
  678.             if ($agreement->getAccount() === $this) {
  679.                 $agreement->setAccount(null);
  680.             }
  681.         }
  683.         return $this;
  684.     }
  686.     public function getVirtualAgreementSpecfication(): ?Agreements
  687.     {
  688.         return $this->virtualAgreementSpecfication;
  689.     }
  691.     public function setVirtualAgreementSpecfication(?Agreements $virtualAgreementSpecfication): static
  692.     {
  693.         $this->virtualAgreementSpecfication = $virtualAgreementSpecfication;
  695.         return $this;
  696.     }
  698.     /**
  699.      * @return Collection<int, AccountAddress>
  700.      */
  701.     public function getAccountAddresses(): Collection
  702.     {
  703.         return $this->accountAddresses;
  704.     }
  706.     public function addAccountAddress(AccountAddress $accountAddress): self
  707.     {
  708.         if (!$this->accountAddresses->contains($accountAddress)) {
  709.             $this->accountAddresses->add($accountAddress);
  710.             $accountAddress->setAccount($this);
  711.         }
  713.         return $this;
  714.     }
  716.     public function removeAccountAddress(AccountAddress $accountAddress): self
  717.     {
  718.         if ($this->accountAddresses->removeElement($accountAddress)) {
  719.             // set the owning side to null (unless already changed)
  720.             if ($accountAddress->getAccount() === $this) {
  721.                 $accountAddress->setAccount(null);
  722.             }
  723.         }
  725.         return $this;
  726.     }
  728.     /**
  729.      * @return Collection<int, AccountWorker>
  730.      */
  731.     public function getAccountWorkers(): Collection
  732.     {
  733.         return $this->accountWorkers;
  734.     }
  736.     public function addAccountWorker(AccountWorker $accountWorker): self
  737.     {
  738.         if (!$this->accountWorkers->contains($accountWorker)) {
  739.             $this->accountWorkers->add($accountWorker);
  740.             $accountWorker->setAccount($this);
  741.         }
  743.         return $this;
  744.     }
  746.     public function removeAccountWorker(AccountWorker $accountWorker): self
  747.     {
  748.         if ($this->accountWorkers->removeElement($accountWorker)) {
  749.             // set the owning side to null (unless already changed)
  750.             if ($accountWorker->getAccount() === $this) {
  751.                 $accountWorker->setAccount(null);
  752.             }
  753.         }
  755.         return $this;
  756.     }
  758.     /**
  759.      * @return Collection<int, Jobs>
  760.      */
  761.     public function getJobs(): Collection
  762.     {
  763.         return $this->jobs;
  764.     }
  766.     public function addJob(Jobs $job): self
  767.     {
  768.         if (!$this->jobs->contains($job)) {
  769.             $this->jobs->add($job);
  770.             $job->setAccount($this);
  771.         }
  773.         return $this;
  774.     }
  776.     public function removeJob(Jobs $job): self
  777.     {
  778.         if ($this->jobs->removeElement($job)) {
  779.             // set the owning side to null (unless already changed)
  780.             if ($job->getAccount() === $this) {
  781.                 $job->setAccount(null);
  782.             }
  783.         }
  785.         return $this;
  786.     }
  787. }