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 findByProductsVariantsNo($productsVariantsNumbers, $isAddition, $getPhysicalVariant = true)
  198.     {
  199.         $query = $this
  200.             ->createQueryBuilder('pv')
  201.             ->where('pv.productVariantNoComplete IN (:pvnc)');
  203.         if ($getPhysicalVariant)
  204.         {
  205.             $query
  206.                 ->leftJoin('pv.physicalVariant', 'mpv')
  207.                 ->orWhere('mpv.productVariantNoComplete IN (:pvnc) AND pv.isAddition =:isAddition')
  208.                 ->setParameter('isAddition', $isAddition);
  209.         }
  211.         return $query->setParameter('pvnc', $productsVariantsNumbers)->getQuery()->getResult();
  212.     }
  214.     public function findOneByProductVariantsNo($productsVariantsNumber, $isAddition)
  215.     {
  216.         return $this
  217.             ->createQueryBuilder('pv')
  218.             ->leftJoin('pv.physicalVariant', 'mpv')
  219.             ->where('pv.productVariantNoComplete = :pvnc')
  220.             ->orWhere('mpv.productVariantNoComplete = :pvnc AND pv.isAddition =:isAddition')
  221.             ->setParameter('pvnc', $productsVariantsNumber)
  222.             ->setParameter('isAddition', $isAddition)
  223.             ->getQuery()
  224.             ->disableResultCache()
  225.             ->setMaxResults(1)->getOneOrNullResult();
  226.     }
  228.     // This method is used to find a product variant by its number with caching for widgets (e.g. show-price).
  229.     public function findOneByProductVariantsNoCacheable($productsVariantsNumber, $isAddition)
  230.     {
  231.         return $this
  232.             ->createQueryBuilder('pv')
  233.             ->leftJoin('pv.physicalVariant', 'mpv')
  234.             ->where('pv.productVariantNoComplete = :pvnc')
  235.             ->orWhere('mpv.productVariantNoComplete = :pvnc AND pv.isAddition =:isAddition')
  236.             ->setParameter('pvnc', $productsVariantsNumber)
  237.             ->setParameter('isAddition', $isAddition)
  238.             ->getQuery()
  239.             ->enableResultCache(self::WIDGETS_CACHE_RESULT_LIFETIME, 'PV_' . $productsVariantsNumber . '_' . (int)$isAddition)
  240.             ->setMaxResults(1)->getOneOrNullResult();
  241.     }
  243.     // This method is used to find a product variant by its id with caching for widgets (e.g. show-price).
  244.     public function findOneCacheable($id)
  245.     {
  246.         return $this
  247.             ->createQueryBuilder('pv')
  248.             ->where('pv.id = :id')
  249.             ->setParameter('id', $id)
  250.             ->getQuery()
  251.             ->enableResultCache(self::WIDGETS_CACHE_RESULT_LIFETIME, 'PV_byId_' . $id)
  252.             ->setMaxResults(1)
  253.             ->getOneOrNullResult();
  254.     }
  256.     // 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).
  257.     public function findOneByProductVariantNoCompleteCacheable($productsVariantsNumber)
  258.     {
  259.         return $this
  260.             ->createQueryBuilder('pv')
  261.             ->where('pv.productVariantNoComplete = :pvnc')
  262.             ->setParameter('pvnc', $productsVariantsNumber)
  263.             ->getQuery()
  264.             ->enableResultCache(self::WIDGETS_CACHE_RESULT_LIFETIME, 'PV_byNoComplete_' . $productsVariantsNumber)
  265.             ->setMaxResults(1)
  266.             ->getOneOrNullResult();
  267.     }
  269.     public function findMaxProductVariantId()
  270.     {
  271.         return $this->createQueryBuilder('pv')
  272.             ->select('MAX(pv.productVariantId) AS newId')
  273.             ->setMaxResults(1)
  274.             ->getQuery()
  275.             ->getOneOrNullResult();
  276.     }
  278.     public function findLastProductVariantNoComplete($masterProductId)
  279.     {
  280.         $sql = 'SELECT pv.product_variant_no
  281.                 FROM product_variant pv 
  282.                 WHERE pv.master_product_id='.$masterProductId.' 
  283.                 ORDER BY CAST(pv.product_variant_no AS unsigned) DESC LIMIT 1';
  285.         return $this->getEntityManager()
  286.             ->getConnection()
  287.             ->prepare($sql)
  288.             ->executeQuery()
  289.             ->fetchAllAssociative();
  290.     }
  292.     public function findAllByCourseAndCountry($slugCourse, $country)
  293.     {
  294.         return $this
  295.             ->createQueryBuilder('pv')
  296.             ->leftJoin("pv.country", "country")
  297.             ->leftJoin("pv.courses", 'course')
  298.             ->where('course.slug = :slugCourse')
  299.             ->setParameter('slugCourse', $slugCourse)
  300.             ->andWhere('country.name = :country')
  301.             ->setParameter('country', $country)
  302.             ->getQuery()
  303.             ->getResult();
  304.     }
  306.     public function findByVariantStateActiveOrTest()
  307.     {
  308.         return $this
  309.             ->createQueryBuilder('pv')
  310.             ->where('pv.variantState = :active')
  311.             ->setParameter('active', 'active')
  312.             ->orWhere('pv.variantState = :test')
  313.             ->setParameter('test', 'Product test')
  314.             ->getQuery()
  315.             ->getResult();
  316.     }
  318.     public function findOneEcoVariantFromProductAssociation(ProductAssociation $productAssociation): ?ProductVariant
  319.     {
  320.         return $this
  321.             ->createQueryBuilder('pv')
  322.             ->leftJoin('pv.productAssociation', 'pa')
  323.             ->where('pa.id = :paId')
  324.             ->setParameter('paId', $productAssociation->getId())
  325.             ->andWhere('pv.productVariantNoComplete NOT LIKE :premium or pv.productVariantNoComplete LIKE :startNumberWith68')
  326.             ->setParameter('startNumberWith68', '68%')
  327.             ->setParameter('premium', '6%')
  328.             ->andWhere('pv.productVariantNoComplete NOT LIKE :online')
  329.             ->setParameter('online', '8%')
  330.             ->andWhere('pv.productVariantNoComplete NOT LIKE :event')
  331.             ->setParameter('event', '7%')
  332.             ->addOrderBy('pv.priceGross', 'ASC')
  333.             ->setMaxResults(1)
  334.             ->getQuery()
  335.             ->getOneOrNullResult();
  336.     }
  338.     public function findAllEligibleToMakeGiftable($countries = [])
  339.     {
  340.         return $this
  341.             ->createQueryBuilder('pv')
  342.             ->leftJoin('pv.country', 'country')
  343.             ->leftJoin('pv.courses', 'course')
  344.             ->where('pv.isGiftable = false OR pv.isGiftable IS NULL')
  345.             ->andWhere('(country.slug IN (:countries)) OR (country.slug = :poland AND pv.productVariantNo = 1)')
  346.             ->setParameter('countries', $countries)
  347.             ->setParameter('poland', 'poland')
  348.             ->andWhere('course.id IS NOT NULL')
  349.             ->getQuery()
  350.             ->getResult();
  351.     }
  353.     public function findAllFromProductVariantPack(ProductVariantPack $productVariantPack)
  354.     {
  355.         $qb = $this
  356.             ->createQueryBuilder('pv')
  357.             ->leftJoin('pv.productVariantPacks', 'pvp');
  359.         if (!$productVariantPack->getProductVariants()->isEmpty())
  360.         {
  361.             $variantsIds = $productVariantPack->getProductVariants()->map(function($item) {return $item->getId();});
  363.             $qb
  364.                 ->where('pv.id IN (:variantsFromPack)')
  365.                 ->setParameter('variantsFromPack', $variantsIds);
  366.         }
  368.         if (!$productVariantPack->getCountries()->isEmpty())
  369.         {
  370.             $countriesIds = $productVariantPack->getCountries()->map(function($item) {return $item->getId();});
  372.             $qb
  373.                 ->leftJoin('pv.country', 'country')
  374.                 ->andWhere('country.id IN (:countries)')
  375.                 ->setParameter('countries', $countriesIds);
  376.         }
  378.         if (!$productVariantPack->getPortalSettings()->isEmpty())
  379.         {
  380.             $portalSettingsIds = $productVariantPack->getPortalSettings()->map(function($item) {return $item->getId();});
  382.             $qb
  383.                 ->leftJoin('pv.portalSettings', 'portalSettings')
  384.                 ->andWhere('portalSettings.id IN (:portalSettings)')
  385.                 ->setParameter('portalSettings', $portalSettingsIds);
  386.         }
  388.         if (!$productVariantPack->getClientTypes()->isEmpty())
  389.         {
  390.             $clientTypesIds = $productVariantPack->getClientTypes()->map(function($item) {return $item->getId();});
  392.             $qb
  393.                 ->leftJoin('pv.clientType', 'clientType')
  394.                 ->andWhere('clientType.id IN (:clientTypes)')
  395.                 ->setParameter('clientTypes', $clientTypesIds);
  396.         }
  398.         return $qb->getQuery()->getResult();
  399.     }
  401.     public function findAllFromProductVariantPacks(Collection $productVariantPacks)
  402.     {
  403.         if ($productVariantPacks->isEmpty()) {
  404.             return [];
  405.         }
  407.         $productVariantPackIds = $productVariantPacks->map(function (ProductVariantPack $productVariantPack) {
  408.             return $productVariantPack->getId();
  409.         })->toArray();
  411.         $sql = '
  412.             SELECT
  413.                 pvp.id AS product_variant_pack_id,
  414.                 group_concat(DISTINCT pspv.portal_settings_id) AS product_variant_portal_settings_id, 
  415.                 group_concat(DISTINCT pvct.client_type_id) AS product_variant_client_type_id, 
  416.                 pv.*
  417.             FROM
  418.                 product_variant_pack pvp
  419.             JOIN product_variant_in_pack pvip ON
  420.                 pvip.product_variant_pack_id = pvp.id
  421.             JOIN product_variant pv ON
  422.                 pv.id = pvip.product_variant_id
  423.             LEFT JOIN portal_settings_product_variant pspv ON
  424.                 pspv.product_variant_id = pv.id
  425.             LEFT JOIN product_variant_client_type pvct ON
  426.                 pvct.product_variant_id = pv.id
  427.             WHERE
  428.                 pvp.id IN ( ' . implode(", ", array_fill(0, count($productVariantPackIds), "?")) . ')
  429.             GROUP BY 
  430.                 pvp.id,
  431.                 pv.id
  432.         ';
  434.         $productVariants = $this->getEntityManager()->getConnection()->executeQuery($sql, $productVariantPackIds)->fetchAllAssociative();
  436.         $productVariantsByPack = [];
  437.         foreach ($productVariants as &$productVariantArray) {
  438.             $productVariantArray['product_variant_portal_settings_id'] = explode(',', $productVariantArray['product_variant_portal_settings_id']);
  439.             $productVariantArray['product_variant_client_type_id'] = explode(',', $productVariantArray['product_variant_client_type_id']);
  441.             if (!array_key_exists($productVariantArray['product_variant_pack_id'], $productVariantsByPack)) {
  442.                 $productVariantsByPack[$productVariantArray['product_variant_pack_id']] = [];
  443.             }
  445.             $productVariantsByPack[$productVariantArray['product_variant_pack_id']][] = $productVariantArray;
  446.         }
  448.         /** @var ProductVariantPack $productVariantPack */
  449.         foreach ($productVariantPacks as $productVariantPack)
  450.         {
  451.             if (!$productVariantPack->getCountries()->isEmpty() ||
  452.                 !$productVariantPack->getPortalSettings()->isEmpty() ||
  453.                 !$productVariantPack->getClientTypes()->isEmpty())
  454.             {
  455.                 if (!$productVariantPack->getCountries()->isEmpty())
  456.                 {
  457.                     $countriesIds = $productVariantPack->getCountries()->map(function($item) { return $item->getId(); });
  459.                     array_filter($productVariantsByPack[$productVariantPack->getId()], function ($productVariant) use ($countriesIds) {
  460.                         return in_array($productVariant['country_id'], $countriesIds->toArray());
  461.                     });
  462.                 }
  464.                 if (!$productVariantPack->getPortalSettings()->isEmpty())
  465.                 {
  466.                     $portalSettingsIds = $productVariantPack->getPortalSettings()->map(function($item) { return $item->getId(); });
  468.                     array_filter($productVariantsByPack[$productVariantPack->getId()], function ($productVariant) use ($portalSettingsIds) {
  469.                         return array_intersect($productVariant['product_variant_portal_settings_id'], $portalSettingsIds->toArray());
  470.                     });
  471.                 }
  473.                 if (!$productVariantPack->getClientTypes()->isEmpty())
  474.                 {
  475.                     $clientTypesIds = $productVariantPack->getClientTypes()->map(function($item) { return $item->getId(); });
  477.                     array_filter($productVariantsByPack[$productVariantPack->getId()], function ($productVariant) use ($clientTypesIds) {
  478.                         return array_intersect($productVariant['product_variant_client_type_id'], $clientTypesIds->toArray());
  479.                     });
  480.                 }
  481.             }
  482.         }
  484.         return array_merge(...$productVariantsByPack);
  485.     }
  487.     public function findMainForCourse(Course $course, $country = null): ?ProductVariant
  488.     {
  489.         $qb = $this
  490.             ->createQueryBuilder('pv')
  491.             ->leftJoin('pv.courses', 'course')
  492.             ->where('course.id = :courseId')
  493.             ->setParameter('courseId', $course->getId());
  495.         if (!is_null($country))
  496.         {
  497.             $qb
  498.                 ->andWhere('pv.country = :country')
  499.                 ->setParameter('country', $country);
  500.         }
  502.         return $qb->setMaxResults(1)->getQuery()->getOneOrNullResult();
  503.     }
  505.     public function findProlongation(ProductVariant $productVariant, int $days): ?ProductVariant
  506.     {
  507.         $qb = $this
  508.             ->createQueryBuilder('pv')
  509.             ->andWhere('pv.productVariantNoComplete LIKE :variantNumber');
  511.         if ($days === 30)
  512.         {
  513.             $qb->setParameter('variantNumber', '2' . $productVariant->getMasterProduct()->getProductNo() . '/1');
  514.         }
  515.         elseif ($days === 270)
  516.         {
  517.             $qb->setParameter('variantNumber', '2' . $productVariant->getMasterProduct()->getProductNo() . '/2');
  518.         }
  519.         else
  520.         {
  521.             return null;
  522.         }
  524.         return $qb->setMaxResults(1)->getQuery()->getOneOrNullResult();
  525.     }
  527.     public function findFullAccessForCourseAndCountry(Course $course, ?Country $country)
  528.     {
  529.         $qb = $this->createQueryBuilder('pv')
  530.             ->leftJoin('pv.courses', 'course')
  531.             ->leftJoin('pv.country', 'country')
  532.             ->leftJoin('pv.packages', 'package')
  533.             ->where('course.id = :courseId')
  534.             ->andWhere('package.id IS NULL')
  535.             ->andWhere('pv.installmentAmount < 2 OR pv.installmentAmount IS NULL')
  536.             ->setParameter('courseId', $course->getId())
  537.             ->andWhere('course.isActive = true');
  539.         if ($country !== null)
  540.         {
  541.             $qb->andWhere('country.slug = :countrySlug')
  542.                 ->setParameter('countrySlug', $country->getSlug());
  543.         }
  545.         return $qb->setMaxResults(1)
  546.             ->getQuery()
  547.             ->getOneOrNullResult();
  548.     }
  550.     public function addToProductVariantPack($productPackId, $countries)
  551.     {
  552.         $sql = "INSERT INTO product_variant_in_pack
  553.         (
  554.             product_variant_pack_id,
  555.             product_variant_id
  556.         )
  557.         SELECT DISTINCT
  558.             ".$productPackId.",
  559.             pv.id
  560.         FROM
  561.             product_variant pv
  562.         LEFT JOIN 
  563.             payment_type pt ON pv.payment_type_id = pt.id
  564.         LEFT JOIN
  565.             relations_product_variant rpv ON rpv.physical_variant_id = pv.id
  566.         LEFT JOIN
  567.             product_variant vpv ON vpv.id = rpv.virtual_variant_id
  568.         LEFT JOIN
  569.             product_variant_course pvc ON pvc.product_variant_id = pv.id
  570.         INNER JOIN
  571.             product_variant_payment_method pvpm ON pvpm.product_variant_id = pv.id
  572.         WHERE
  573.         (pt.slug IS NULL OR pt.slug != 'partial-payment')
  574.         AND pvpm.product_variant_id IS NOT NULL
  575.             AND pv.state_is_availible = TRUE
  576.             AND (pv.quantity IS NULL OR pv.quantity = 0 OR pv.quantity > pv.order_quantity)
  577.         AND (vpv.state_is_availible = TRUE OR vpv.id IS NULL)
  578.         AND (vpv.quantity IS NULL OR vpv.quantity = 0 OR vpv.quantity > vpv.order_quantity)
  579.         AND NOT EXISTS (
  580.                 SELECT *
  581.                 FROM product_variant_in_pack pvip 
  582.                 WHERE pvip.product_variant_pack_id = ".$productPackId."
  583.                 AND pvip.product_variant_id = pv.id
  584.         )
  585.         AND pvc.product_variant_id IS NOT NULL
  586.         AND pv.country_id IN (".$countries.")";
  588.         $this->getEntityManager()
  589.             ->getConnection()
  590.             ->prepare($sql)
  591.             ->executeStatement();
  592.     }
  594.     public function getForProcessingFOResponse(?array $productVariantNoComplete)
  595.     {
  596.         return $this->createQueryBuilder('pv')
  597.             ->select("CASE WHEN (pgt.name = 'event') THEN true ELSE false END as isEvent, 
  598.                        pgt.name as gosType, pst.name as subscriptionType, pv.productVariantNoComplete")
  599.             ->innerJoin('pv.masterProduct', 'p')
  600.             ->leftJoin('p.productGosType', 'pgt')
  601.             ->leftJoin('pv.productSubscriptionType', 'pst')
  602.             ->andWhere('pv.productVariantNoComplete in (:productVariantNoComplete)')
  603.             ->setParameter('productVariantNoComplete', $productVariantNoComplete)
  604.             ->getQuery()
  605.             ->getResult();
  606.     }
  608.     public function getDataForBenefits(?array $productVariantNoComplete)
  609.     {
  610.         $conn = $this->getEntityManager()->getConnection();
  611.         $sql  = 'SELECT 
  612.                     pst.slug as productSubscriptionType, 
  613.                     pgt.name as productGosType,
  614.                     p.product_No as productNumber, 
  615.                     pv.product_variant_no_complete AS productVariantNumber,
  616.                     group_concat(pa_products.id) as productAssociationsProduct, 
  617.                     group_concat(pa_product_variants.id) as productAssociationsProductVariant
  618.                  FROM
  619.                     product_variant pv
  620.                         INNER JOIN
  621.                     product p ON pv.master_product_id = p.id
  622.                         LEFT JOIN
  623.                     product_subscription_type pst ON pv.product_subscription_type_id = pst.id
  624.                         LEFT JOIN
  625.                     product_gos_type pgt ON p.product_gos_type_id = pgt.id
  626.                         LEFT JOIN
  627.                     product_association_product pap ON p.id = pap.product_id
  628.                         LEFT JOIN
  629.                     product_association pa_products ON pap.product_association_id = pa_products.id
  630.                         LEFT JOIN
  631.                     product_association_product_variant papv ON pv.id = papv.product_variant_id
  632.                         LEFT JOIN
  633.                     product_association pa_product_variants ON papv.product_association_id = pa_product_variants.id
  634.                     where pv.product_variant_no_complete in (:productVariantNoComplete)
  635.                  GROUP BY pv.product_variant_no_complete';
  637.         $stmt = $conn->executeQuery($sql,
  638.                     ['productVariantNoComplete' => $productVariantNoComplete],
  639.                     ['productVariantNoComplete' => Connection::PARAM_STR_ARRAY]
  640.         );
  642.         return $stmt->fetchAll();
  643.     }
  645.     public function findAllForCalendarEvents(): ?array
  646.     {
  647.         return $this->createQueryBuilder('pv')
  648.             ->join('pv.calendarEvents', 'ce')
  649.             ->getQuery()
  650.             ->getResult();
  651.     }
  653.     public function findAllForPaymentReminder(): ?array
  654.     {
  655.         $conn = $this->getEntityManager()->getConnection();
  656.         $sql  = 'SELECT prpv.product_variant_id FROM payment_reminders_product_variant prpv GROUP BY 1';
  658.         $stmt = $conn->executeQuery($sql);
  659.         $all = $stmt->fetchAll();
  661.         $result = [];
  662.         foreach ($all as $id) $result[] = $id['product_variant_id'];
  664.         return $result;
  665.     }
  667.     public function selectProductVariantNoCompleteForAll($noVirtual = false)
  668.     {
  669.         $qb = $this->createQueryBuilder('pv')
  670.             ->select('pv.id, pv.productVariantNoComplete');
  672.         if ($noVirtual === true)
  673.         {
  674.             $qb->andWhere('pv.priceNet > 0');
  675.         }
  677.         return $qb->getQuery()->getResult();
  678.     }
  680.     public function findAllForOmnibus(QueryBuilder $qb)
  681.     {
  682.         $qb
  683.             ->distinct()
  684.             ->select('pv')
  685.             ->from(ProductVariant::class, 'pv')
  686.             ->leftJoin('pv.omnibus', 'o')
  687.             ->andWhere('pv.priceNet > 0')
  688.             ->andWhere('o.id IS NOT NULL');
  690.         return  $qb;
  691.     }
  693.     public function findOriginalProductsVariantWithDuplicate($productVariantNoComplete)
  694.     {
  695.         $qb = $this->createQueryBuilder('pv');
  697.         if (!is_null($productVariantNoComplete))
  698.         {
  699.             $qb
  700.                 ->andWhere('pv.productVariantNoComplete IN (:productVariantNoComplete)')
  701.                 ->setParameter('productVariantNoComplete', $productVariantNoComplete);
  702.         }
  704.         $qb
  705.             ->groupBy('pv.productVariantNoComplete')
  706.             ->having('COUNT(pv.productVariantNoComplete) > 1');
  708.         return $qb->getQuery()->getResult();
  709.     }
  711.     public function findAllDuplicateByOriginal(ProductVariant $originalProductVariant)
  712.     {
  713.         return $this
  714.             ->createQueryBuilder('pv')
  715.             ->where('pv.productVariantNoComplete = :productVariantNoComplete')
  716.             ->andWhere('pv.id != :originalId' )
  717.             ->setParameter('productVariantNoComplete', $originalProductVariant->getProductVariantNoComplete())
  718.             ->setParameter('originalId', $originalProductVariant->getId())
  719.             ->getQuery()->getResult();
  720.     }
  722.     public function findLastForProduct(Product $product)
  723.     {
  724.         return $this
  725.             ->createQueryBuilder('pv')
  726.             ->leftJoin('pv.product', 'p')
  727.             ->where('p = :product')
  728.             ->setParameter('product', $product)
  729.             ->setMaxResults(1)
  730.             ->orderBy('pv.id', 'DESC')
  731.             ->getQuery()
  732.             ->getOneOrNullResult();
  733.     }
  735.     public function findOneByNoCompleteAndTaxNoComplete(string $noComplete)
  736.     {
  737.         return $this
  738.             ->createQueryBuilder('pv')
  739.             ->where('pv.productVariantNoComplete = :noComplete')
  740.             ->orWhere('pv.productNumberPartTax = :noComplete')
  741.             ->orWhere('pv.productNumberNoTax = :noComplete')
  742.             ->setParameter('noComplete', $noComplete)
  743.             ->setMaxResults(1)
  744.             ->getQuery()
  745.             ->getOneOrNullResult();
  746.     }
  748.     public function findWithoutNewClientType(?int $limit)
  749.     {
  750.         $qb = $this->createQueryBuilder('pv')
  751.             ->leftJoin('pv.additionalOptionsByClientTypes', 'aobct')
  752.             ->leftJoin('pv.paymentMethod', 'pm')
  753.             ->leftJoin('pv.clientType', 'ct')
  754.             ->where('aobct.id IS NULL')
  755.             ->andWhere('pm.id IS NOT NULL')
  756.             ->andWhere('ct.id IS NOT NULL');
  759.         if (!is_null($limit))
  760.         {
  761.             $qb->setMaxResults($limit);
  762.         }
  764.         $qb->groupBy('pv.id');
  766.         return  $qb->getQuery()->getResult();
  767.     }
  769.     public function getProductVariantPriceGross(string $productVariantNoComplete): ?float
  770.     {
  771.         try
  772.         {
  773.             return $this->createQueryBuilder('pv')
  774.                 ->select('pv.priceGross')
  775.                 ->where('pv.productVariantNoComplete = :noComplete')
  776.                 ->setParameter('noComplete', $productVariantNoComplete)
  777.                 ->setMaxResults(1)
  778.                 ->getQuery()
  779.                 ->getSingleScalarResult();
  780.         }
  781.         catch (\Exception $e)
  782.         {
  783.             return null;
  784.         }
  785.     }
  787.     public function findByUserAccessForAjaxFilter($query, array $accessProductVariants = []): Query
  788.     {
  789.         $qb = $this->createQueryBuilder('pv')
  790.             ->select("distinct pv.id, CONCAT(pv.tradeName, ' ', pv.productVariantNoComplete) as text")
  791.             ->leftJoin('pv.physicalVariant', 'physicalVariant')
  792.             ->andWhere('pv.productVariantNoComplete in (:accessProductVariants)')
  793.             ->andWhere('physicalVariant.id IS NULL')
  794.             ->setParameter('accessProductVariants', $accessProductVariants);
  796.         if (!empty($query)) {
  797.             $qb->andWhere('pv.tradeName like :enteredProductName')
  798.                 ->setParameter('enteredProductName', '%'.$query.'%');
  799.         }
  802.         return $qb->getQuery();
  803.     }
  804. }