src/Repository/ProductVariantRepository.php line 83

Open in your IDE?
  1. <?php
  3. namespace App\Repository;
  4. use App\Entity\Gos\Country;
  5. use App\Entity\Gos\Product;
  6. use App\Entity\Gos\ProductAssociation;
  7. use App\Entity\Gos\ProductVariant;
  8. use App\Entity\Gos\ProductVariantPack;
  9. use App\Entity\Gos\Uniqskills\Course;
  10. use App\Enum\Product\ProductSourceSystem;
  11. use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository;
  12. use Doctrine\Common\Collections\Collection;
  13. use Doctrine\DBAL\Connection;
  14. use Doctrine\ORM\EntityRepository;
  15. use Doctrine\ORM\Query;
  16. use Doctrine\ORM\QueryBuilder;
  17. use Doctrine\Persistence\ManagerRegistry;
  19. /**
  20.  * ProductVariantRepository
  21.  *
  22.  * This class was generated by the Doctrine ORM. Add your own custom
  23.  * repository methods below.
  24.  */
  25. class ProductVariantRepository extends ServiceEntityRepository
  26. {
  27.     public function __construct(ManagerRegistry $registry)
  28.     {
  29.         parent::__construct($registry, ProductVariant::class);
  30.     }
  31.     private const WIDGETS_CACHE_RESULT_LIFETIME = 300; //5 minutes
  33.     public function findAllByCourseAndCountryCode($courseSlug, $myCountryCode)
  34.     {
  35.         return $this
  36.             ->createQueryBuilder('pv')
  37.             ->leftJoin('pv.courses', 'course')
  38.             ->leftJoin('pv.country', 'country')
  39.             ->where('course.slug = :courseSlug')
  40.             ->setParameter('courseSlug', $courseSlug)
  41.             ->andWhere('country.alpha2 = :countryCode')
  42.             ->setParameter('countryCode', $myCountryCode)
  43.             ->getQuery()
  44.             ->getResult();
  45.     }
  47.     public function findProductVariantToAdd($arrayProductVariantNo)
  48.     {
  49.         return $this
  50.             ->createQueryBuilder('pv')
  51.             ->leftJoin('pv.physicalVariant', 'mpv')
  52.             ->where('pv.productVariantNoComplete IN (:pvnc)')
  53.             ->orWhere('mpv.productVariantNoComplete IN (:pvnc) AND pv.isAddition =:isAddition')
  54.             ->setParameter('pvnc', $arrayProductVariantNo)
  55.             ->setParameter('isAddition', true)
  56.             ->getQuery()
  57.             ->getResult();
  58.     }
  60.     public function findOneByIdAndProductVariantNoComplete($productVariantId, $productVariantNoComplete)
  61.     {
  62.         return $this
  63.             ->createQueryBuilder('pv')
  64.             ->leftJoin('pv.physicalVariant', 'physicalVariant')
  65.             ->where('pv.id = :id')
  66.             ->setParameter('id', $productVariantId)
  67.             ->andWhere('physicalVariant.productVariantNoComplete = :physicalVariant')
  68.             ->setParameter('physicalVariant', $productVariantNoComplete)
  69.             ->getQuery()->setMaxResults(1)->getOneOrNullResult();
  70.     }
  72.     public function findTaxFreeForBudgetUnitIsTrue($productCart)
  73.     {
  74.         return $this
  75.             ->createQueryBuilder('pv')
  76.             ->leftJoin('pv.productCart', 'pc')
  77.             ->where('pc.id IN (:id)')
  78.             ->setParameter('id', $productCart)
  79.             ->andWhere('pv.taxFreeForBudgetUnit = true')
  80.             ->getQuery()->getResult();
  81.     }
  83.     public function findAllFiltered(QueryBuilder $qb, $psId = 0, $number = null, $isEvent = null, $course = null, $country = null, $sourceSystem): QueryBuilder
  84.     {
  85.         $qb
  86.             ->distinct()
  87.             ->select('pv')
  88.             ->from(ProductVariant::class, 'pv');
  90.         if ($psId)
  91.         {
  92.             $qb
  93.                 ->leftJoin('pv.portalSettings', 'ps')
  94.                 ->where('ps.id = :portalSettingsId')
  95.                 ->setParameter('portalSettingsId', $psId);
  96.         }
  98.         if (!empty($number))
  99.         {
  100.             $qb
  101.                 ->andWhere('pv.productVariantNoComplete = :no')
  102.                 ->setParameter('no', $number);
  103.         }
  105.         if (!is_null($isEvent))
  106.         {
  107.             $qb
  108.                 ->leftJoin('pv.masterProduct', 'master_product')
  109.                 ->leftJoin('master_product.productGosType', 'product_gos_type');
  111.             if ($isEvent)
  112.             {
  113.                 $qb->where('product_gos_type.name = :productGosType')
  114.                     ->setParameter('productGosType', 'event');
  115.             }
  116.             else
  117.             {
  118.                 $qb->where('product_gos_type.name != :productGosType')
  119.                     ->setParameter('productGosType', 'event');
  120.             }
  121.         }
  123.         if ($course)
  124.         {
  125.             $qb
  126.                 ->leftJoin('pv.courses', 'c')
  127.                 ->andWhere('c.id = (:cid)')
  128.                 ->setParameter('cid', $course);
  129.         }
  131.         if ($country)
  132.         {
  133.             $qb
  134.                 ->leftJoin('pv.country', 'country')
  135.                 ->andWhere('country.id = (:countryid)')
  136.                 ->setParameter('countryid', $country);
  137.         }
  139.         if (!empty($sourceSystem))
  140.         {
  141.             $sourceSystem = ProductSourceSystem::from($sourceSystem);
  142.             $qb
  143.                 ->innerJoin('pv.masterProduct', 'masterProduct')
  144.                 ->andWhere('masterProduct.sourceSystem = :sourceSystem')
  145.                 ->setParameter('sourceSystem', $sourceSystem);
  146.         }
  148.         return $qb;
  149.     }
  151.     public function findOnlyEvents($notAssignedToEventsEntity = false, $maximum = null)
  152.     {
  153.         $qb = $this->createQueryBuilder('e')
  154.                 ->leftJoin('e.masterProduct', 'mp')
  155.                 ->leftJoin('mp.productGosType', 'product_gos_type')
  156.                 ->where('product_gos_type.name = :productGosType')
  157.                 ->setParameter('productGosType', 'event');
  159.         if ($notAssignedToEventsEntity === true)
  160.         {
  161.             $qb
  162.                ->andWhere('e.events is null');
  163.         }
  165.         if (!is_null($maximum))
  166.         {
  167.             $qb->setMaxResults($maximum);
  168.         }
  170.         return $qb->getQuery()->getResult();
  171.     }
  173.     public function findForAjaxFilter($productVariantNoComplete, array $findIn = null)
  174.     {
  175.         $form = $this
  176.             ->createQueryBuilder('pv')
  177.             ->select("pv.id, COALESCE(pv.productVariantNoComplete, CONCAT(pv.id, ' ', pv.workingTitle)) as text");
  179.         if (!empty($productVariantNoComplete))
  180.         {
  181.             $form
  182.                 ->andWhere("COALESCE(pv.productVariantNoComplete, CONCAT(pv.id, ' ', pv.workingTitle)) LIKE :productVariantNoComplete")
  183.                 ->setParameter('productVariantNoComplete', $productVariantNoComplete . '%');
  184.         }
  186.         if (is_iterable($findIn))
  187.         {
  188.             $form
  189.                 ->andWhere('pv.id IN (:findIn)')
  190.                 ->setParameter('findIn', $findIn)
  191.             ;
  192.         }
  194.         return $form->getQuery();
  195.     }
  197.     public function findForAjaxFilterBCOnly($productVariantNoComplete)
  198.     {
  199.         $form = $this
  200.             ->createQueryBuilder('pv')
  201.             ->select("pv.id, COALESCE(pv.productVariantNoComplete, CONCAT(pv.id, ' ', pv.workingTitle)) as text")
  202.             ->innerJoin('pv.masterProduct', 'mp')
  203.             ->andWhere('mp.sourceSystem = :sourceSystem')
  204.             ->setParameter('sourceSystem', ProductSourceSystem::BC);
  206.         if (!empty($productVariantNoComplete)) {
  207.             $form
  208.                 ->andWhere("COALESCE(pv.productVariantNoComplete, CONCAT(pv.id, ' ', pv.workingTitle)) LIKE :productVariantNoComplete")
  209.                 ->setParameter('productVariantNoComplete', $productVariantNoComplete . '%');
  210.         }
  212.         return $form->getQuery();
  213.     }
  215.     public function findByProductsVariantsNo($productsVariantsNumbers, $isAddition, $getPhysicalVariant = true)
  216.     {
  217.         $query = $this
  218.             ->createQueryBuilder('pv')
  219.             ->where('pv.productVariantNoComplete IN (:pvnc)');
  221.         if ($getPhysicalVariant)
  222.         {
  223.             $query
  224.                 ->leftJoin('pv.physicalVariant', 'mpv')
  225.                 ->orWhere('mpv.productVariantNoComplete IN (:pvnc) AND pv.isAddition =:isAddition')
  226.                 ->setParameter('isAddition', $isAddition);
  227.         }
  229.         return $query->setParameter('pvnc', $productsVariantsNumbers)->getQuery()->getResult();
  230.     }
  232.     public function findOneByProductVariantsNo($productsVariantsNumber, $isAddition)
  233.     {
  234.         return $this
  235.             ->createQueryBuilder('pv')
  236.             ->leftJoin('pv.physicalVariant', 'mpv')
  237.             ->where('pv.productVariantNoComplete = :pvnc')
  238.             ->orWhere('mpv.productVariantNoComplete = :pvnc AND pv.isAddition =:isAddition')
  239.             ->setParameter('pvnc', $productsVariantsNumber)
  240.             ->setParameter('isAddition', $isAddition)
  241.             ->getQuery()
  242.             ->disableResultCache()
  243.             ->setMaxResults(1)->getOneOrNullResult();
  244.     }
  246.     // This method is used to find a product variant by its number with caching for widgets (e.g. show-price).
  247.     public function findOneByProductVariantsNoCacheable($productsVariantsNumber, $isAddition)
  248.     {
  249.         return $this
  250.             ->createQueryBuilder('pv')
  251.             ->leftJoin('pv.physicalVariant', 'mpv')
  252.             ->where('pv.productVariantNoComplete = :pvnc')
  253.             ->orWhere('mpv.productVariantNoComplete = :pvnc AND pv.isAddition =:isAddition')
  254.             ->setParameter('pvnc', $productsVariantsNumber)
  255.             ->setParameter('isAddition', $isAddition)
  256.             ->getQuery()
  257.             ->enableResultCache(self::WIDGETS_CACHE_RESULT_LIFETIME, 'PV_' . $productsVariantsNumber . '_' . (int)$isAddition)
  258.             ->setMaxResults(1)->getOneOrNullResult();
  259.     }
  261.     // This method is used to find a product variant by its id with caching for widgets (e.g. show-price).
  262.     public function findOneCacheable($id)
  263.     {
  264.         return $this
  265.             ->createQueryBuilder('pv')
  266.             ->where('pv.id = :id')
  267.             ->setParameter('id', $id)
  268.             ->getQuery()
  269.             ->enableResultCache(self::WIDGETS_CACHE_RESULT_LIFETIME, 'PV_byId_' . $id)
  270.             ->setMaxResults(1)
  271.             ->getOneOrNullResult();
  272.     }
  274.     // This method is used to find a product variant by its number with caching for widgets (e.g. show-price-omnibus, check-exclusive-pv-info).
  275.     public function findOneByProductVariantNoCompleteCacheable($productsVariantsNumber)
  276.     {
  277.         return $this
  278.             ->createQueryBuilder('pv')
  279.             ->where('pv.productVariantNoComplete = :pvnc')
  280.             ->setParameter('pvnc', $productsVariantsNumber)
  281.             ->getQuery()
  282.             ->enableResultCache(self::WIDGETS_CACHE_RESULT_LIFETIME, 'PV_byNoComplete_' . $productsVariantsNumber)
  283.             ->setMaxResults(1)
  284.             ->getOneOrNullResult();
  285.     }
  287.     public function findMaxProductVariantId()
  288.     {
  289.         return $this->createQueryBuilder('pv')
  290.             ->select('MAX(pv.productVariantId) AS newId')
  291.             ->setMaxResults(1)
  292.             ->getQuery()
  293.             ->getOneOrNullResult();
  294.     }
  296.     public function findLastProductVariantNoComplete($masterProductId)
  297.     {
  298.         $sql = 'SELECT pv.product_variant_no
  299.                 FROM product_variant pv 
  300.                 WHERE pv.master_product_id='.$masterProductId.' 
  301.                 ORDER BY CAST(pv.product_variant_no AS unsigned) DESC LIMIT 1';
  303.         return $this->getEntityManager()
  304.             ->getConnection()
  305.             ->prepare($sql)
  306.             ->executeQuery()
  307.             ->fetchAllAssociative();
  308.     }
  310.     public function findAllByCourseAndCountry($slugCourse, $country)
  311.     {
  312.         return $this
  313.             ->createQueryBuilder('pv')
  314.             ->leftJoin("pv.country", "country")
  315.             ->leftJoin("pv.courses", 'course')
  316.             ->where('course.slug = :slugCourse')
  317.             ->setParameter('slugCourse', $slugCourse)
  318.             ->andWhere('country.name = :country')
  319.             ->setParameter('country', $country)
  320.             ->getQuery()
  321.             ->getResult();
  322.     }
  324.     public function findByVariantStateActiveOrTest()
  325.     {
  326.         return $this
  327.             ->createQueryBuilder('pv')
  328.             ->where('pv.variantState = :active')
  329.             ->setParameter('active', 'active')
  330.             ->orWhere('pv.variantState = :test')
  331.             ->setParameter('test', 'Product test')
  332.             ->getQuery()
  333.             ->getResult();
  334.     }
  336.     public function findOneEcoVariantFromProductAssociation(ProductAssociation $productAssociation): ?ProductVariant
  337.     {
  338.         return $this
  339.             ->createQueryBuilder('pv')
  340.             ->leftJoin('pv.productAssociation', 'pa')
  341.             ->where('pa.id = :paId')
  342.             ->setParameter('paId', $productAssociation->getId())
  343.             ->andWhere('pv.productVariantNoComplete NOT LIKE :premium or pv.productVariantNoComplete LIKE :startNumberWith68')
  344.             ->setParameter('startNumberWith68', '68%')
  345.             ->setParameter('premium', '6%')
  346.             ->andWhere('pv.productVariantNoComplete NOT LIKE :online')
  347.             ->setParameter('online', '8%')
  348.             ->andWhere('pv.productVariantNoComplete NOT LIKE :event')
  349.             ->setParameter('event', '7%')
  350.             ->addOrderBy('pv.priceGross', 'ASC')
  351.             ->setMaxResults(1)
  352.             ->getQuery()
  353.             ->getOneOrNullResult();
  354.     }
  356.     public function findAllEligibleToMakeGiftable($countries = [])
  357.     {
  358.         return $this
  359.             ->createQueryBuilder('pv')
  360.             ->leftJoin('pv.country', 'country')
  361.             ->leftJoin('pv.courses', 'course')
  362.             ->where('pv.isGiftable = false OR pv.isGiftable IS NULL')
  363.             ->andWhere('(country.slug IN (:countries)) OR (country.slug = :poland AND pv.productVariantNo = 1)')
  364.             ->setParameter('countries', $countries)
  365.             ->setParameter('poland', 'poland')
  366.             ->andWhere('course.id IS NOT NULL')
  367.             ->getQuery()
  368.             ->getResult();
  369.     }
  371.     public function findAllFromProductVariantPack(ProductVariantPack $productVariantPack)
  372.     {
  373.         $qb = $this
  374.             ->createQueryBuilder('pv')
  375.             ->leftJoin('pv.productVariantPacks', 'pvp');
  377.         if (!$productVariantPack->getProductVariants()->isEmpty())
  378.         {
  379.             $variantsIds = $productVariantPack->getProductVariants()->map(function($item) {return $item->getId();});
  381.             $qb
  382.                 ->where('pv.id IN (:variantsFromPack)')
  383.                 ->setParameter('variantsFromPack', $variantsIds);
  384.         }
  386.         if (!$productVariantPack->getCountries()->isEmpty())
  387.         {
  388.             $countriesIds = $productVariantPack->getCountries()->map(function($item) {return $item->getId();});
  390.             $qb
  391.                 ->leftJoin('pv.country', 'country')
  392.                 ->andWhere('country.id IN (:countries)')
  393.                 ->setParameter('countries', $countriesIds);
  394.         }
  396.         if (!$productVariantPack->getPortalSettings()->isEmpty())
  397.         {
  398.             $portalSettingsIds = $productVariantPack->getPortalSettings()->map(function($item) {return $item->getId();});
  400.             $qb
  401.                 ->leftJoin('pv.portalSettings', 'portalSettings')
  402.                 ->andWhere('portalSettings.id IN (:portalSettings)')
  403.                 ->setParameter('portalSettings', $portalSettingsIds);
  404.         }
  406.         if (!$productVariantPack->getClientTypes()->isEmpty())
  407.         {
  408.             $clientTypesIds = $productVariantPack->getClientTypes()->map(function($item) {return $item->getId();});
  410.             $qb
  411.                 ->leftJoin('pv.clientType', 'clientType')
  412.                 ->andWhere('clientType.id IN (:clientTypes)')
  413.                 ->setParameter('clientTypes', $clientTypesIds);
  414.         }
  416.         return $qb->getQuery()->getResult();
  417.     }
  419.     public function findAllFromProductVariantPacks(Collection $productVariantPacks)
  420.     {
  421.         if ($productVariantPacks->isEmpty()) {
  422.             return [];
  423.         }
  425.         $productVariantPackIds = $productVariantPacks->map(function (ProductVariantPack $productVariantPack) {
  426.             return $productVariantPack->getId();
  427.         })->toArray();
  429.         $sql = '
  430.             SELECT
  431.                 pvp.id AS product_variant_pack_id,
  432.                 group_concat(DISTINCT pspv.portal_settings_id) AS product_variant_portal_settings_id, 
  433.                 group_concat(DISTINCT pvct.client_type_id) AS product_variant_client_type_id, 
  434.                 pv.*
  435.             FROM
  436.                 product_variant_pack pvp
  437.             JOIN product_variant_in_pack pvip ON
  438.                 pvip.product_variant_pack_id = pvp.id
  439.             JOIN product_variant pv ON
  440.                 pv.id = pvip.product_variant_id
  441.             LEFT JOIN portal_settings_product_variant pspv ON
  442.                 pspv.product_variant_id = pv.id
  443.             LEFT JOIN product_variant_client_type pvct ON
  444.                 pvct.product_variant_id = pv.id
  445.             WHERE
  446.                 pvp.id IN ( ' . implode(", ", array_fill(0, count($productVariantPackIds), "?")) . ')
  447.             GROUP BY 
  448.                 pvp.id,
  449.                 pv.id
  450.         ';
  452.         $productVariants = $this->getEntityManager()->getConnection()->executeQuery($sql, $productVariantPackIds)->fetchAllAssociative();
  454.         $productVariantsByPack = [];
  455.         foreach ($productVariants as &$productVariantArray) {
  456.             $productVariantArray['product_variant_portal_settings_id'] = explode(',', $productVariantArray['product_variant_portal_settings_id']);
  457.             $productVariantArray['product_variant_client_type_id'] = explode(',', $productVariantArray['product_variant_client_type_id']);
  459.             if (!array_key_exists($productVariantArray['product_variant_pack_id'], $productVariantsByPack)) {
  460.                 $productVariantsByPack[$productVariantArray['product_variant_pack_id']] = [];
  461.             }
  463.             $productVariantsByPack[$productVariantArray['product_variant_pack_id']][] = $productVariantArray;
  464.         }
  466.         /** @var ProductVariantPack $productVariantPack */
  467.         foreach ($productVariantPacks as $productVariantPack)
  468.         {
  469.             if (!$productVariantPack->getCountries()->isEmpty() ||
  470.                 !$productVariantPack->getPortalSettings()->isEmpty() ||
  471.                 !$productVariantPack->getClientTypes()->isEmpty())
  472.             {
  473.                 if (!$productVariantPack->getCountries()->isEmpty())
  474.                 {
  475.                     $countriesIds = $productVariantPack->getCountries()->map(function($item) { return $item->getId(); });
  477.                     array_filter($productVariantsByPack[$productVariantPack->getId()], function ($productVariant) use ($countriesIds) {
  478.                         return in_array($productVariant['country_id'], $countriesIds->toArray());
  479.                     });
  480.                 }
  482.                 if (!$productVariantPack->getPortalSettings()->isEmpty())
  483.                 {
  484.                     $portalSettingsIds = $productVariantPack->getPortalSettings()->map(function($item) { return $item->getId(); });
  486.                     array_filter($productVariantsByPack[$productVariantPack->getId()], function ($productVariant) use ($portalSettingsIds) {
  487.                         return array_intersect($productVariant['product_variant_portal_settings_id'], $portalSettingsIds->toArray());
  488.                     });
  489.                 }
  491.                 if (!$productVariantPack->getClientTypes()->isEmpty())
  492.                 {
  493.                     $clientTypesIds = $productVariantPack->getClientTypes()->map(function($item) { return $item->getId(); });
  495.                     array_filter($productVariantsByPack[$productVariantPack->getId()], function ($productVariant) use ($clientTypesIds) {
  496.                         return array_intersect($productVariant['product_variant_client_type_id'], $clientTypesIds->toArray());
  497.                     });
  498.                 }
  499.             }
  500.         }
  502.         return array_merge(...$productVariantsByPack);
  503.     }
  505.     public function findMainForCourse(Course $course, $country = null): ?ProductVariant
  506.     {
  507.         $qb = $this
  508.             ->createQueryBuilder('pv')
  509.             ->leftJoin('pv.courses', 'course')
  510.             ->where('course.id = :courseId')
  511.             ->setParameter('courseId', $course->getId());
  513.         if (!is_null($country))
  514.         {
  515.             $qb
  516.                 ->andWhere('pv.country = :country')
  517.                 ->setParameter('country', $country);
  518.         }
  520.         return $qb->setMaxResults(1)->getQuery()->getOneOrNullResult();
  521.     }
  523.     public function findProlongation(ProductVariant $productVariant, int $days): ?ProductVariant
  524.     {
  525.         $qb = $this
  526.             ->createQueryBuilder('pv')
  527.             ->andWhere('pv.productVariantNoComplete LIKE :variantNumber');
  529.         if ($days === 30)
  530.         {
  531.             $qb->setParameter('variantNumber', '2' . $productVariant->getMasterProduct()->getProductNo() . '/1');
  532.         }
  533.         elseif ($days === 270)
  534.         {
  535.             $qb->setParameter('variantNumber', '2' . $productVariant->getMasterProduct()->getProductNo() . '/2');
  536.         }
  537.         else
  538.         {
  539.             return null;
  540.         }
  542.         return $qb->setMaxResults(1)->getQuery()->getOneOrNullResult();
  543.     }
  545.     public function findFullAccessForCourseAndCountry(Course $course, ?Country $country)
  546.     {
  547.         $qb = $this->createQueryBuilder('pv')
  548.             ->leftJoin('pv.courses', 'course')
  549.             ->leftJoin('pv.country', 'country')
  550.             ->leftJoin('pv.packages', 'package')
  551.             ->where('course.id = :courseId')
  552.             ->andWhere('package.id IS NULL')
  553.             ->andWhere('pv.installmentAmount < 2 OR pv.installmentAmount IS NULL')
  554.             ->setParameter('courseId', $course->getId())
  555.             ->andWhere('course.isActive = true');
  557.         if ($country !== null)
  558.         {
  559.             $qb->andWhere('country.slug = :countrySlug')
  560.                 ->setParameter('countrySlug', $country->getSlug());
  561.         }
  563.         return $qb->setMaxResults(1)
  564.             ->getQuery()
  565.             ->getOneOrNullResult();
  566.     }
  568.     public function addToProductVariantPack($productPackId, $countries)
  569.     {
  570.         $sql = "INSERT INTO product_variant_in_pack
  571.         (
  572.             product_variant_pack_id,
  573.             product_variant_id
  574.         )
  575.         SELECT DISTINCT
  576.             ".$productPackId.",
  577.             pv.id
  578.         FROM
  579.             product_variant pv
  580.         LEFT JOIN 
  581.             payment_type pt ON pv.payment_type_id = pt.id
  582.         LEFT JOIN
  583.             relations_product_variant rpv ON rpv.physical_variant_id = pv.id
  584.         LEFT JOIN
  585.             product_variant vpv ON vpv.id = rpv.virtual_variant_id
  586.         LEFT JOIN
  587.             product_variant_course pvc ON pvc.product_variant_id = pv.id
  588.         INNER JOIN
  589.             product_variant_payment_method pvpm ON pvpm.product_variant_id = pv.id
  590.         WHERE
  591.         (pt.slug IS NULL OR pt.slug != 'partial-payment')
  592.         AND pvpm.product_variant_id IS NOT NULL
  593.             AND pv.state_is_availible = TRUE
  594.             AND (pv.quantity IS NULL OR pv.quantity = 0 OR pv.quantity > pv.order_quantity)
  595.         AND (vpv.state_is_availible = TRUE OR vpv.id IS NULL)
  596.         AND (vpv.quantity IS NULL OR vpv.quantity = 0 OR vpv.quantity > vpv.order_quantity)
  597.         AND NOT EXISTS (
  598.                 SELECT *
  599.                 FROM product_variant_in_pack pvip 
  600.                 WHERE pvip.product_variant_pack_id = ".$productPackId."
  601.                 AND pvip.product_variant_id = pv.id
  602.         )
  603.         AND pvc.product_variant_id IS NOT NULL
  604.         AND pv.country_id IN (".$countries.")";
  606.         $this->getEntityManager()
  607.             ->getConnection()
  608.             ->prepare($sql)
  609.             ->executeStatement();
  610.     }
  612.     public function getForProcessingFOResponse(?array $productVariantNoComplete)
  613.     {
  614.         return $this->createQueryBuilder('pv')
  615.             ->select("CASE WHEN (pgt.name = 'event') THEN true ELSE false END as isEvent, 
  616.                        pgt.name as gosType, pst.name as subscriptionType, pv.productVariantNoComplete")
  617.             ->innerJoin('pv.masterProduct', 'p')
  618.             ->leftJoin('p.productGosType', 'pgt')
  619.             ->leftJoin('pv.productSubscriptionType', 'pst')
  620.             ->andWhere('pv.productVariantNoComplete in (:productVariantNoComplete)')
  621.             ->setParameter('productVariantNoComplete', $productVariantNoComplete)
  622.             ->getQuery()
  623.             ->getResult();
  624.     }
  626.     public function getDataForBenefits(?array $productVariantNoComplete)
  627.     {
  628.         $conn = $this->getEntityManager()->getConnection();
  629.         $sql  = 'SELECT 
  630.                     pst.slug as productSubscriptionType, 
  631.                     pgt.name as productGosType,
  632.                     p.product_No as productNumber, 
  633.                     pv.product_variant_no_complete AS productVariantNumber,
  634.                     group_concat(pa_products.id) as productAssociationsProduct, 
  635.                     group_concat(pa_product_variants.id) as productAssociationsProductVariant
  636.                  FROM
  637.                     product_variant pv
  638.                         INNER JOIN
  639.                     product p ON pv.master_product_id = p.id
  640.                         LEFT JOIN
  641.                     product_subscription_type pst ON pv.product_subscription_type_id = pst.id
  642.                         LEFT JOIN
  643.                     product_gos_type pgt ON p.product_gos_type_id = pgt.id
  644.                         LEFT JOIN
  645.                     product_association_product pap ON p.id = pap.product_id
  646.                         LEFT JOIN
  647.                     product_association pa_products ON pap.product_association_id = pa_products.id
  648.                         LEFT JOIN
  649.                     product_association_product_variant papv ON pv.id = papv.product_variant_id
  650.                         LEFT JOIN
  651.                     product_association pa_product_variants ON papv.product_association_id = pa_product_variants.id
  652.                     where pv.product_variant_no_complete in (:productVariantNoComplete)
  653.                  GROUP BY pv.product_variant_no_complete';
  655.         $stmt = $conn->executeQuery($sql,
  656.                     ['productVariantNoComplete' => $productVariantNoComplete],
  657.                     ['productVariantNoComplete' => Connection::PARAM_STR_ARRAY]
  658.         );
  660.         return $stmt->fetchAll();
  661.     }
  663.     public function findAllForCalendarEvents(): ?array
  664.     {
  665.         return $this->createQueryBuilder('pv')
  666.             ->join('pv.calendarEvents', 'ce')
  667.             ->getQuery()
  668.             ->getResult();
  669.     }
  671.     public function findAllForPaymentReminder(): ?array
  672.     {
  673.         $conn = $this->getEntityManager()->getConnection();
  674.         $sql  = 'SELECT prpv.product_variant_id FROM payment_reminders_product_variant prpv GROUP BY 1';
  676.         $stmt = $conn->executeQuery($sql);
  677.         $all = $stmt->fetchAll();
  679.         $result = [];
  680.         foreach ($all as $id) $result[] = $id['product_variant_id'];
  682.         return $result;
  683.     }
  685.     public function selectProductVariantNoCompleteForAll($noVirtual = false)
  686.     {
  687.         $qb = $this->createQueryBuilder('pv')
  688.             ->select('pv.id, pv.productVariantNoComplete');
  690.         if ($noVirtual === true)
  691.         {
  692.             $qb->andWhere('pv.priceNet > 0');
  693.         }
  695.         return $qb->getQuery()->getResult();
  696.     }
  698.     public function findAllForOmnibus(QueryBuilder $qb)
  699.     {
  700.         $qb
  701.             ->distinct()
  702.             ->select('pv')
  703.             ->from(ProductVariant::class, 'pv')
  704.             ->leftJoin('pv.omnibus', 'o')
  705.             ->andWhere('pv.priceNet > 0')
  706.             ->andWhere('o.id IS NOT NULL');
  708.         return  $qb;
  709.     }
  711.     public function findOriginalProductsVariantWithDuplicate($productVariantNoComplete)
  712.     {
  713.         $qb = $this->createQueryBuilder('pv');
  715.         if (!is_null($productVariantNoComplete))
  716.         {
  717.             $qb
  718.                 ->andWhere('pv.productVariantNoComplete IN (:productVariantNoComplete)')
  719.                 ->setParameter('productVariantNoComplete', $productVariantNoComplete);
  720.         }
  722.         $qb
  723.             ->groupBy('pv.productVariantNoComplete')
  724.             ->having('COUNT(pv.productVariantNoComplete) > 1');
  726.         return $qb->getQuery()->getResult();
  727.     }
  729.     public function findAllDuplicateByOriginal(ProductVariant $originalProductVariant)
  730.     {
  731.         return $this
  732.             ->createQueryBuilder('pv')
  733.             ->where('pv.productVariantNoComplete = :productVariantNoComplete')
  734.             ->andWhere('pv.id != :originalId' )
  735.             ->setParameter('productVariantNoComplete', $originalProductVariant->getProductVariantNoComplete())
  736.             ->setParameter('originalId', $originalProductVariant->getId())
  737.             ->getQuery()->getResult();
  738.     }
  740.     public function findLastForProduct(Product $product)
  741.     {
  742.         return $this
  743.             ->createQueryBuilder('pv')
  744.             ->leftJoin('pv.product', 'p')
  745.             ->where('p = :product')
  746.             ->setParameter('product', $product)
  747.             ->setMaxResults(1)
  748.             ->orderBy('pv.id', 'DESC')
  749.             ->getQuery()
  750.             ->getOneOrNullResult();
  751.     }
  753.     public function findOneByNoCompleteAndTaxNoComplete(string $noComplete)
  754.     {
  755.         return $this
  756.             ->createQueryBuilder('pv')
  757.             ->where('pv.productVariantNoComplete = :noComplete')
  758.             ->orWhere('pv.productNumberPartTax = :noComplete')
  759.             ->orWhere('pv.productNumberNoTax = :noComplete')
  760.             ->setParameter('noComplete', $noComplete)
  761.             ->setMaxResults(1)
  762.             ->getQuery()
  763.             ->getOneOrNullResult();
  764.     }
  766.     public function findWithoutNewClientType(?int $limit)
  767.     {
  768.         $qb = $this->createQueryBuilder('pv')
  769.             ->leftJoin('pv.additionalOptionsByClientTypes', 'aobct')
  770.             ->leftJoin('pv.paymentMethod', 'pm')
  771.             ->leftJoin('pv.clientType', 'ct')
  772.             ->where('aobct.id IS NULL')
  773.             ->andWhere('pm.id IS NOT NULL')
  774.             ->andWhere('ct.id IS NOT NULL');
  777.         if (!is_null($limit))
  778.         {
  779.             $qb->setMaxResults($limit);
  780.         }
  782.         $qb->groupBy('pv.id');
  784.         return  $qb->getQuery()->getResult();
  785.     }
  787.     public function getProductVariantPriceGross(string $productVariantNoComplete): ?float
  788.     {
  789.         try
  790.         {
  791.             return $this->createQueryBuilder('pv')
  792.                 ->select('pv.priceGross')
  793.                 ->where('pv.productVariantNoComplete = :noComplete')
  794.                 ->setParameter('noComplete', $productVariantNoComplete)
  795.                 ->setMaxResults(1)
  796.                 ->getQuery()
  797.                 ->getSingleScalarResult();
  798.         }
  799.         catch (\Exception $e)
  800.         {
  801.             return null;
  802.         }
  803.     }
  805.     public function findByUserAccessForAjaxFilter($query, array $accessProductVariants = []): Query
  806.     {
  807.         $qb = $this->createQueryBuilder('pv')
  808.             ->select("distinct pv.id, CONCAT(pv.tradeName, ' ', pv.productVariantNoComplete) as text")
  809.             ->leftJoin('pv.physicalVariant', 'physicalVariant')
  810.             ->andWhere('pv.productVariantNoComplete in (:accessProductVariants)')
  811.             ->andWhere('physicalVariant.id IS NULL')
  812.             ->setParameter('accessProductVariants', $accessProductVariants);
  814.         if (!empty($query)) {
  815.             $qb->andWhere('pv.tradeName like :enteredProductName')
  816.                 ->setParameter('enteredProductName', '%'.$query.'%');
  817.         }
  820.         return $qb->getQuery();
  821.     }
  823.     public function findAllWithTargetVariant(): array
  824.     {
  825.         return $this->createQueryBuilder('pv')
  826.             ->where('pv.targetVariant IS NOT NULL')
  827.             ->getQuery()
  828.             ->getResult();
  829.     }
  831.     public function findByBcItemNoAndPositionType(string $bcItemNo, string $bcPositionType): array
  832.     {
  833.         $itemEscaped    = preg_quote($bcItemNo, null);
  834.         $posTypeEscaped = preg_quote($bcPositionType, null);
  836.         $pattern = '^' . $itemEscaped . '/([^/]+/)?' . $posTypeEscaped . '$';
  838.         return $this->createQueryBuilder('pv')
  839.             ->where('REGEXP(pv.productVariantNoComplete, :pattern) = 1')
  840.             ->setParameter('pattern', $pattern)
  841.             ->getQuery()
  842.             ->getResult();
  843.     }
  844. }