src/Entity/CRM/Customer.php line 15

  1. <?php
  3. namespace App\Entity\CRM;
  5. use App\Entity\CRM\Order;
  6. use App\Entity\CRM\OrderCustomerAddress;
  7. use App\Repository\CustomerRepository;
  8. use DateTime;
  9. use Doctrine\Common\Collections\ArrayCollection;
  10. use Doctrine\Common\Collections\Collection;
  11. use Doctrine\DBAL\Types\Types;
  12. use Doctrine\ORM\Mapping as ORM;
  14. #[ORM\Entity(repositoryClass: CustomerRepository::class)]
  15. class Customer
  16. {
  17.     #[ORM\Id]
  18.     #[ORM\GeneratedValue]
  19.     #[ORM\Column]
  20.     private ?int $id = null;
  22.     #[ORM\Column(length: 255)]
  23.     private ?string $name = null;
  25.     #[ORM\Column(length: 255)]
  26.     private ?string $lastName = null;
  28.     #[ORM\Column(length: 255)]
  29.     private ?string $firstName = null;
  31.     #[ORM\Column(length: 255)]
  32.     private ?string $address = null;
  34.     #[ORM\Column(length: 255)]
  35.     private ?string $city = null;
  37.     #[ORM\Column(length: 255)]
  38.     private ?string $zipCode = null;
  40.     #[ORM\Column(length: 255)]
  41.     private ?string $email = null;
  43.     #[ORM\Column(length: 10)]
  44.     private ?string $companyNumber = null;
  46.     #[ORM\Column(type: Types::DATETIME_MUTABLE)]
  47.     private \DateTimeInterface $addedDate;
  49.     #[ORM\Column]
  50.     private ?bool $checkUser = null;
  52.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  53.     private ?string $userNote = null;
  55.     #[ORM\Column]
  56.     private ?bool $isActive = null;
  58.     #[ORM\Column(nullable: true)]
  59.     private ?int $old_id = null;
  61.     #[ORM\OneToMany(mappedBy: 'customer', targetEntity: CustomerAddress::class, cascade: ['persist'], orphanRemoval: true)]
  62.     private Collection $customerAddresses;
  64.     #[ORM\OneToMany(mappedBy: 'customer', targetEntity: Order::class)]
  65.     private Collection $orders;
  67.     #[ORM\OneToMany(mappedBy: 'customer', targetEntity: OrderCustomerAddress::class)]
  68.     private Collection $orderCustomerAddresses;
  70.     #[ORM\ManyToOne(inversedBy: 'customers')]
  71.     private ?Consultant $consultant = null;
  73.     #[ORM\Column(length: 255, nullable: true)]
  74.     private ?string $phone = null;
  76.     #[ORM\Column]
  77.     private ?bool $ordersBlock = null;
  79.     #[ORM\OneToMany(mappedBy: 'customer', targetEntity: CustomerHistory::class)]
  80.     private Collection $customerHistories;
  82.     #[ORM\Column(nullable: true)]
  83.     private ?string $regon = null;
  85.     public function __construct()
  86.     {
  87.         $this->addedDate = new DateTime();
  88.         $this->customerAddresses = new ArrayCollection();
  89.         $this->orders = new ArrayCollection();
  90.         $this->orderCustomerAddresses = new ArrayCollection();
  91.         $this->customerHistories = new ArrayCollection();
  92.     }
  94.     public function __toString()
  95.     {
  96.         return $this->getFirstName().' '.$this->getLastName();
  97.     }
  99.     public function getId(): ?int
  100.     {
  101.         return $this->id;
  102.     }
  104.     public function getName(): ?string
  105.     {
  106.         return $this->name;
  107.     }
  109.     public function setName(string $name): self
  110.     {
  111.         $this->name = $name;
  113.         return $this;
  114.     }
  116.     public function getLastName(): ?string
  117.     {
  118.         return $this->lastName;
  119.     }
  121.     public function setLastName(string $lastName): self
  122.     {
  123.         $this->lastName = $lastName;
  125.         return $this;
  126.     }
  128.     public function getFirstName(): ?string
  129.     {
  130.         return $this->firstName;
  131.     }
  133.     public function setFirstName(string $firstName): self
  134.     {
  135.         $this->firstName = $firstName;
  137.         return $this;
  138.     }
  140.     public function getAddress(): ?string
  141.     {
  142.         return $this->address;
  143.     }
  145.     public function setAddress(string $address): self
  146.     {
  147.         $this->address = $address;
  149.         return $this;
  150.     }
  152.     public function getCity(): ?string
  153.     {
  154.         return $this->city;
  155.     }
  157.     public function setCity(string $city): self
  158.     {
  159.         $this->city = $city;
  161.         return $this;
  162.     }
  164.     public function getZipCode(): ?string
  165.     {
  166.         return $this->zipCode;
  167.     }
  169.     public function setZipCode(string $zipCode): self
  170.     {
  171.         $this->zipCode = $zipCode;
  173.         return $this;
  174.     }
  176.     public function getEmail(): ?string
  177.     {
  178.         return $this->email;
  179.     }
  181.     public function setEmail(string $email): self
  182.     {
  183.         $this->email = $email;
  185.         return $this;
  186.     }
  188.     public function getCompanyNumber(): ?int
  189.     {
  190.         return $this->companyNumber;
  191.     }
  193.     public function setCompanyNumber(int $companyNumber): self
  194.     {
  195.         $this->companyNumber = $companyNumber;
  197.         return $this;
  198.     }
  200.     public function getAddedDate(): ?\DateTimeInterface
  201.     {
  202.         return $this->addedDate;
  203.     }
  205.     public function setAddedDate(\DateTimeInterface $addedDate): self
  206.     {
  207.         $this->addedDate = $addedDate;
  209.         return $this;
  210.     }
  212.     public function isCheckUser(): ?bool
  213.     {
  214.         return $this->checkUser;
  215.     }
  217.     public function setCheckUser(bool $checkUser): self
  218.     {
  219.         $this->checkUser = $checkUser;
  221.         return $this;
  222.     }
  224.     public function getUserNote(): ?string
  225.     {
  226.         return $this->userNote;
  227.     }
  229.     public function setUserNote(?string $userNote): self
  230.     {
  231.         $this->userNote = $userNote;
  233.         return $this;
  234.     }
  236.     public function isIsActive(): ?bool
  237.     {
  238.         return $this->isActive;
  239.     }
  241.     public function setIsActive(bool $isActive): self
  242.     {
  243.         $this->isActive = $isActive;
  245.         return $this;
  246.     }
  248.     public function getOldId(): ?int
  249.     {
  250.         return $this->old_id;
  251.     }
  253.     public function setOldId(?int $old_id): self
  254.     {
  255.         $this->old_id = $old_id;
  257.         return $this;
  258.     }
  260.     /**
  261.      * @return Collection<int, CustomerAddress>
  262.      */
  263.     public function getCustomerAddresses(): Collection
  264.     {
  265.         return $this->customerAddresses;
  266.     }
  268.     public function addCustomerAddress(CustomerAddress $customerAddress): self
  269.     {
  270.         if (!$this->customerAddresses->contains($customerAddress)) {
  271.             $this->customerAddresses->add($customerAddress);
  272.             $customerAddress->setCustomer($this);
  273.         }
  275.         return $this;
  276.     }
  278.     public function removeCustomerAddress(CustomerAddress $customerAddress): self
  279.     {
  280.         if ($this->customerAddresses->removeElement($customerAddress)) {
  281.             // set the owning side to null (unless already changed)
  282.             if ($customerAddress->getCustomer() === $this) {
  283.                 $customerAddress->setCustomer(null);
  284.             }
  285.         }
  287.         return $this;
  288.     }
  290.     /**
  291.      * @return Collection<int, Order>
  292.      */
  293.     public function getOrders(): Collection
  294.     {
  295.         return $this->orders;
  296.     }
  298.     public function addOrder(Order $order): self
  299.     {
  300.         if (!$this->orders->contains($order)) {
  301.             $this->orders->add($order);
  302.             $order->setCustomer($this);
  303.         }
  305.         return $this;
  306.     }
  308.     public function removeOrder(Order $order): self
  309.     {
  310.         if ($this->orders->removeElement($order)) {
  311.             // set the owning side to null (unless already changed)
  312.             if ($order->getCustomer() === $this) {
  313.                 $order->setCustomer(null);
  314.             }
  315.         }
  317.         return $this;
  318.     }
  320.     /**
  321.      * @return Collection<int, OrderCustomerAddress>
  322.      */
  323.     public function getOrderCustomerAddresses(): Collection
  324.     {
  325.         return $this->orderCustomerAddresses;
  326.     }
  328.     public function addOrderCustomerAddress(OrderCustomerAddress $orderCustomerAddress): self
  329.     {
  330.         if (!$this->orderCustomerAddresses->contains($orderCustomerAddress)) {
  331.             $this->orderCustomerAddresses->add($orderCustomerAddress);
  332.             $orderCustomerAddress->setCustomer($this);
  333.         }
  335.         return $this;
  336.     }
  338.     public function removeOrderCustomerAddress(OrderCustomerAddress $orderCustomerAddress): self
  339.     {
  340.         if ($this->orderCustomerAddresses->removeElement($orderCustomerAddress)) {
  341.             // set the owning side to null (unless already changed)
  342.             if ($orderCustomerAddress->getCustomer() === $this) {
  343.                 $orderCustomerAddress->setCustomer(null);
  344.             }
  345.         }
  347.         return $this;
  348.     }
  350.     public function getConsultant(): ?Consultant
  351.     {
  352.         return $this->consultant;
  353.     }
  355.     public function setConsultant(?Consultant $consultant): static
  356.     {
  357.         $this->consultant = $consultant;
  359.         return $this;
  360.     }
  362.     public function getPhone(): ?string
  363.     {
  364.         return $this->phone;
  365.     }
  367.     public function setPhone(?string $phone): static
  368.     {
  369.         $this->phone = $phone;
  371.         return $this;
  372.     }
  374.     public function isOrdersBlock(): ?bool
  375.     {
  376.         return $this->ordersBlock;
  377.     }
  379.     public function setOrdersBlock(bool $ordersBlock): static
  380.     {
  381.         $this->ordersBlock = $ordersBlock;
  383.         return $this;
  384.     }
  386.     /**
  387.      * @return Collection<int, CustomerHistory>
  388.      */
  389.     public function getCustomerHistories(): Collection
  390.     {
  391.         return $this->customerHistories;
  392.     }
  394.     public function addCustomerHistory(CustomerHistory $customerHistory): static
  395.     {
  396.         if (!$this->customerHistories->contains($customerHistory)) {
  397.             $this->customerHistories->add($customerHistory);
  398.             $customerHistory->setCustomer($this);
  399.         }
  401.         return $this;
  402.     }
  404.     public function removeCustomerHistory(CustomerHistory $customerHistory): static
  405.     {
  406.         if ($this->customerHistories->removeElement($customerHistory)) {
  407.             // set the owning side to null (unless already changed)
  408.             if ($customerHistory->getCustomer() === $this) {
  409.                 $customerHistory->setCustomer(null);
  410.             }
  411.         }
  413.         return $this;
  414.     }
  416.     public function getRegon(): ?string
  417.     {
  418.         return $this->regon;
  419.     }
  421.     public function setRegon(?string $regon): static
  422.     {
  423.         $this->regon = $regon;
  425.         return $this;
  426.     }
  427. }