src/Repository/ProductRepository.php line 257

  1. <?php
  3. namespace App\Repository;
  5. use App\Entity\Product;
  6. use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository;
  7. use Doctrine\Persistence\ManagerRegistry;
  8. use Symfony\Component\HttpFoundation\JsonResponse;
  10. /**
  11.  * @extends ServiceEntityRepository<Product>
  12.  *
  13.  * @method Product|null find($id, $lockMode = null, $lockVersion = null)
  14.  * @method Product|null findOneBy(array $criteria, array $orderBy = null)
  15.  * @method Product[]    findAll()
  16.  * @method Product[]    findBy(array $criteria, array $orderBy = null, $limit = null, $offset = null)
  17.  */
  18. class ProductRepository extends ServiceEntityRepository
  19. {
  20.     public function __construct(ManagerRegistry $registry)
  21.     {
  22.         parent::__construct($registry, Product::class);
  23.     }
  25.     public function save(Product $entity, bool $flush = false): void
  26.     {
  27.         $this->getEntityManager()->persist($entity);
  29.         if ($flush) {
  30.             $this->getEntityManager()->flush();
  31.         }
  32.     }
  34.     public function remove(Product $entity, bool $flush = false): void
  35.     {
  36.         $this->getEntityManager()->remove($entity);
  38.         if ($flush) {
  39.             $this->getEntityManager()->flush();
  40.         }
  41.     }
  43.     /**
  44.      * @param $value
  45.      * @return Product|null
  46.      * @throws \Doctrine\ORM\NonUniqueResultException
  47.      */
  48.     public function findProductBySlug($value): ?Product
  49.     {
  50.         return $this->createQueryBuilder('p')
  51.             ->andWhere('p.slug = :val')
  52.             ->setParameter('val', $value)
  53.             ->getQuery()
  54.             ->getOneOrNullResult();
  56.     }
  59.         /**
  60.      * @param $value
  61.      * @return Product|null
  62.      * @throws \Doctrine\ORM\NonUniqueResultException
  63.      */
  64.     public function findProductsByCategory($category): ?array
  65.     {
  66.         // return $this->createQueryBuilder('p')
  67.         //     ->select('DISTINCT ov.*')
  68.         //     ->Join('p.variants','v')
  69.         //     ->Join('v.optionValues','ov')
  70.         //     ->andWhere('ov.name = :color')
  71.         //     ->andWhere(':category MEMBER OF p.categories')
  72.         //     ->setParameter('category', $category)
  73.         //     ->setParameter('color',"Color")
  74.         //     // ->groupBy('ov.value')
  75.         //     ->getQuery()
  76.         //     ->getResult();
  78.     //     $qb->select('p, v, ov')
  79.     //     ->from('App\Entity\Product', 'p')
  80.     //     ->leftJoin('p.variants', 'v')
  81.     //     ->leftJoin('v.color', 'ov')
  82.     //     ->groupBy('ov.id'); 
  86.     //     $qb = $entityManager->createQueryBuilder();
  88.     // $qb->select('p, v, ov')
  89.     //    ->from('App\Entity\Product', 'p')
  90.     //    ->leftJoin('p.variants', 'v')
  91.     //    ->leftJoin('v.color', 'ov')
  92.     //    ->groupBy('ov.id'); // Group by color (OptionValues entity)
  94.     // $query = $qb->getQuery();
  96.     // return $query->getResult();
  98.             return $this->createQueryBuilder('p')
  99.                         ->select('p,v,ov')
  100.                         ->leftJoin('p.variants','v')
  101.                         ->leftJoin('v.optionValues','ov')
  102.                         ->andWhere(':category MEMBER OF p.categories')
  103.                         ->setParameter('category', $category)
  104.                         ->groupBy('v.color')
  105.                         ->getQuery()
  106.                         ->getResult();
  108.     }
  111.     public function findProductsByCollection($collection,$page,$filters)
  112.     {
  114.         // $query = $this->createQueryBuilder('p')
  115.         //             ->select('p,v,ov')
  116.         //             ->leftJoin('p.variants','v')
  117.         //             ->leftJoin('v.optionValues','ov')
  118.         //             ->andWhere(':collection MEMBER OF p.collections')
  119.         //             ->setParameter('collection', $collection);
  122.         // if($filters){
  124.         //     if ( array_key_exists('color',$filters) & !empty($filters['color'])) {
  125.         //             $query->andWhere('ov.value = :color')
  126.         //                 ->setParameter('color',$filters['color']);
  127.         //     }
  129.         //     if( array_key_exists('size',$filters) & !empty($filters['size']) ){
  130.         //             $query->andWhere('ov.value = :size')
  131.         //                     ->setParameter('size',$filters['size']);
  132.         //     }
  133.         //     //dd($filters);
  134.         //     if( array_key_exists('price_min',$filters) and array_key_exists('price_max',$filters)){
  135.         //             $query->andWhere('v.sellingPrice BETWEEN :minPrice and :maxPrice')
  136.         //                     ->setParameter('minPrice',$filters['price_min'])
  137.         //                     ->setParameter('maxPrice',$filters['price_max']);
  138.         //     }
  140.    
  141.         // }
  144.         // return $query->groupBy('p.id')
  145.         //             ->groupBy('v.color')
  146.         //             ->getQuery()
  147.         //             ->getResult();
  150.             $query = $this->createQueryBuilder('p')
  151.                             ->select('p', 'v', 'ovColor', 'ovSize')
  152.                             ->leftJoin('p.variants', 'v')
  153.                             ->leftJoin('v.optionValues', 'ovColor', 'WITH', 'ovColor.name = :colorName')
  154.                             ->leftJoin('v.optionValues', 'ovSize', 'WITH', 'ovSize.name = :sizeName')
  155.                             ->setParameters([
  156.                                 'colorName' => 'Color',
  157.                                 'sizeName' => 'Size',
  158.                             ]);
  160.             $query->andWhere(':collection MEMBER OF p.collections')
  161.                          ->setParameter('collection', $collection);                
  164.             if($filters){
  166.                     if( array_key_exists("color",$filters) & !empty($filters['color']) ){
  167.                         $color = strtolower($filters["color"]);
  168.                         $query->andWhere('LOWER(ovColor.value) = :color')
  169.                                 ->setParameter('color',$color);
  170.                     }
  172.                     if( array_key_exists('size',$filters) & !empty($filters['size']) ){
  173.                         $query->andWhere('ovSize.value = :size')
  174.                                 ->setParameter('size',$filters["size"]);
  175.                     }
  177.                     if(array_key_exists('priceRange',$filters)){
  178.                         $query->andWhere('v.sellingPrice BETWEEN :minPrice and :maxPrice')
  179.                                 ->setParameter('minPrice',$filters['price_min'])
  180.                                 ->setParameter('maxPrice',$filters['price_max']);
  181.                     }
  183.                     // dump($query->getQuery());
  184.                     return $query->getQuery()
  185.                             ->getResult();
  187.             }
  189.             return $query->groupBy('v.color')
  190.                     ->getQuery()
  191.                     ->getResult();
  193.     }
  197.     /**
  198.      * @param $slugOrId
  199.      * @return Product|null
  200.      * @throws \Doctrine\ORM\NonUniqueResultException
  201.      */
  202.     public function findProductBySlugOrId($slugOrId): ?Product
  203.     {
  204.         return $this->createQueryBuilder('p')
  205.                     ->andWhere('p.id = :slugOrId')
  206.                     ->orWhere('p.slug = :slugOrId')
  207.                     ->setParameter('val',$slugOrId)
  208.                     ->getQuery()
  209.                     ->getOneOrNullResult();
  210.     }
  212.     /**
  213.      * @param $value
  214.      * @return array|null
  215.      */
  216.     public function getProductsByCollection($idOrName): ?array
  217.     {
  219.         // $conn = $this->getEntityManager()->getConnection();
  220.         // $sql = "SELECT *  FROM `product` WHERE collection_id = :id";
  221.         // $results = $conn->executeQuery($sql,['id' => $id]);
  223.         // return $results->fetchAllAssociative();
  224.    
  225.         return $this->createQueryBuilder('p')
  226.             ->andWhere('p.collection_name = :val')
  227.             ->setParameter('val', $idOrName)
  228.             ->setMaxResults(10)
  229.             ->getQuery()
  230.             ->getResult();
  231.     }
  237.     /**
  238.      * @param $limit
  239.      * @return null|array
  240.      */
  241.     public function findWithLimit($limit): ?array
  242.     {
  243.         return $this->createQueryBuilder('p')
  244.             ->setMaxResults($limit)
  245.             ->getQuery()
  246.             ->getResult();
  247.     }
  250.     public function findRelatedProducts($categories): ?array
  251.     {
  252.         return $this->createQueryBuilder('p')
  253.                     ->andWhere(':vals MEMBER OF p.categories')
  254.                     ->setParameter('vals', $categories)
  255.                     ->setMaxResults('10')
  256.                     ->getQuery()
  257.                     ->getResult();
  258.     }
  260.     public function findCategoryProducts($category,$filters): ?array
  261.     {
  264.         $query = $this->createQueryBuilder('p')
  265.                         ->select('p', 'v', 'ovColor', 'ovSize')
  266.                         ->leftJoin('p.variants', 'v')
  267.                         ->leftJoin('v.optionValues', 'ovColor', 'WITH', 'ovColor.name = :colorName')
  268.                         ->leftJoin('v.optionValues', 'ovSize', 'WITH', 'ovSize.name = :sizeName')
  269.                         ->setParameters([
  270.                             'colorName' => 'Color',
  271.                             'sizeName' => 'Size',
  272.                         ]);
  274.         $query->andWhere(':category MEMBER OF p.categories')
  275.                 ->setParameter('category', $category);                
  278.         if($filters){
  280.             if( array_key_exists("color",$filters) & !empty($filters['color']) ){
  281.                 $color = strtolower($filters["color"]);
  282.                 $query->andWhere('LOWER(ovColor.value) = :color')
  283.                         ->setParameter('color',$color);
  284.             }
  286.             if( array_key_exists('size',$filters) & !empty($filters['size']) ){
  287.                 $query->andWhere('ovSize.value = :size')
  288.                         ->setParameter('size',$filters["size"]);
  289.             }
  291.             if(array_key_exists('priceRange',$filters)){
  292.                 $query->andWhere('v.sellingPrice BETWEEN :minPrice and :maxPrice')
  293.                         ->setParameter('minPrice',$filters['price_min'])
  294.                         ->setParameter('maxPrice',$filters['price_max']);
  295.             }
  297.             // dump($query->getQuery());
  298.             return $query->getQuery()
  299.                         ->getResult();
  301.         }
  303.         return $query->groupBy('v.color')
  304.                         ->getQuery()
  305.                         ->getResult();
  306.     }
  308.     public function findByNameLike(string $searchInput)
  309.     {
  310.         return $this->createQueryBuilder('p')
  311.                         ->andWhere('p.name LIKE :searchInput')
  312.                         ->setParameter('searchInput','%'.$searchInput.'%')
  313.                         ->setMaxResults(10)
  314.                         ->getQuery()
  315.                         ->getResult();
  316.     }
  318. }