src/Entity/Category.php line 14

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use Doctrine\Common\Collections\ArrayCollection;
  6. use Doctrine\Common\Collections\Collection;
  7. use Doctrine\ORM\Mapping as ORM;
  8. use Doctrine\Common\Collections\Criteria;
  11. /**
  12.  * @ORM\Entity(repositoryClass="App\Repository\CategoryRepository")
  13.  */
  14. class Category
  15. {
  16.     const TYPE_POST_CATEGORY = 1;
  17.     const TYPE_CLASSIFIED_GROUP = 2;
  18.     const TYPE_CUSTOMER_LEVEL = 3;
  19.     
  20.     const STATUS_ACTIVE = 1;
  21.     const STATUS_INACTIVE = 0;
  22.     
  23.     const SITE_RCS = 1;
  24.     const SITE_AAR = 2;
  25.     const SITE_MCS = 3;
  26.     const SITE_CCS = 4;
  27.     
  28.     /**
  29.      * @ORM\Id()
  30.      * @ORM\GeneratedValue()
  31.      * @ORM\Column(type="bigint")
  32.      */
  33.     private $id;
  34.     
  35.     /**
  36.      * @ORM\Version @ORM\Column(type="integer")
  37.      */
  38.     private $version;
  39.     
  40.     /**
  41.      * @ORM\ManyToMany(targetEntity="App\Entity\Site", inversedBy="categories")
  42.      */
  43.     private $site;
  44.     
  45.     /**
  46.      * @ORM\Column(type="string", length=255)
  47.      */
  48.     private $title;
  50.     /**
  51.      * @ORM\Column(type="text")
  52.      */
  53.     private $description;
  55.     /**
  56.      * @ORM\Column(type="string", length=255)
  57.      */
  58.     private $slug;
  60.     /**
  61.      * @ORM\Column(type="integer")
  62.      */
  63.     private $type;
  65.     /**
  66.      * @ORM\ManyToOne(targetEntity="App\Entity\Category", inversedBy="children")
  67.      * @ORM\JoinColumn(nullable=true)
  68.      */
  69.     private $prnt;
  70.     
  71.     /**
  72.      * @ORM\OneToMany(targetEntity="App\Entity\Category", mappedBy="prnt")
  73.      */
  74.     private $children;
  76.     /**
  77.      * @ORM\Column(type="datetime")
  78.      */
  79.     private $modified_at;
  81.     /**
  82.      * @ORM\Column(type="datetime")
  83.      */
  84.     private $created_at;
  86.     /**
  87.      * @ORM\Column(type="integer")
  88.      * ... not needed
  89.      */
  90.     private $sort;
  92.     /**
  93.      * @ORM\Column(type="integer")
  94.      */
  95.     private $status;
  97.     /**
  98.      * @ O R M\OneToMany(targetEntity="App\Entity\Customer", mappedBy="customer_type")
  99.      * /
  100.     private $customers;
  101.     */
  103.     /**
  104.      * @ORM\OneToMany(targetEntity="App\Entity\Content", mappedBy="category")
  105.      */
  106.     private $content;
  107.     
  108.     /**
  109.      * @ORM\ManyToMany(targetEntity="App\Entity\Content", mappedBy="secondary_categories", cascade={"detach"})
  110.      */
  111.     private $secondary_content;
  112.     
  113.     /**
  114.      * @ORM\OneToMany(targetEntity="App\Entity\Product", mappedBy="category")
  115.      */
  116.     private $products;
  117.     
  118.     /**
  119.      * @ORM\ManyToMany(targetEntity="App\Entity\Product", mappedBy="secondary_categories", cascade={"persist"})
  120.      */
  121.     private $secondary_products;
  123.     /**
  124.      * @ORM\Column(type="string", length=255)
  125.      */
  126.     private $taxonomy;
  128.     /**
  129.      * @ORM\ManyToMany(targetEntity="App\Entity\Customer", mappedBy="categories")
  130.      */
  131.     private $customers;
  133.     /**
  134.      * @ORM\ManyToOne(targetEntity="App\Entity\Media", cascade={"persist"})
  135.      * @ORM\JoinColumn(nullable=true)
  136.      */
  137.     private $media;
  138.     
  139.     public function __construct ()
  140.     {
  141.         $this->sort = 0;
  142.         $this->status = 1;
  143.         $this->type = 0;
  144.         $this->description = "";
  145.         $this->site = new ArrayCollection();
  146.         
  147.         $this->modified_at = new \DateTime("now");
  148.         $this->created_at = new \DateTime("now");
  149.         $this->customer_level = new ArrayCollection();
  150.         $this->customers = new ArrayCollection();
  151.         $this->content = new ArrayCollection();
  152.         $this->secondary_content = new ArrayCollection();
  153.         $this->products = new ArrayCollection();
  154.         $this->secondary_products = new ArrayCollection();
  155.         
  156.         $this->children = new ArrayCollection();
  157.     }
  159.     public function getId()
  160.     {
  161.         return $this->id;
  162.     }
  163.     
  164.     public function getVersion() {
  165.         return $this->version;
  166.     }
  167.     
  168.     /*
  169.     public function getSite(): ?int
  170.     {
  171.         return $this->site;
  172.     }
  173.     
  174.     public function setSite(int $site): self
  175.     {
  176.         $this->site = $site;
  177.         return $this;
  178.     }
  179.     */
  180.     
  181.     /**
  182.      * @return Collection|Site[]
  183.      */
  184.     public function getSite(): Collection
  185.     {
  186.         return $this->site;
  187.     }
  188.     
  189.     public function getSites(): Collection
  190.     {
  191.         return $this->site;
  192.     }
  194.     public function addSite(Site $site): self
  195.     {
  196.         if (!$this->site->contains($site)) {
  197.             $this->site[] = $site;
  198.             $site->addCategory($this);
  199.         }
  200.         return $this;
  201.     }
  202.     
  203.     public function resetSite(): self
  204.     {
  205.         $this->site = new ArrayCollection();
  206.         return $this;
  207.     }
  208.     
  209.     public function removeSite(Site $site): self
  210.     {
  211.         if ($this->site->contains($site)) {
  212.             $this->site->removeElement($site);
  213.             $site->removeCategory($this);
  214.         }
  215.         return $this;
  216.     }
  217.     
  218.     
  219.     public function getSiteTextShort()
  220.     {
  221.         $site_texts = [];
  222.         foreach($this->getSite() as $s) {
  223.             $site_texts[] = $s->getSiteTextShort();
  224.         }
  225.         return implode(", ", $site_texts);
  226.     }
  227.     
  228.     public function getSiteIds()
  229.     {
  230.         $site_ids = [];
  231.         foreach($this->getSite() as $s) {
  232.             $site_ids[] = $s->getId();
  233.         }
  234.         return $site_ids;
  235.     }
  236.     
  237.     
  238.     public function getTitle(): ?string
  239.     {
  240.         return $this->title;
  241.     }
  243.     public function setTitle(string $title = null): self
  244.     {
  245.         $this->title = $title ? $title : "";
  247.         return $this;
  248.     }
  250.     public function getDescription(): ?string
  251.     {
  252.         return $this->description;
  253.     }
  255.     public function setDescription(string $description = null): self
  256.     {
  257.         $this->description = $description ? $description : "";
  259.         return $this;
  260.     }
  262.     public function getSlug(): ?string
  263.     {
  264.         return $this->slug;
  265.     }
  267.     public function setSlug(string $slug = null): self
  268.     {
  269.         $this->slug = $slug ? $slug : "";
  271.         return $this;
  272.     }
  274.     public function getType(): ?int
  275.     {
  276.         return $this->type;
  277.     }
  279.     public function setType(int $type = null): self
  280.     {
  281.         $this->type = $type ? $type : 0;
  283.         return $this;
  284.     }
  286.     public function getPrnt(): ?self
  287.     {
  288.         return $this->prnt;
  289.     }
  291.     public function setPrnt(?self $prnt): self
  292.     {
  293.         $this->prnt = $prnt;
  295.         return $this;
  296.     }
  298.     public function getModifiedAt(): ?\DateTimeInterface
  299.     {
  300.         return $this->modified_at;
  301.     }
  303.     public function setModifiedAt(\DateTimeInterface $modified_at): self
  304.     {
  305.         $this->modified_at = $modified_at;
  307.         return $this;
  308.     }
  310.     public function getCreatedAt(): ?\DateTimeInterface
  311.     {
  312.         return $this->created_at;
  313.     }
  315.     public function setCreatedAt(\DateTimeInterface $created_at): self
  316.     {
  317.         $this->created_at = $created_at;
  319.         return $this;
  320.     }
  322.     public function getSort(): ?int
  323.     {
  324.         return $this->sort;
  325.     }
  327.     public function setSort(int $sort): self
  328.     {
  329.         $this->sort = $sort;
  331.         return $this;
  332.     }
  334.     public function getStatus(): ?int
  335.     {
  336.         return $this->status;
  337.     }
  339.     public function setStatus(int $status): self
  340.     {
  341.         $this->status = $status;
  343.         return $this;
  344.     }
  346.     /**
  347.      * @return Collection|Customer[]
  348.      * /
  349.     public function getCustomers(): Collection
  350.     {
  351.         return $this->customers;
  352.     }
  354.     public function addCustomer(Customer $customer): self
  355.     {
  356.         if (!$this->customers->contains($customer)) {
  357.             $this->customers[] = $customer;
  358.             $customer->setCustomerType($this);
  359.         }
  361.         return $this;
  362.     }
  364.     public function removeCustomer(Customer $customer): self
  365.     {
  366.         if ($this->customers->contains($customer)) {
  367.             $this->customers->removeElement($customer);
  368.             // set the owning side to null (unless already changed)
  369.             if ($customer->getCustomerType() === $this) {
  370.                 $customer->setCustomerType(null);
  371.             }
  372.         }
  374.         return $this;
  375.     }
  376.     */
  378.     /**
  379.      * @return Collection|Content[]
  380.      */
  381.     public function getContent(): Collection
  382.     {
  383.         return $this->content;
  384.     }
  386.     public function addContent(Content $content): self
  387.     {
  388.         if (!$this->content->contains($content)) {
  389.             $this->content[] = $content;
  390.             $content->setCategory($this);
  391.         }
  393.         return $this;
  394.     }
  396.     public function removeContent(Content $content): self
  397.     {
  398.         if ($this->content->contains($content)) {
  399.             $this->content->removeElement($content);
  400.             // set the owning side to null (unless already changed)
  401.             if ($content->getCategory() === $this) {
  402.                 $content->setCategory(null);
  403.             }
  404.         }
  406.         return $this;
  407.     }
  408.     
  409.     public function getSecondaryContent (): Collection
  410.     {
  411.         return $this->secondary_content;
  412.     }
  413.     
  414.     public function addSecondaryContent (Content $content)
  415.     {
  416.         if (!$this->secondary_content->contains($content)) {
  417.             $this->secondary_content[] = $content;
  418.             $content->addSecondaryCategory($this);
  419.         }
  421.         return $this;
  422.     }
  423.     
  424.     public function removeSecondaryContent (Content $content): self
  425.     {
  426.         if ($this->secondary_content->contains($content)) {
  427.             $this->secondary_content->removeElement($content);
  428.             $content->removeSecondaryCategory($this);
  429.         }
  431.         return $this;
  432.     }
  433.     
  434.     public function getPinnedEbook($site = "") {
  435.         
  436.         $criteria = Criteria::create()
  437.             ->where(Criteria::expr()->eq("status", "1"))
  438.             ->orderBy(["id" => Criteria::ASC])
  439.         ;
  440.         
  441.         $content = $this->getSecondaryContent()->matching($criteria);
  442.         //$content = $this->getSecondaryContent();
  443.         
  444.         if(!$content) {
  445.             return null;
  446.         }
  448.         if($site) {
  449.             $tempContent = $content;
  450.             $content = [];
  451.             foreach($tempContent as $c) {
  452.                 foreach($c->getSites() as $s) {
  453.                     if($s->getId() == $site) {
  454.                         $content[] = $c;
  455.                     }
  456.                 }
  457.             }
  458.             if(!$content) {
  459.                 return null;
  460.             }
  461.         }
  463.         $pinnedContent = [];
  464.         foreach($content as $c) {
  465.             if($c->getEbookPinned()) {
  466.                 $pinnedContent[] = $c;
  467.             }
  468.         }
  469.         
  470.         if(!empty($pinnedContent)) {
  471.             return $pinnedContent[array_rand($pinnedContent)];
  472.         }
  473.         
  474.         //return $content->first();
  475.         return $content[0];
  476.         
  477.         
  478.     }
  479.     
  480.     /**
  481.      * @return Collection|Product[]
  482.      */
  483.     public function getProducts(): Collection
  484.     {
  485.         return $this->products;
  486.     }
  488.     public function addProduct(Product $product): self
  489.     {
  490.         if (!$this->products->contains($product)) {
  491.             $this->products[] = $product;
  492.             $product->setCategory($this);
  493.         }
  495.         return $this;
  496.     }
  498.     public function removeProduct(Product $product): self
  499.     {
  500.         if ($this->products->contains($product)) {
  501.             $this->products->removeElement($product);
  502.             // set the owning side to null (unless already changed)
  503.             if ($product->getCategory() === $this) {
  504.                 $product->setCategory(null);
  505.             }
  506.         }
  508.         return $this;
  509.     }
  510.     
  511.     public function getSecondaryProducts (): Collection
  512.     {
  513.         return $this->secondary_products;
  514.     }
  515.     
  516.     public function addSecondaryProduct (Product $product)
  517.     {
  518.         if (!$this->secondary_products->contains($product)) {
  519.             $this->secondary_products[] = $product;
  520.             $product->addSecondaryCategory($this);
  521.         }
  523.         return $this;
  524.     }
  525.     
  526.     public function removeSecondaryProduct (Product $product): self
  527.     {
  528.         if ($this->secondary_products->contains($product)) {
  529.             $this->secondary_products->removeElement($product);
  530.             $product->removeSecondaryCategory($this);
  531.         }
  533.         return $this;
  534.     }
  536.     public function getTaxonomy(): ?string
  537.     {
  538.         return $this->taxonomy;
  539.     }
  541.     public function setTaxonomy(string $taxonomy = null): self
  542.     {
  543.         $this->taxonomy = $taxonomy ? $taxonomy : "";
  545.         return $this;
  546.     }
  548.     /**
  549.      * @return Collection|Customer[]
  550.      */
  551.     public function getCustomers(): Collection
  552.     {
  553.         return $this->customers;
  554.     }
  556.     public function addCustomer(Customer $customer): self
  557.     {
  558.         if (!$this->customers->contains($customer)) {
  559.             $this->customers[] = $customer;
  560.             $customer->addCategory($this);
  561.         }
  563.         return $this;
  564.     }
  566.     public function removeCustomer(Customer $customer): self
  567.     {
  568.         if ($this->customers->contains($customer)) {
  569.             $this->customers->removeElement($customer);
  570.             $customer->removeCategory($this);
  571.         }
  573.         return $this;
  574.     }
  575.     
  576.     public function getChildren ()
  577.     {
  578.         return $this->children;
  579.     }
  580.     
  581.     public function addChild (Category $child) {
  582.         if (!$this->children->contains($child)) {
  583.             $this->children[] = $child;
  584.             $child->setPrnt($this);
  585.         }
  586.         
  587.         return $this;
  588.     }
  589.     
  590.     public function removeChild (Category $children): self
  591.     {
  592.         if ($this->children->contains($children)) {
  593.             $this->children->removeElement($children);
  594.             // set the owning side to null (unless already changed)
  595.             if ($children->getPrnt() === $this) {
  596.                 $children->setPrnt(null);
  597.             }
  598.         }
  599.         
  600.         return $this;
  601.     }
  602.     
  603.     public function getURL ()
  604.     {
  605.         // grab URL based on category taxonomy
  606.         
  607.         if ($this->taxonomy && strtolower($this->taxonomy) != "category") {
  608.             return "/taxonomy/{$this->taxonomy}/{$this->slug}";
  609.         }
  610.         
  611.         return "/category/{$this->slug}";
  612.     }
  613.     
  614.     public function getSiteMapURL()
  615.     {
  617.         if ($this->taxonomy && strtolower($this->taxonomy) == "ebook-category") {
  618.             return "/category/ebooks/{$this->slug}";
  619.         }
  621.         return "/category/{$this->slug}";
  622.     }
  624.     public function getMedia (): ?Media
  625.     {
  626.         return $this->media;
  627.     }
  628.     
  629.     public function setMedia (Media $media = null): self
  630.     {
  631.         $this->media = $media;
  632.         
  633.         return $this;
  634.     }
  636.     public function __toString ()
  637.     {
  638.         return $this->title ? $this->title : "";
  639.     }
  640.     
  641.     
  642. }