src/Eccube/Repository/ProductRepository.php line 58

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of EC-CUBE
  5.  *
  6.  * Copyright(c) EC-CUBE CO.,LTD. All Rights Reserved.
  7.  *
  8.  * http://www.ec-cube.co.jp/
  9.  *
  10.  * For the full copyright and license information, please view the LICENSE
  11.  * file that was distributed with this source code.
  12.  */
  14. namespace Eccube\Repository;
  16. use Doctrine\Common\Collections\ArrayCollection;
  17. use Doctrine\Persistence\ManagerRegistry as RegistryInterface;
  18. use Eccube\Common\EccubeConfig;
  19. use Eccube\Doctrine\Query\Queries;
  20. use Eccube\Entity\Category;
  21. use Eccube\Entity\Master\ProductListMax;
  22. use Eccube\Entity\Master\ProductListOrderBy;
  23. use Eccube\Entity\Master\ProductStatus;
  24. use Eccube\Entity\Product;
  25. use Eccube\Entity\ProductStock;
  26. use Eccube\Entity\Tag;
  27. use Eccube\Util\StringUtil;
  29. /**
  30.  * ProductRepository
  31.  *
  32.  * This class was generated by the Doctrine ORM. Add your own custom
  33.  * repository methods below.
  34.  */
  35. class ProductRepository extends AbstractRepository
  36. {
  37.     /**
  38.      * @var Queries
  39.      */
  40.     protected $queries;
  42.     /**
  43.      * @var EccubeConfig
  44.      */
  45.     protected $eccubeConfig;
  47.     public const COLUMNS = [
  48.         'product_id' => 'p.id', 'name' => 'p.name', 'product_code' => 'pc.code', 'stock' => 'pc.stock', 'status' => 'p.Status', 'create_date' => 'p.create_date', 'update_date' => 'p.update_date',
  49.     ];
  51.     /**
  52.      * ProductRepository constructor.
  53.      *
  54.      * @param RegistryInterface $registry
  55.      * @param Queries $queries
  56.      * @param EccubeConfig $eccubeConfig
  57.      */
  58.     public function __construct(
  59.         RegistryInterface $registry,
  60.         Queries $queries,
  61.         EccubeConfig $eccubeConfig
  62.     ) {
  63.         parent::__construct($registry, Product::class);
  64.         $this->queries = $queries;
  65.         $this->eccubeConfig = $eccubeConfig;
  66.     }
  68.     /**
  69.      * Find the Product with sorted ClassCategories.
  70.      *
  71.      * @param integer $productId
  72.      *
  73.      * @return Product
  74.      */
  75.     public function findWithSortedClassCategories($productId)
  76.     {
  77.         $qb = $this->createQueryBuilder('p');
  78.         $qb->addSelect(['pc', 'cc1', 'cc2', 'pi', 'pt'])
  79.             ->innerJoin('p.ProductClasses', 'pc')
  80.             ->leftJoin('pc.ClassCategory1', 'cc1')
  81.             ->leftJoin('pc.ClassCategory2', 'cc2')
  82.             ->leftJoin('p.ProductImage', 'pi')
  83.             ->leftJoin('p.ProductTag', 'pt')
  84.             ->where('p.id = :id')
  85.             ->andWhere('pc.visible = :visible')
  86.             ->setParameter('id', $productId)
  87.             ->setParameter('visible', true)
  88.             ->orderBy('cc1.sort_no', 'ASC')
  89.             ->addOrderBy('cc2.sort_no', 'ASC');
  91.         $product = $qb
  92.             ->getQuery()
  93.             ->getSingleResult();
  95.         return $product;
  96.     }
  98.     /**
  99.      * Find the Products with sorted ClassCategories.
  100.      *
  101.      * @param array $ids Product in ids
  102.      * @param string $indexBy The index for the from.
  103.      *
  104.      * @return ArrayCollection|array
  105.      */
  106.     public function findProductsWithSortedClassCategories(array $ids, $indexBy = null)
  107.     {
  108.         if (count($ids) < 1) {
  109.             return [];
  110.         }
  111.         $qb = $this->createQueryBuilder('p', $indexBy);
  112.         $qb->addSelect(['pc', 'cc1', 'cc2', 'pi', 'pt', 'tr', 'ps'])
  113.             ->innerJoin('p.ProductClasses', 'pc')
  114.             // XXX Joined 'TaxRule' and 'ProductStock' to prevent lazy loading
  115.             ->leftJoin('pc.TaxRule', 'tr')
  116.             ->innerJoin('pc.ProductStock', 'ps')
  117.             ->leftJoin('pc.ClassCategory1', 'cc1')
  118.             ->leftJoin('pc.ClassCategory2', 'cc2')
  119.             ->leftJoin('p.ProductImage', 'pi')
  120.             ->leftJoin('p.ProductTag', 'pt')
  121.             ->where($qb->expr()->in('p.id', $ids))
  122.             ->andWhere('pc.visible = :visible')
  123.             ->setParameter('visible', true)
  124.             ->orderBy('cc1.sort_no', 'ASC')
  125.             ->addOrderBy('cc2.sort_no', 'ASC');
  127.         $products = $qb
  128.             ->getQuery()
  129.             ->useResultCache(true, $this->eccubeConfig['eccube_result_cache_lifetime_short'])
  130.             ->getResult();
  132.         return $products;
  133.     }
  135.     /**
  136.      * get query builder.
  137.      *
  138.      * @param array{
  139.      *         category_id?:Category,
  140.      *         name?:string,
  141.      *         pageno?:string,
  142.      *         disp_number?:ProductListMax,
  143.      *         orderby?:ProductListOrderBy
  144.      *     } $searchData
  145.      *
  146.      * @return \Doctrine\ORM\QueryBuilder
  147.      */
  148.     public function getQueryBuilderBySearchData($searchData)
  149.     {
  150.         $qb = $this->createQueryBuilder('p')
  151.             ->andWhere('p.Status = 1');
  153.         // category
  154.         $categoryJoin = false;
  155.         if (!empty($searchData['category_id']) && $searchData['category_id']) {
  156.             $Categories = $searchData['category_id']->getSelfAndDescendants();
  157.             if ($Categories) {
  158.                 $qb
  159.                     ->innerJoin('p.ProductCategories', 'pct')
  160.                     ->innerJoin('pct.Category', 'c')
  161.                     ->andWhere($qb->expr()->in('pct.Category', ':Categories'))
  162.                     ->setParameter('Categories', $Categories);
  163.                 $categoryJoin = true;
  164.             }
  165.         }
  167.         // name
  168.         if (isset($searchData['name']) && StringUtil::isNotBlank($searchData['name'])) {
  169.             $keywords = preg_split('/[\s　]+/u', str_replace(['%', '_'], ['\\%', '\\_'], $searchData['name']), -1, PREG_SPLIT_NO_EMPTY);
  171.             foreach ($keywords as $index => $keyword) {
  172.                 $key = sprintf('keyword%s', $index);
  173.                 $qb
  174.                     ->andWhere(sprintf('NORMALIZE(p.name) LIKE NORMALIZE(:%s) OR
  175.                         NORMALIZE(p.search_word) LIKE NORMALIZE(:%s) OR
  176.                         EXISTS (SELECT wpc%d FROM \Eccube\Entity\ProductClass wpc%d WHERE p = wpc%d.Product AND NORMALIZE(wpc%d.code) LIKE NORMALIZE(:%s))',
  177.                         $key, $key, $index, $index, $index, $index, $key))
  178.                     ->setParameter($key, '%'.$keyword.'%');
  179.             }
  180.         }
  182.         // Order By
  183.         // 価格低い順
  184.         $config = $this->eccubeConfig;
  185.         if (!empty($searchData['orderby']) && $searchData['orderby']->getId() == $config['eccube_product_order_price_lower']) {
  186.             // @see http://doctrine-orm.readthedocs.org/en/latest/reference/dql-doctrine-query-language.html
  187.             $qb->addSelect('MIN(pc.price02) as HIDDEN price02_min');
  188.             $qb->innerJoin('p.ProductClasses', 'pc');
  189.             $qb->andWhere('pc.visible = true');
  190.             $qb->groupBy('p.id');
  191.             $qb->orderBy('price02_min', 'ASC');
  192.             $qb->addOrderBy('p.id', 'DESC');
  193.         // 価格高い順
  194.         } elseif (!empty($searchData['orderby']) && $searchData['orderby']->getId() == $config['eccube_product_order_price_higher']) {
  195.             $qb->addSelect('MAX(pc.price02) as HIDDEN price02_max');
  196.             $qb->innerJoin('p.ProductClasses', 'pc');
  197.             $qb->andWhere('pc.visible = true');
  198.             $qb->groupBy('p.id');
  199.             $qb->orderBy('price02_max', 'DESC');
  200.             $qb->addOrderBy('p.id', 'DESC');
  201.         // 新着順
  202.         } elseif (!empty($searchData['orderby']) && $searchData['orderby']->getId() == $config['eccube_product_order_newer']) {
  203.             // 在庫切れ商品非表示の設定が有効時対応
  204.             // @see https://github.com/EC-CUBE/ec-cube/issues/1998
  205.             if ($this->getEntityManager()->getFilters()->isEnabled('option_nostock_hidden') == true) {
  206.                 $qb->innerJoin('p.ProductClasses', 'pc');
  207.                 $qb->andWhere('pc.visible = true');
  208.             }
  209.             $qb->orderBy('p.create_date', 'DESC');
  210.             $qb->addOrderBy('p.id', 'DESC');
  211.         } else {
  212.             if ($categoryJoin === false) {
  213.                 $qb
  214.                     ->leftJoin('p.ProductCategories', 'pct')
  215.                     ->leftJoin('pct.Category', 'c');
  216.             }
  217.             $qb
  218.                 ->addOrderBy('p.id', 'DESC');
  219.         }
  221.         return $this->queries->customize(QueryKey::PRODUCT_SEARCH, $qb, $searchData);
  222.     }
  224.     /**
  225.      * 複数カテゴリIDに属する商品を取得する（いずれかのカテゴリに属していれば対象）.
  226.      *
  227.      * @param int[] $categoryIds カテゴリIDの配列
  228.      * @param int $maxResults 取得件数
  229.      *
  230.      * @return Product[]
  231.      */
  232.     public function getProductsByCategoryIds(array $categoryIds, int $maxResults = 8): array
  233.     {
  234.         if (count($categoryIds) === 0) {
  235.             return [];
  236.         }
  238.         $categoryRepository = $this->getEntityManager()->getRepository(Category::class);
  239.         $allCategories = [];
  240.         $seenIds = [];
  242.         foreach ($categoryIds as $id) {
  243.             $Category = $categoryRepository->find((int) $id);
  244.             if (!$Category) {
  245.                 continue;
  246.             }
  247.             foreach ($Category->getSelfAndDescendants() as $C) {
  248.                 $cid = $C->getId();
  249.                 if (!in_array($cid, $seenIds, true)) {
  250.                     $seenIds[] = $cid;
  251.                     $allCategories[] = $C;
  252.                 }
  253.             }
  254.         }
  256.         if (count($allCategories) === 0) {
  257.             return [];
  258.         }
  260.         $qb = $this->createQueryBuilder('p')
  261.             ->distinct()
  262.             ->andWhere('p.Status = 1')
  263.             ->innerJoin('p.ProductCategories', 'pct')
  264.             ->innerJoin('pct.Category', 'c')
  265.             ->andWhere('pct.Category IN (:Categories)')
  266.             ->setParameter('Categories', $allCategories)
  267.             ->orderBy('p.id', 'DESC')
  268.             ->setMaxResults($maxResults);
  270.         $query = $qb->getQuery();
  271.         $query->useResultCache(
  272.             true,
  273.             $this->eccubeConfig['eccube_result_cache_lifetime_short'],
  274.             'product_by_category_ids_'.implode('_', array_map('intval', $categoryIds))
  275.         );
  277.         return $query->getResult();
  278.     }
  280.     /**
  281.      * get query builder.
  282.      *
  283.      * @param array{
  284.      *         id?:string|int|null,
  285.      *         category_id?:Category,
  286.      *         status?:ProductStatus[],
  287.      *         link_status?:ProductStatus[],
  288.      *         stock_status?:int,
  289.      *         stock?:ProductStock::IN_STOCK|ProductStock::OUT_OF_STOCK,
  290.      *         tag_id?:Tag,
  291.      *         create_datetime_start?:\DateTime,
  292.      *         create_datetime_end?:\DateTime,
  293.      *         create_date_start?:\DateTime,
  294.      *         create_date_end?:\DateTime,
  295.      *         update_datetime_start?:\DateTime,
  296.      *         update_datetime_end?:\DateTime,
  297.      *         update_date_start?:\DateTime,
  298.      *         update_date_end?:\DateTime,
  299.      *         sortkey?:string,
  300.      *         sorttype?:string
  301.      *     } $searchData
  302.      *
  303.      * @return \Doctrine\ORM\QueryBuilder
  304.      */
  305.     public function getQueryBuilderBySearchDataForAdmin($searchData)
  306.     {
  307.         $qb = $this->createQueryBuilder('p')
  308.             ->addSelect('pc', 'pi', 'tr', 'ps')
  309.             ->innerJoin('p.ProductClasses', 'pc')
  310.             ->leftJoin('p.ProductImage', 'pi')
  311.             ->leftJoin('pc.TaxRule', 'tr')
  312.             ->leftJoin('pc.ProductStock', 'ps')
  313.             ->andWhere('pc.visible = :visible')
  314.             ->setParameter('visible', true);
  316.         // id
  317.         if (isset($searchData['id']) && StringUtil::isNotBlank($searchData['id'])) {
  318.             $id = preg_match('/^\d{0,10}$/', $searchData['id']) ? $searchData['id'] : null;
  319.             if ($id && $id > '2147483647' && $this->isPostgreSQL()) {
  320.                 $id = null;
  321.             }
  322.             $qb
  323.                 ->andWhere('p.id = :id OR p.name LIKE :likeid OR pc.code LIKE :likeid')
  324.                 ->setParameter('id', $id)
  325.                 ->setParameter('likeid', '%'.str_replace(['%', '_'], ['\\%', '\\_'], $searchData['id']).'%');
  326.         }
  328.         // code
  329.         /*
  330.         if (!empty($searchData['code']) && $searchData['code']) {
  331.             $qb
  332.                 ->innerJoin('p.ProductClasses', 'pc')
  333.                 ->andWhere('pc.code LIKE :code')
  334.                 ->setParameter('code', '%' . $searchData['code'] . '%');
  335.         }
  337.         // name
  338.         if (!empty($searchData['name']) && $searchData['name']) {
  339.             $keywords = preg_split('/[\s　]+/u', $searchData['name'], -1, PREG_SPLIT_NO_EMPTY);
  340.             foreach ($keywords as $keyword) {
  341.                 $qb
  342.                     ->andWhere('p.name LIKE :name')
  343.                     ->setParameter('name', '%' . $keyword . '%');
  344.             }
  345.         }
  346.        */
  348.         // category
  349.         if (!empty($searchData['category_id']) && $searchData['category_id']) {
  350.             $Categories = $searchData['category_id']->getSelfAndDescendants();
  351.             if ($Categories) {
  352.                 $qb
  353.                     ->innerJoin('p.ProductCategories', 'pct')
  354.                     ->innerJoin('pct.Category', 'c')
  355.                     ->andWhere($qb->expr()->in('pct.Category', ':Categories'))
  356.                     ->setParameter('Categories', $Categories);
  357.             }
  358.         }
  360.         // status
  361.         if (!empty($searchData['status']) && $searchData['status']) {
  362.             $qb
  363.                 ->andWhere($qb->expr()->in('p.Status', ':Status'))
  364.                 ->setParameter('Status', $searchData['status']);
  365.         }
  367.         // link_status
  368.         if (isset($searchData['link_status']) && !empty($searchData['link_status'])) {
  369.             $qb
  370.                 ->andWhere($qb->expr()->in('p.Status', ':Status'))
  371.                 ->setParameter('Status', $searchData['link_status']);
  372.         }
  374.         // stock status
  375.         if (isset($searchData['stock_status'])) {
  376.             $qb
  377.                 ->andWhere('pc.stock_unlimited = :StockUnlimited AND pc.stock = 0')
  378.                 ->setParameter('StockUnlimited', $searchData['stock_status']);
  379.         }
  381.         // stock status
  382.         if (isset($searchData['stock']) && !empty($searchData['stock'])) {
  383.             switch ($searchData['stock']) {
  384.                 case [ProductStock::IN_STOCK]:
  385.                     $qb->andWhere('pc.stock_unlimited = true OR pc.stock > 0');
  386.                     break;
  387.                 case [ProductStock::OUT_OF_STOCK]:
  388.                     $qb->andWhere('pc.stock_unlimited = false AND pc.stock <= 0');
  389.                     break;
  390.                 default:
  391.                     // 共に選択された場合は全権該当するので検索条件に含めない
  392.             }
  393.         }
  395.         // tag
  396.         if (!empty($searchData['tag_id']) && $searchData['tag_id']) {
  397.             $qb
  398.                 ->innerJoin('p.ProductTag', 'pt')
  399.                 ->andWhere('pt.Tag = :tag_id')
  400.                 ->setParameter('tag_id', $searchData['tag_id']);
  401.         }
  403.         // crate_date
  404.         if (!empty($searchData['create_datetime_start']) && $searchData['create_datetime_start']) {
  405.             $date = $searchData['create_datetime_start'];
  406.             $qb
  407.                 ->andWhere('p.create_date >= :create_date_start')
  408.                 ->setParameter('create_date_start', $date);
  409.         } elseif (!empty($searchData['create_date_start']) && $searchData['create_date_start']) {
  410.             $date = $searchData['create_date_start'];
  411.             $qb
  412.                 ->andWhere('p.create_date >= :create_date_start')
  413.                 ->setParameter('create_date_start', $date);
  414.         }
  416.         if (!empty($searchData['create_datetime_end']) && $searchData['create_datetime_end']) {
  417.             $date = $searchData['create_datetime_end'];
  418.             $qb
  419.                 ->andWhere('p.create_date < :create_date_end')
  420.                 ->setParameter('create_date_end', $date);
  421.         } elseif (!empty($searchData['create_date_end']) && $searchData['create_date_end']) {
  422.             $date = clone $searchData['create_date_end'];
  423.             $date = $date
  424.                 ->modify('+1 days');
  425.             $qb
  426.                 ->andWhere('p.create_date < :create_date_end')
  427.                 ->setParameter('create_date_end', $date);
  428.         }
  430.         // update_date
  431.         if (!empty($searchData['update_datetime_start']) && $searchData['update_datetime_start']) {
  432.             $date = $searchData['update_datetime_start'];
  433.             $qb
  434.                 ->andWhere('p.update_date >= :update_date_start')
  435.                 ->setParameter('update_date_start', $date);
  436.         } elseif (!empty($searchData['update_date_start']) && $searchData['update_date_start']) {
  437.             $date = $searchData['update_date_start'];
  438.             $qb
  439.                 ->andWhere('p.update_date >= :update_date_start')
  440.                 ->setParameter('update_date_start', $date);
  441.         }
  443.         if (!empty($searchData['update_datetime_end']) && $searchData['update_datetime_end']) {
  444.             $date = $searchData['update_datetime_end'];
  445.             $qb
  446.                 ->andWhere('p.update_date < :update_date_end')
  447.                 ->setParameter('update_date_end', $date);
  448.         } elseif (!empty($searchData['update_date_end']) && $searchData['update_date_end']) {
  449.             $date = clone $searchData['update_date_end'];
  450.             $date = $date
  451.                 ->modify('+1 days');
  452.             $qb
  453.                 ->andWhere('p.update_date < :update_date_end')
  454.                 ->setParameter('update_date_end', $date);
  455.         }
  457.         // Order By
  458.         if (isset($searchData['sortkey']) && !empty($searchData['sortkey'])) {
  459.             $sortOrder = (isset($searchData['sorttype']) && $searchData['sorttype'] == 'a') ? 'ASC' : 'DESC';
  461.             $qb->orderBy(self::COLUMNS[$searchData['sortkey']], $sortOrder);
  462.             $qb->addOrderBy('p.update_date', 'DESC');
  463.             $qb->addOrderBy('p.id', 'DESC');
  464.         } else {
  465.             $qb->orderBy('p.update_date', 'DESC');
  466.             $qb->addOrderBy('p.id', 'DESC');
  467.         }
  469.         return $this->queries->customize(QueryKey::PRODUCT_SEARCH_ADMIN, $qb, $searchData);
  470.     }
  471. }