src/Entity/Shop.php line 14

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\ShopRepository;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\DBAL\Types\Types;
  9. use Doctrine\ORM\Mapping as ORM;
  11. /**
  12.  * @ORM\Entity(repositoryClass=ShopRepository::class)
  13.  */
  14. class Shop
  15. {
  16.     /**
  17.      * @ORM\Id
  18.      * @ORM\GeneratedValue
  19.      * @ORM\Column(type="integer")
  20.      */
  21.     private $id;
  23.     /**
  24.      * @ORM\Column(type="string", length=128)
  25.      */
  26.     private $name;
  28.     /**
  29.      * @ORM\Column(type="string", length=128)
  30.      */
  31.     private $country;
  33.     /**
  34.      * @ORM\Column(type="integer")
  35.      */
  36.     private $wttId;
  38.     /**
  39.      * @ORM\ManyToMany(targetEntity=User::class, mappedBy="shops")
  40.      */
  41.     private Collection $users;
  43.     /**
  44.      * @ORM\OneToMany(targetEntity=Order::class, mappedBy="shop")
  45.      */
  46.     private $orders;
  48.     /**
  49.      * @ORM\Column(type="string", length=16, nullable=true)
  50.      */
  51.     private $wttName;
  53.     /**
  54.      * @ORM\Column(type="text", length=16, nullable=true)
  55.      */
  56.     private $logo = null;
  58.     /**
  59.      * @ORM\OneToMany(targetEntity=Stock::class, mappedBy="shop")
  60.      */
  61.     private $stocks;
  63.     /**
  64.      * @ORM\Column(type="json", nullable=true)
  65.      */
  66.     private $config = null;
  68.     /**
  69.      * @ORM\OneToMany(targetEntity=Company::class, mappedBy="shop")
  70.      */
  71.     private $companies;
  73.     /**
  74.      * @ORM\OneToMany(targetEntity=ShopSetting::class, mappedBy="shop", cascade={"persist"})
  75.      */
  76.     private $settings;
  78.     /**
  79.      * @ORM\OneToMany(targetEntity=Imei::class, mappedBy="shop")
  80.      */
  81.     private $imeis;
  83.     /**
  84.      * @ORM\Column(type="string", length=255, nullable=true)
  85.      */
  86.     private $apikey;
  89.     /**
  90.      * @ORM\Column(type="string", length=255,nullable=true)
  91.      */
  92.     private $loginHash;
  94.     /**
  95.      * @ORM\Column(type="string", length=16)
  96.      */
  97.     private $channel;
  99.     /**
  100.      * @ORM\Column(type="text", nullable=true)
  101.      */
  102.     private $mailCopy;
  105.     /**
  106.      * @ORM\OneToMany(targetEntity=Coupon::class, mappedBy="shop")
  107.      */
  108.     private $coupons;
  111.     /**
  112.      * @ORM\ManyToMany(targetEntity=Category::class, inversedBy="shops", cascade={"persist"})
  113.      */
  114.     private Collection $categories;
  116.     /**
  117.      * @ORM\ManyToMany(targetEntity=Option::class, mappedBy="shops", cascade={"persist"})
  118.      */
  119.     private Collection $options;
  121.     /**
  122.      * @ORM\ManyToMany(targetEntity=Status::class, inversedBy="shops", cascade={"persist"})
  123.      */
  124.     private Collection $statuses;
  126.     /**
  127.      * @ORM\Column(type="boolean", nullable=true)
  128.      */
  129.     private $active;
  132.     private $vat;
  135.     public function __construct()
  136.     {
  137.         $this->users = new ArrayCollection();
  138.         $this->orders = new ArrayCollection();
  139.         $this->products = new ArrayCollection();
  140.         $this->stocks = new ArrayCollection();
  141.         $this->companies = new ArrayCollection();
  142.         $this->imeis = new ArrayCollection();
  143.         $this->settings = new ArrayCollection();
  144.         $this->coupons = new ArrayCollection();
  145.         $this->categories = new ArrayCollection();
  146.         $this->options = new ArrayCollection();
  147.         $this->statuses = new ArrayCollection();
  148.     }
  150.     public function __toString() {
  151.         if($this->name!='') {
  152.             return $this->getName();
  153.         }
  154.         return "new shop";
  155.     }
  157.     public function getId(): ?int
  158.     {
  159.         return $this->id;
  160.     }
  162.     public function getName(): ?string
  163.     {
  164.         return $this->name;
  165.     }
  167.     public function setName(string $name): self
  168.     {
  169.         $this->name = $name;
  171.         return $this;
  172.     }
  174.     public function getMachineName() {
  175.         $name=str_replace(' ','-',$this->getName());
  176.         return preg_replace("/[^A-Za-z0-9.-]/",'',$name);
  177.     }
  179.     public function getWttId(): ?int
  180.     {
  181.         return $this->wttId;
  182.     }
  184.     public function setWttId(int $wttId): self
  185.     {
  186.         $this->wttId = $wttId;
  188.         return $this;
  189.     }
  191.     /**
  192.      * @return Collection<int, User>
  193.      */
  194.     public function getUsers(): Collection
  195.     {
  196.         return $this->users;
  197.     }
  199.     public function addUser(User $user): self
  200.     {
  201.         if (!$this->users->contains($user)) {
  202.             $this->users[] = $user;
  203.             //$user->setShop($this);
  204.             $user->addShop($this);
  205.         }
  207.         return $this;
  208.     }
  210.     public function removeUser(User $user): self
  211.     {
  212.         if ($this->users->removeElement($user)) {
  213.             // set the owning side to null (unless already changed)
  214.             if ($user->getShop() === $this) {
  215.                 //$user->setShop(null);
  216.                 $user->removeShop($this);
  217.             }
  218.         }
  220.         return $this;
  221.     }
  226.     public function addOrder(Order $order): self
  227.     {
  228.         if (!$this->orders->contains($order)) {
  229.             $this->orders[] = $order;
  230.             $order->setShop($this);
  231.         }
  233.         return $this;
  234.     }
  236.     public function removeOrder(Order $order): self
  237.     {
  238.         if ($this->orders->removeElement($order)) {
  239.             // set the owning side to null (unless already changed)
  240.             if ($order->getShop() === $this) {
  241.                 $order->setShop(null);
  242.             }
  243.         }
  245.         return $this;
  246.     }
  249.     public function getWttName(): ?string
  250.     {
  251.         return $this->wttName;
  252.     }
  254.     public function setWttName(string $wttName): self
  255.     {
  256.         $this->wttName = $wttName;
  258.         return $this;
  259.     }
  261.     /**
  262.      * @return Collection<int, Stock>
  263.      */
  264.     public function getStocks(): Collection
  265.     {
  266.         return $this->stocks;
  267.     }
  269.     public function addStock(Stock $stock): self
  270.     {
  271.         if (!$this->stocks->contains($stock)) {
  272.             $this->stocks[] = $stock;
  273.             $stock->setShop($this);
  274.         }
  276.         return $this;
  277.     }
  279.     public function removeStock(Stock $stock): self
  280.     {
  281.         if ($this->stocks->removeElement($stock)) {
  282.             // set the owning side to null (unless already changed)
  283.             if ($stock->getShop() === $this) {
  284.                 $stock->setShop(null);
  285.             }
  286.         }
  288.         return $this;
  289.     }
  291.     public function getConfig()
  292.     {
  293.         if(is_null($this->config)) {
  294.             return null;
  295.         }
  296.         return reset($this->config);
  297.     }
  299.     public function setConfig( $config): self
  300.     {
  301.         $this->config = $config;
  303.         return $this;
  304.     }
  306.     /**
  307.      * @return Collection<int, Company>
  308.      */
  309.     public function getCompanies(): Collection
  310.     {
  311.         return $this->companies;
  312.     }
  314.     public function addCompany(Company $company): self
  315.     {
  316.         if (!$this->companies->contains($company)) {
  317.             $this->companies[] = $company;
  318.             $company->setShop($this);
  319.         }
  321.         return $this;
  322.     }
  324.     public function removeCompany(Company $company): self
  325.     {
  326.         if ($this->companies->removeElement($company)) {
  327.             // set the owning side to null (unless already changed)
  328.             if ($company->getShop() === $this) {
  329.                 $company->setShop(null);
  330.             }
  331.         }
  333.         return $this;
  334.     }
  337.     /**
  338.      * @return Collection<int, ShopSetting>
  339.      */
  340.     public function getSettings(): Collection
  341.     {
  342.         return $this->settings;
  343.     }
  346.     public function getSetting($machineName) {
  348.         foreach($this->getSettings() as $setting) {
  349.             if($setting->getSetting()->getMachineName()==$machineName) {
  350.                 if($setting->getValue()=='false') {
  351.                     return false;
  352.                 }
  353.                 return $setting->getValue();
  354.             }
  355.         }
  356.         return false;
  357.     }
  360.     public function addSetting(ShopSetting $setting): void
  361.     {
  362.         $setting->setShop($this);
  363.         $this->settings->add($setting);
  364.         /*if (!$this->settings->contains($setting)) {
  365.             $this->settings[] = $setting;
  366.             $setting->setUser($this);
  367.         }
  369.         return $this;
  370.         */
  371.     }
  373.     public function removeSetting(ShopSetting $setting): void
  374.     {
  375.         /*if ($this->settings->removeElement($setting)) {
  376.             // set the owning side to null (unless already changed)
  377.             if ($setting->getUser() === $this) {
  378.                 $setting->setUser(null);
  379.             }
  380.         }
  382.         return $this;*/
  383.     }
  385.     /**
  386.      * @return Collection<int, Imei>
  387.      */
  388.     public function getImeis(): Collection
  389.     {
  390.         return $this->imeis;
  391.     }
  393.     public function addImei(Imei $imei): self
  394.     {
  395.         if (!$this->imeis->contains($imei)) {
  396.             $this->imeis[] = $imei;
  397.             $imei->setShop($this);
  398.         }
  400.         return $this;
  401.     }
  403.     public function removeImei(Imei $imei): self
  404.     {
  405.         if ($this->imeis->removeElement($imei)) {
  406.             // set the owning side to null (unless already changed)
  407.             if ($imei->getShop() === $this) {
  408.                 $imei->setShop(null);
  409.             }
  410.         }
  412.         return $this;
  413.     }
  415.     public function getApikey(): ?string
  416.     {
  417.         return $this->apikey;
  418.     }
  420.     public function setApikey(string $apikey): self
  421.     {
  422.         $this->apikey = $apikey;
  424.         return $this;
  425.     }
  427.     public function getLoginHash(): ?string
  428.     {
  429.         return $this->loginHash;
  430.     }
  432.     public function setLoginHash(string $loginHash): self
  433.     {
  434.         $this->loginHash = $loginHash;
  436.         return $this;
  437.     }
  439.     public function getChannel(): ?string
  440.     {
  441.         return $this->channel;
  442.     }
  444.     public function setChannel(string $channel): self
  445.     {
  446.         $this->channel = $channel;
  448.         return $this;
  449.     }
  453.     public function getMailCopy(): ?string
  454.     {
  455.         return $this->mailCopy;
  456.     }
  458.     public function setMailCopy(?string $mailCopy): self
  459.     {
  460.         $this->mailCopy = $mailCopy;
  462.         return $this;
  463.     }
  465.     /**
  466.      * @return Collection<int, Coupon>
  467.      */
  468.     public function getCoupons(): Collection
  469.     {
  470.         return $this->coupons;
  471.     }
  473.     public function addCoupon(Coupon $coupon): static
  474.     {
  475.         if (!$this->coupons->contains($coupon)) {
  476.             $this->coupons->add($coupon);
  477.             $coupon->setShop($this);
  478.         }
  480.         return $this;
  481.     }
  483.     public function removeCoupon(Coupon $coupon): static
  484.     {
  485.         if ($this->coupons->removeElement($coupon)) {
  486.             // set the owning side to null (unless already changed)
  487.             if ($coupon->getShop() === $this) {
  488.                 $coupon->setShop(null);
  489.             }
  490.         }
  492.         return $this;
  493.     }
  495.     /**
  496.      * @return Collection<int, Order>
  497.      */
  498.     public function getOrders(): Collection
  499.     {
  500.         return $this->orders;
  501.     }
  503.     public function getLogo(): ?string
  504.     {
  505.         return $this->logo;
  506.     }
  508.     public function setLogo(?string $logo): self
  509.     {
  510.         $this->logo = $logo;
  512.         return $this;
  513.     }
  515.     public function getCountry(): ?string
  516.     {
  517.         return $this->country;
  518.     }
  520.     public function setCountry(string $country): static
  521.     {
  522.         $this->country = $country;
  524.         return $this;
  525.     }
  527.     public function getVat() {
  528.         $this->vat=20;
  529.         if($this->getCountry()=='es') {
  530.             $this->vat=21;
  531.         }
  532.         return $this->vat;
  533.     }
  535.     /**
  536.      * @return Collection<int, Category>
  537.      */
  538.     public function getCategories(): Collection
  539.     {
  540.         return $this->categories;
  541.     }
  543.     public function addCategory(Category $category): static
  544.     {
  545.         if (!$this->categories->contains($category)) {
  546.             $this->categories->add($category);
  547.             $category->addShop($this);
  548.         }
  550.         return $this;
  551.     }
  553.     public function removeCategory(Category $category): static
  554.     {
  555.         if ($this->categories->removeElement($category)) {
  556.             $category->removeShop($this);
  557.         }
  559.         return $this;
  560.     }
  565.     /**
  566.      * @return Collection<int, Option>
  567.      */
  568.     public function getOptions(): Collection
  569.     {
  570.         return $this->options;
  571.     }
  573.     public function addOption(Option $option): static
  574.     {
  575.         if (!$this->options->contains($option)) {
  576.             $this->options->add($option);
  577.             $option->addShop($this);
  578.         }
  580.         return $this;
  581.     }
  583.     public function removeOption(Option $option): static
  584.     {
  585.         if ($this->options->removeElement($option)) {
  586.             $option->removeShop($this);
  587.         }
  589.         return $this;
  590.     }
  592.     /**
  593.      * @return Collection<int, Status>
  594.      */
  595.     public function getStatuses(): Collection
  596.     {
  597.         return $this->statuses;
  598.     }
  600.     public function addStatus(Status $status): static
  601.     {
  602.         if (!$this->statuses->contains($status)) {
  603.             $this->statuses->add($status);
  604.         }
  606.         return $this;
  607.     }
  609.     public function removeStatus(Status $status): static
  610.     {
  611.         $this->statuses->removeElement($status);
  613.         return $this;
  614.     }
  616.     public function getActive():bool
  617.     {
  618.         return $this->active;
  619.     }
  621.     public function setActive(bool $active):self
  622.     {
  623.         $this->active = $active;
  624.         return $this;
  625.     }
  627.     public function isActive(): ?bool
  628.     {
  629.         return $this->active;
  630.     }
  632. }