src/AtechNet/CoreBundle/Helper/Furbify/ProductHelper.php line 4302

Open in your IDE?
  1. <?php
  3. namespace App\AtechNet\CoreBundle\Helper\Furbify;
  5. use App\AtechNet\CoreBundle\Entity\Album;
  6. use App\AtechNet\CoreBundle\Entity\Attribute;
  7. use App\AtechNet\CoreBundle\Entity\AttributeOption;
  8. use App\AtechNet\CoreBundle\Entity\CategoryGroup;
  9. use App\AtechNet\CoreBundle\Entity\CategoryGroupMemberImage;
  10. use App\AtechNet\CoreBundle\Entity\CategoryPage;
  11. use App\AtechNet\CoreBundle\Entity\CategoryPagesPriorityProducts;
  12. use App\AtechNet\CoreBundle\Entity\Coupon;
  13. use App\AtechNet\CoreBundle\Entity\Customer;
  14. use App\AtechNet\CoreBundle\Entity\Domain;
  15. use App\AtechNet\CoreBundle\Entity\Language;
  16. use App\AtechNet\CoreBundle\Entity\Product;
  17. use App\AtechNet\CoreBundle\Entity\ProductAttribute;
  18. use App\AtechNet\CoreBundle\Entity\ProductContainer;
  19. use App\AtechNet\CoreBundle\Entity\ProductGroup;
  20. use App\AtechNet\CoreBundle\Entity\ProductGroupMember;
  21. use App\AtechNet\CoreBundle\Entity\ProductMeta;
  22. use App\AtechNet\CoreBundle\Entity\ProductModelMeta;
  23. use App\AtechNet\CoreBundle\Entity\ProductTag;
  24. use App\AtechNet\CoreBundle\Entity\ProductType;
  25. use App\AtechNet\CoreBundle\Entity\Review;
  26. use App\AtechNet\CoreBundle\Entity\ReviewSurveyMedia;
  27. use App\AtechNet\CoreBundle\Entity\Vendor;
  28. use App\AtechNet\CoreBundle\Service\HistoricalEuroRate;
  29. use App\AtechNet\CoreBundle\Sevices\ProductService;
  30. use App\AtechNet\CoreBundle\Translation\DatabaseTranslator;
  31. use Doctrine\ORM\EntityManager;
  32. use Doctrine\ORM\EntityManagerInterface;
  33. use Doctrine\ORM\Exception\NotSupported;
  34. use Doctrine\ORM\Query;
  35. use Doctrine\ORM\Tools\Pagination\Paginator;
  36. use Psr\Cache\CacheItemPoolInterface;
  37. use Symfony\Bridge\Twig\TokenParser\DumpTokenParser;
  38. use Symfony\Component\Filesystem\Filesystem;
  40. use Symfony\Component\HttpFoundation\Request;
  41. use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
  43. class ProductHelper
  44. {
  45.     public const CUSTOMER_TYPE_RETAIL = 1;
  46.     public const CUSTOMER_TYPE_WHOLESALE = 2;
  48.     public const AGE_0_to_2_YEARS = 0;
  49.     public const AGE_3_to_5_YEARS = 1;
  50.     public const AGE_6_PLUS_YEARS = 2;
  52.     public const LIST_ALLOWED_ATTRIBUTES_RETAIL = [
  53.         ProductType::PRODUCT_TYPE_ID_MONITOR => [
  54.             Attribute::ATTRIBUTE_ID_SCREEN_SIZE,
  55.             Attribute::ATTRIBUTE_ID_MAXIMUM_RESOLUTION,
  56.             Attribute::ATTRIBUTE_ID_RESPONSE_TIME,
  57.             Attribute::ATTRIBUTE_ID_DISPLAY_TECHNOLOGY,
  58.             Attribute::ATTRIBUTE_ID_ASPECT_RATIO,
  59.         ],
  60.         ProductType::PRODUCT_TYPE_ID_NOTEBOOK => [
  61.             Attribute::ATTRIBUTE_ID_CPU_NB,
  62.             Attribute::ATTRIBUTE_ID_RAM_NB,
  63.             Attribute::ATTRIBUTE_ID_SSD,
  64.             Attribute::ATTRIBUTE_ID_HDD_25,
  65.             Attribute::ATTRIBUTE_ID_SCREEN_SIZE,
  66.             Attribute::ATTRIBUTE_ID_MAXIMUM_RESOLUTION,
  67.             Attribute::ATTRIBUTE_ID_VGA,
  68.             Attribute::ATTRIBUTE_ID_OPERATING_SYSTEM,
  69.         ],
  70.         ProductType::PRODUCT_TYPE_ID_PC => [
  71.             Attribute::ATTRIBUTE_ID_CPU_PC,
  72.             Attribute::ATTRIBUTE_ID_RAM_PC,
  73.             Attribute::ATTRIBUTE_ID_SSD,
  74.             Attribute::ATTRIBUTE_ID_HDD_25,
  75.             Attribute::ATTRIBUTE_ID_HDD_35,
  76.             Attribute::ATTRIBUTE_ID_VGA,
  77.             Attribute::ATTRIBUTE_ID_OPERATING_SYSTEM,
  78.         ],
  79.         ProductType::PRODUCT_TYPE_ID_PC_SET => [
  80.             Attribute::ATTRIBUTE_ID_CPU_PC,
  81.             Attribute::ATTRIBUTE_ID_RAM_PC,
  82.             Attribute::ATTRIBUTE_ID_SSD,
  83.             Attribute::ATTRIBUTE_ID_HDD_35,
  84.             Attribute::ATTRIBUTE_ID_VGA,
  85.             Attribute::ATTRIBUTE_ID_OPERATING_SYSTEM,
  86.         ],
  87.         ProductType::PRODUCT_TYPE_ID_ALL_IN_ONE => [
  88.             Attribute::ATTRIBUTE_ID_CPU_PC,
  89.             Attribute::ATTRIBUTE_ID_RAM_PC,
  90.             Attribute::ATTRIBUTE_ID_SSD,
  91.             Attribute::ATTRIBUTE_ID_HDD_35,
  92.             Attribute::ATTRIBUTE_ID_SCREEN_SIZE,
  93.             Attribute::ATTRIBUTE_ID_MAXIMUM_RESOLUTION,
  94.             Attribute::ATTRIBUTE_ID_VGA,
  95.             Attribute::ATTRIBUTE_ID_OPERATING_SYSTEM,
  96.         ],
  97.         ProductType::PRODUCT_TYPE_ID_PRINTER => [
  98.             Attribute::ATTRIBUTE_ID_PRINTING_TECHNOLOGY,
  99.             Attribute::ATTRIBUTE_ID_PRINTING_COLOR,
  100.             Attribute::ATTRIBUTE_ID_DUPLEX,
  101.             Attribute::ATTRIBUTE_ID_PORTS,
  102.             Attribute::ATTRIBUTE_ID_PRINTING_SPEED,
  103.         ],
  104.         ProductType::PRODUCT_TYPE_ID_ELECTRIC_SCOOTER => [
  105.             Attribute::ATTRIBUTE_ID_MAX_SPEED,
  106.             Attribute::ATTRIBUTE_ID_MAX_RANGE,
  107.             Attribute::ATTRIBUTE_ID_POWER,
  108.         ],
  109.         ProductType::PRODUCT_TYPE_ID_SMARTPHONE => [
  110.             Attribute::ATTRIBUTE_ID_SCREEN_SIZE,
  111.             Attribute::ATTRIBUTE_ID_MAXIMUM_RESOLUTION,
  112.             Attribute::ATTRIBUTE_ID_MEMORY,
  113.             Attribute::ATTRIBUTE_ID_CPU_PHONE,
  114.             Attribute::ATTRIBUTE_ID_RAM,
  115.             Attribute::ATTRIBUTE_ID_OPERATING_SYSTEM,
  116.         ],
  117.         ProductType::PRODUCT_TYPE_ID_TABLET => [
  118.             Attribute::ATTRIBUTE_ID_SCREEN_SIZE,
  119.             Attribute::ATTRIBUTE_ID_MAXIMUM_RESOLUTION,
  120.             Attribute::ATTRIBUTE_ID_MEMORY,
  121.             Attribute::ATTRIBUTE_ID_CPU_PHONE,
  122.             Attribute::ATTRIBUTE_ID_RAM,
  123.             Attribute::ATTRIBUTE_ID_OPERATING_SYSTEM,
  124.         ],
  125.         ProductType::PRODUCT_TYPE_ID_SERVER => [
  126.             Attribute::ATTRIBUTE_ID_QUALITY,
  127.             Attribute::ATTRIBUTE_ID_CPU_PC,
  128.             Attribute::ATTRIBUTE_ID_RAM_PC,
  129.             Attribute::ATTRIBUTE_ID_SSD,
  130.             Attribute::ATTRIBUTE_ID_SSHD35,
  131.             Attribute::ATTRIBUTE_ID_HDD_25,
  132.             Attribute::ATTRIBUTE_ID_HDD_35,
  133.             Attribute::ATTRIBUTE_ID_VGA,
  134.             Attribute::ATTRIBUTE_ID_FORM,
  135.         ],
  136.         ProductType::PRODUCT_TYPE_ID_PROJECTOR => [
  137.             Attribute::ATTRIBUTE_ID_MAXIMUM_RESOLUTION,
  138.             Attribute::ATTRIBUTE_ID_ASPECT_RATIO,
  139.             Attribute::ATTRIBUTE_ID_CONTRAST,
  140.             Attribute::ATTRIBUTE_ID_PROJECTOR_REMOTE,
  141.             Attribute::ATTRIBUTE_ID_LUMEN,
  142.         ],
  143.         ProductType::PRODUCT_TYPE_ID_RAM_PC => [
  144.             Attribute::ATTRIBUTE_ID_MEMORY_TYPE,
  145.             Attribute::ATTRIBUTE_ID_MEMORY_SIZE,
  146.             Attribute::ATTRIBUTE_ID_MEMORY_FREQUENCY,
  147.         ],
  148.         ProductType::PRODUCT_TYPE_ID_CPU => [
  149.             Attribute::ATTRIBUTE_ID_CPU_PC_FAMILY,
  150.             Attribute::ATTRIBUTE_ID_CPU_GENERATION,
  151.             Attribute::ATTRIBUTE_ID_CLOCKSPEED,
  152.         ],
  153.         ProductType::PRODUCT_TYPE_ID_DOCKING_STATION => [
  154.             Attribute::ATTRIBUTE_ID_CONNECTORS,
  155.             Attribute::ATTRIBUTE_ID_DOCKING_STATION_POWER_INPUT,
  156.         ],
  157.         ProductType::PRODUCT_TYPE_ID_NOTEBOOK_BAG => [
  158.             Attribute::ATTRIBUTE_ID_NOTEBOOK_BAG_SIZE,
  159.             Attribute::ATTRIBUTE_ID_QUALITY,
  160.             Attribute::ATTRIBUTE_ID_COLOR,
  161.         ],
  162.     ];
  164.     public const LIST_ALLOWED_ATTRIBUTES_WHOLESALE = [
  165.         ProductType::PRODUCT_TYPE_ID_MONITOR => [
  166.             Attribute::ATTRIBUTE_ID_SCREEN_SIZE,
  167.             Attribute::ATTRIBUTE_ID_MAXIMUM_RESOLUTION,
  168.             Attribute::ATTRIBUTE_ID_RESPONSE_TIME,
  169.             Attribute::ATTRIBUTE_ID_DISPLAY_TECHNOLOGY,
  170.             Attribute::ATTRIBUTE_ID_ASPECT_RATIO,
  171.         ],
  172.         ProductType::PRODUCT_TYPE_ID_NOTEBOOK => [
  173.             Attribute::ATTRIBUTE_ID_CPU_NB,
  174.             Attribute::ATTRIBUTE_ID_RAM_NB,
  175.             Attribute::ATTRIBUTE_ID_SSD,
  176.             Attribute::ATTRIBUTE_ID_HDD_25,
  177.             Attribute::ATTRIBUTE_ID_SCREEN_SIZE,
  178.             Attribute::ATTRIBUTE_ID_MAXIMUM_RESOLUTION,
  179.             Attribute::ATTRIBUTE_ID_VGA,
  180.             Attribute::ATTRIBUTE_ID_OPERATING_SYSTEM,
  181.         ],
  182.         ProductType::PRODUCT_TYPE_ID_PC => [
  183.             Attribute::ATTRIBUTE_ID_CPU_PC,
  184.             Attribute::ATTRIBUTE_ID_RAM_PC,
  185.             Attribute::ATTRIBUTE_ID_SSD,
  186.             Attribute::ATTRIBUTE_ID_HDD_25,
  187.             Attribute::ATTRIBUTE_ID_HDD_35,
  188.             Attribute::ATTRIBUTE_ID_VGA,
  189.             Attribute::ATTRIBUTE_ID_OPERATING_SYSTEM,
  190.         ],
  191.         ProductType::PRODUCT_TYPE_ID_PC_SET => [
  192.             Attribute::ATTRIBUTE_ID_CPU_PC,
  193.             Attribute::ATTRIBUTE_ID_RAM_PC,
  194.             Attribute::ATTRIBUTE_ID_SSD,
  195.             Attribute::ATTRIBUTE_ID_HDD_35,
  196.             Attribute::ATTRIBUTE_ID_VGA,
  197.             Attribute::ATTRIBUTE_ID_OPERATING_SYSTEM,
  198.         ],
  199.         ProductType::PRODUCT_TYPE_ID_ALL_IN_ONE => [
  200.             Attribute::ATTRIBUTE_ID_CPU_PC,
  201.             Attribute::ATTRIBUTE_ID_RAM_PC,
  202.             Attribute::ATTRIBUTE_ID_SSD,
  203.             Attribute::ATTRIBUTE_ID_HDD_35,
  204.             Attribute::ATTRIBUTE_ID_SCREEN_SIZE,
  205.             Attribute::ATTRIBUTE_ID_MAXIMUM_RESOLUTION,
  206.             Attribute::ATTRIBUTE_ID_VGA,
  207.             Attribute::ATTRIBUTE_ID_OPERATING_SYSTEM,
  208.         ],
  209.         ProductType::PRODUCT_TYPE_ID_PRINTER => [
  210.             Attribute::ATTRIBUTE_ID_PRINTING_TECHNOLOGY,
  211.             Attribute::ATTRIBUTE_ID_PRINTING_COLOR,
  212.             Attribute::ATTRIBUTE_ID_DUPLEX,
  213.             Attribute::ATTRIBUTE_ID_PORTS,
  214.             Attribute::ATTRIBUTE_ID_PRINTING_SPEED,
  215.         ],
  216.         ProductType::PRODUCT_TYPE_ID_ELECTRIC_SCOOTER => [
  217.             Attribute::ATTRIBUTE_ID_MAX_SPEED,
  218.             Attribute::ATTRIBUTE_ID_MAX_RANGE,
  219.             Attribute::ATTRIBUTE_ID_POWER,
  220.         ],
  221.         ProductType::PRODUCT_TYPE_ID_SMARTPHONE => [
  222.             Attribute::ATTRIBUTE_ID_SCREEN_SIZE,
  223.             Attribute::ATTRIBUTE_ID_MAXIMUM_RESOLUTION,
  224.             Attribute::ATTRIBUTE_ID_MEMORY,
  225.             Attribute::ATTRIBUTE_ID_CPU_PHONE,
  226.             Attribute::ATTRIBUTE_ID_RAM,
  227.             Attribute::ATTRIBUTE_ID_OPERATING_SYSTEM,
  228.         ],
  229.         ProductType::PRODUCT_TYPE_ID_TABLET => [
  230.             Attribute::ATTRIBUTE_ID_SCREEN_SIZE,
  231.             Attribute::ATTRIBUTE_ID_MAXIMUM_RESOLUTION,
  232.             Attribute::ATTRIBUTE_ID_MEMORY,
  233.             Attribute::ATTRIBUTE_ID_CPU_PHONE,
  234.             Attribute::ATTRIBUTE_ID_RAM,
  235.             Attribute::ATTRIBUTE_ID_OPERATING_SYSTEM,
  236.         ],
  237.         ProductType::PRODUCT_TYPE_ID_SERVER => [
  238.             Attribute::ATTRIBUTE_ID_QUALITY,
  239.             Attribute::ATTRIBUTE_ID_CPU_PC,
  240.             Attribute::ATTRIBUTE_ID_RAM_PC,
  241.             Attribute::ATTRIBUTE_ID_SSD,
  242.             Attribute::ATTRIBUTE_ID_SSHD35,
  243.             Attribute::ATTRIBUTE_ID_HDD_25,
  244.             Attribute::ATTRIBUTE_ID_HDD_35,
  245.             Attribute::ATTRIBUTE_ID_VGA,
  246.             Attribute::ATTRIBUTE_ID_FORM,
  247.         ],
  248.         ProductType::PRODUCT_TYPE_ID_PROJECTOR => [
  249.             Attribute::ATTRIBUTE_ID_MAXIMUM_RESOLUTION,
  250.             Attribute::ATTRIBUTE_ID_ASPECT_RATIO,
  251.             Attribute::ATTRIBUTE_ID_CONTRAST,
  252.             Attribute::ATTRIBUTE_ID_PROJECTOR_REMOTE,
  253.             Attribute::ATTRIBUTE_ID_LUMEN,
  254.         ],
  255.         ProductType::PRODUCT_TYPE_ID_RAM_PC => [
  256.             Attribute::ATTRIBUTE_ID_MEMORY_TYPE,
  257.             Attribute::ATTRIBUTE_ID_MEMORY_SIZE,
  258.             Attribute::ATTRIBUTE_ID_MEMORY_FREQUENCY,
  259.         ],
  260.         ProductType::PRODUCT_TYPE_ID_CPU => [
  261.             Attribute::ATTRIBUTE_ID_CPU_PC_FAMILY,
  262.             Attribute::ATTRIBUTE_ID_CPU_GENERATION,
  263.             Attribute::ATTRIBUTE_ID_CLOCKSPEED,
  264.         ],
  265.         ProductType::PRODUCT_TYPE_ID_DOCKING_STATION => [
  266.             Attribute::ATTRIBUTE_ID_CONNECTORS,
  267.             Attribute::ATTRIBUTE_ID_DOCKING_STATION_POWER_INPUT,
  268.         ],
  269.         ProductType::PRODUCT_TYPE_ID_NOTEBOOK_BAG => [
  270.             Attribute::ATTRIBUTE_ID_NOTEBOOK_BAG_SIZE,
  271.             Attribute::ATTRIBUTE_ID_QUALITY,
  272.             Attribute::ATTRIBUTE_ID_COLOR,
  273.         ],
  274.     ];
  276.     public const DEFAULT_ACCESSORY_SELECTIONS = [
  277.         21 => 247,
  278.         105 => 1536, // USB wifi : I dont need
  279.         116 => 1535, // Speaker : I dont need
  280.         147 => 1522, // DDR 4 PC RAM : I dont need
  281.         149 => 1537, // Headphones : I dont need
  282.     ];
  284.     public const CPU_MARK_HELPER_MIN = [
  285.         1 => 0,
  286.         2 => 3_000,
  287.         3 => 6_000,
  288.         4 => 9_000,
  289.         5 => 11_000,
  290.     ];
  292.     public const CPU_MARK_HELPER_MAX = [
  293.         1 => 3_000,
  294.         2 => 6_000,
  295.         3 => 9_000,
  296.         4 => 11_000,
  297.         5 => 1_000_000,
  298.     ];
  300.     private $entityManager;
  301.     private $cloudFlareApiConfig;
  302.     private $translator;
  303.     private $multiStore;
  305.     private $customerType;
  307.     private $priceDomainId;
  308.     private $localeDomainId;
  309.     private $priceDomain;
  310.     private $localeDomain;
  311.     private $showWindows;
  312.     private $notebookSkinAttribute;
  313.     private $notebookSkinAttributeOptions;
  314.     private $router;
  316.     /**
  317.      * ProductHelper constructor.
  318.      * @param EntityManager $entityManager
  319.      * @param array $cloudFlareApiConfig
  320.      * @param $translator
  321.      * @param MultiStore $multiStore
  322.      * @param $router
  323.      * @throws \Exception
  324.      */
  325.     public function __construct(
  326.         EntityManager $entityManager,
  327.         array $cloudFlareApiConfig,
  328.         $translator,
  329.         MultiStore $multiStore,
  330.         $router,
  331.         private HistoricalEuroRate $historicalEuroRate,
  332.     )
  333.     {
  334.         $this->entityManager = $entityManager;
  335.         $this->cloudFlareApiConfig = $cloudFlareApiConfig;
  336.         $this->translator = $translator;
  337.         $this->multiStore = $multiStore;
  338.         $this->router = $router;
  340.         $this->customerType = $this->multiStore->getCustomerTypeId();
  342.         $this->priceDomainId = $this->multiStore->getDomainId();
  343.         $this->localeDomainId = $this->multiStore->getLocaleDomainId();
  345.         $this->priceDomain = $this->multiStore->getDomain();
  346.         if ($this->priceDomainId == $this->localeDomainId) {
  347.             $this->localeDomain = $this->priceDomain;
  348.         } else {
  349.             $this->localeDomain = $this->multiStore->getLocaleDomain();
  350.             $this->translator = new DatabaseTranslator($this->entityManager, $this->multiStore->getLocaleDomainId());
  351.         }
  352.         return '';
  354.         $this->showWindows = !($this->priceDomain->getType() == 'retail') && !in_array($this->priceDomainId, [Domain::DOMAIN_ID_RT_EU, Domain::DOMAIN_ID_WS_EU]);
  355.     }
  357.     /**
  358.      * @param Product $product
  359.      * @return array
  360.      */
  361.     public function getDataForProduct(Product $product): array
  362.     {
  363.         $priceProductMeta = $product->getDomainMeta($this->priceDomain);
  365.         if ($this->priceDomain->getId() == $this->localeDomain->getId()) {
  366.             $localeProductMeta = $priceProductMeta;
  367.         } else {
  368.             $localeProductMeta = $product->getDomainMeta($this->localeDomain);
  369.         }
  371.         return [
  372.             'product' => $product,
  373.             'priceMeta' => $priceProductMeta,
  374.             'localeMeta' => $localeProductMeta,
  375.         ];
  376.     }
  378.     /**
  379.      * @param int $productId
  380.      * @return array
  381.      */
  382.     public function getDataForProductById($productId)
  383.     {
  384.         $product = $this->entityManager->getRepository(Product::class)->findOneById($productId);
  386.         return $product ? $this->getDataForProduct($product) : null;
  387.     }
  389.     /**
  390.      * @param array $products
  391.      * @return array
  392.      */
  393.     public function getDataForProducts($products)
  394.     {
  395.         $productsData = [];
  397.         foreach ($products as $product) {
  398.             $productsData[$product->getId()] = $this->getDataForProduct($product);
  399.         }
  401.         return $productsData;
  402.     }
  404.     /**
  405.      * @param array $productIds
  406.      * @return array
  407.      */
  408.     public function getDataForProductsById($productIds)
  409.     {
  410.         $productsData = [];
  412.         foreach ($productIds as $productId) {
  413.             $productData = $this->getDataForProductById($productId);
  415.             if ($productData) {
  416.                 $productsData[$productId] = $productData;
  417.             }
  418.         }
  420.         return $productsData;
  421.     }
  423.     /**
  424.      * @param array $products
  425.      * @param bool $withMultiplePicture
  426.      *
  427.      * @return array
  428.      */
  429.     public function getStructuredDataForProducts($products, bool $withMultiplePicture = false): array
  430.     {
  431.         $structuredProducts = [];
  433.         if (count($products) < 1) {
  434.             return $structuredProducts;
  435.         }
  437.         foreach ($products as $product) {
  438.             $structuredProducts[$product->getId()] = $this->getStructuredDataForProduct($product, 'list', $withMultiplePicture);
  439.         }
  441.         return $structuredProducts;
  442.     }
  444.     /**
  445.      * @param array $products
  446.      * @param string $viewMode
  447.      * @return array
  448.      */
  449.     public function getStructuredDataForProductsById(array $products, $viewMode = 'details'): array
  450.     {
  451.         $structuredProducts = [];
  453.         $products = $this->entityManager->getRepository(Product::class)->findBy([
  454.             'id' => $products,
  455.         ]);
  457.         foreach ($products as $product) {
  458.             $structuredProducts[$product->getId()] = $this->getStructuredDataForProduct($product, $viewMode);
  459.         }
  461.         return $structuredProducts;
  462.     }
  464.     /**
  465.      * @param array $attributeList
  466.      * @return string
  467.      */
  468.     private function getAttributeInfoForProductDescription(array $attributeList): string
  469.     {
  470.         $attributeIdToIgnoreForTitle = [
  471.             Attribute::ATTRIBUTE_ID_CPU_GENERATION,
  472.             Attribute::ATTRIBUTE_ID_CPU_NB,
  473.             Attribute::ATTRIBUTE_ID_RAM_NB,
  474.             Attribute::ATTRIBUTE_ID_MAXIMUM_RESOLUTION,
  475.             Attribute::ATTRIBUTE_ID_HDD_35,
  476.             Attribute::ATTRIBUTE_ID_CPU_PC,
  477.             Attribute::ATTRIBUTE_ID_RAM_PC,
  478.             #Attribute::ATTRIBUTE_ID_VGA,
  479.             Attribute::ATTRIBUTE_ID_OPERATING_SYSTEM,
  480.             Attribute::ATTRIBUTE_ID_SCREEN_SIZE,
  481.             Attribute::ATTRIBUTE_ID_RESPONSE_TIME,
  482.             Attribute::ATTRIBUTE_ID_ASPECT_RATIO,
  483.             Attribute::ATTRIBUTE_ID_DISPLAY_TECHNOLOGY,
  484.             Attribute::ATTRIBUTE_ID_CPU_PHONE,
  485.             Attribute::ATTRIBUTE_ID_DISPLAY_TECHNOLOGY,
  486.             Attribute::ATTRIBUTE_ID_MEMORY,
  487.             Attribute::ATTRIBUTE_ID_CONNECTORS,
  488.             Attribute::ATTRIBUTE_ID_QUALITY,
  489.             Attribute::ATTRIBUTE_ID_NOTEBOOK_BAG_SIZE,
  490.             Attribute::ATTRIBUTE_ID_COLOR,
  491.         ];
  493.         $attributeListText = '';
  495.         if (array_key_exists(Attribute::ATTRIBUTE_ID_OPERATING_SYSTEM, $attributeList)) {
  496.             $operationSystem = $attributeList[Attribute::ATTRIBUTE_ID_OPERATING_SYSTEM];
  498.             unset($attributeList[Attribute::ATTRIBUTE_ID_OPERATING_SYSTEM]);
  500.             $attributeList[Attribute::ATTRIBUTE_ID_OPERATING_SYSTEM] = $operationSystem;
  501.         }
  503.         foreach ($attributeList as $attribute) {
  504.             if ($attributeListText != '') {
  505.                 $attributeListText .= ', ';
  506.             }
  507.             foreach ($attribute['options'] as $option) {
  508.                 if (!in_array($attribute['id'], $attributeIdToIgnoreForTitle)) {
  509.                     $attributeTitle = $attribute['id'] == Attribute::ATTRIBUTE_ID_VGA
  510.                         ? ''
  511.                         : ' ' . $attribute['title'];
  512.                 } else {
  513.                     switch ($attribute['id']) {
  514.                         case Attribute::ATTRIBUTE_ID_RAM_NB:
  515.                         case Attribute::ATTRIBUTE_ID_RAM_PC:
  516.                             $attributeTitle = ' RAM';
  517.                             break;
  519.                         case Attribute::ATTRIBUTE_ID_OPERATING_SYSTEM:
  520.                             $attributeTitle = $attribute['title'] . str_contains(strtolower($attribute['title']), 'windows') ? " OS" : '';
  521.                             break;
  523.                         case Attribute::ATTRIBUTE_ID_CPU_PC:
  524.                         case Attribute::ATTRIBUTE_ID_CPU_NB:
  525.                             $attributeListText .= " {$attribute['vendor']} {$option['title']}";
  527.                             $attributeListText = str_replace('AMD AMD', 'AMD', $attributeListText);
  528.                             break;
  530.                         case Attribute::ATTRIBUTE_ID_CONNECTORS:
  531.                             $attributeListText = implode(', ', array_map(
  532.                                 function ($option) {
  533.                                     return in_array($option['title'], ['Videokártya', 'Grafická karta']) ? $option['vendor'] : $option['title'];
  534.                                 },
  535.                                 $attribute['options']
  536.                             ));
  537.                             break;
  539.                         default:
  540.                             $attributeTitle = '';
  541.                             break;
  542.                     }
  543.                 }
  545.                 if (isset($attributeTitle)) {
  546.                     $attributeListText .= " {$option['title']}$attributeTitle";
  547.                 }
  548.             }
  549.         }
  551.         $attributeListText = str_replace('OS OS', 'OS', $attributeListText);
  553.         return $attributeListText;
  554.     }
  556.     /**
  557.      * @param Product $product
  558.      * @param string $viewMode
  559.      * @param bool $withMultipleImage
  560.      *
  561.      * @return array
  562.      * @throws NotSupported
  563.      */
  564.     public function getStructuredDataForProduct(Product $product, string $viewMode = 'details', bool $withMultipleImage = false): array
  565.     {
  566.         /**
  567.          * @var Product $product
  568.          * @var ProductMeta $priceDomain
  569.          * @var ProductMeta $localeDomain
  570.          * @var ProductAttribute $spec
  571.          * @var AttributeOption $option
  572.          * @var AttributeOption $acc
  573.          */
  574.         
  575.         $priceMeta = $product->getDomainMeta($this->priceDomain) ?: null;
  576.         $localeMeta = $product->getDomainMeta($this->localeDomain) ?: null;
  577.         $isCustomerTypeRetail = $this->priceDomain->getType() == 'retail';
  578.         $isWebcamIncluded = false;
  579.         $noWebcamBadge = false;
  581.         $images = [];
  582.         $categoryId = 0;
  583.         $accessoryAttributes = [];
  584.         $specificationAttributes = [];
  585.         $specificationAttributesListText = '';
  586.         $freeShipLimit = self::getFreeShipLimitsForDomain($this->priceDomainId)['freeShipLimit'];
  587.         $containerPartsSpecifications = [];
  588.         $connectedBatteries = [];
  589.         $batterAttributeOptionId = null;
  591.         $isContainer = $product->isContainer();
  592.         $containerWithSkin = false;
  594.         $translatedKeyboardReprint = $this->translator->trans('Keyboard reprint');
  596.         if ($viewMode == 'details') {
  597.             foreach ($product->getSpecificationProductAttributeOptions() as $spec) {
  598.                 $option = $spec->getOption();
  599.                 $attributeId = $option->getAttribute()->getId();
  601.                 if ($attributeId == Attribute::ATTRIBUTE_ID_QUALITY
  602.                     || ($attributeId == Attribute::ATTRIBUTE_ID_OPERATING_SYSTEM && (in_array($this->priceDomainId, [Domain::DOMAIN_ID_RT_EU, Domain::DOMAIN_ID_WS_EU])))) {
  603.                     continue;
  604.                 }
  606.                 if (!isset($specificationAttributes[$attributeId])) {
  607.                     $specificationAttributes[$attributeId] = [
  608.                         'id' => $attributeId,
  609.                         'title' => $option->getAttribute()->getTitle($this->translator),
  610.                         'options' => [],
  611.                     ];
  613.                     if ($attributeId == Attribute::ATTRIBUTE_ID_WEBCAM) {
  614.                         $isWebcamIncluded = true;
  615.                     }
  616.                 }
  618.                 $title = $option->getLongTitle($this->translator);
  619.                 if (empty($title)) {
  620.                     $title = $option->getTitle($this->translator);
  621.                 }
  623.                 $specificationAttributes[$attributeId]['options'][$spec->getId()] = [
  624.                     'id' => $spec->getId(),
  625.                     'attributeOptionId' => $spec->getOption()->getId(),
  626.                     'title' => $spec->getId() == 1623398 ? $option->getTitle($this->translator) : $title,
  627.                     'shortTitle' => $option->getTitle($this->translator),
  628.                     'multiplier' => $spec->getMultiplier(),
  629.                 ];
  630.             }
  632.             if ($product->getType()->getId() == ProductType::PRODUCT_TYPE_ID_MONITOR) {
  633.                 if (isset($specificationAttributes[Attribute::ATTRIBUTE_ID_GRAPHIC_INPUTS])) {
  634.                     $sortOrder = [733, 628, 595];
  635.                     $options = $specificationAttributes[Attribute::ATTRIBUTE_ID_GRAPHIC_INPUTS]['options'];
  637.                     usort($options, function ($a, $b) use ($sortOrder) {
  638.                         return array_search($a['attributeOptionId'], $sortOrder) - array_search($b['attributeOptionId'], $sortOrder);
  639.                     });
  641.                     $formatedOptions = [];
  642.                     foreach ($options as $option) {
  643.                         $formatedOptions[$option['id']] = $option;
  644.                     }
  646.                     $specificationAttributes[Attribute::ATTRIBUTE_ID_GRAPHIC_INPUTS]['options'] = $formatedOptions;
  647.                 }
  648.             }
  650.             if ($isContainer && $product->getType()->getId() == ProductType::PRODUCT_TYPE_ID_PC_SET) {
  651.                 /**
  652.                  * @var ProductContainer $container
  653.                  */
  654.                 // get attributes from main product First
  655.                 $productId = $product->getId();
  656.                 $productTypeId = $product->getType()->getId();
  658.                 foreach ($product->getSpecificationProductAttributeOptions() as $spec) {
  659.                     $option = $spec->getOption();
  660.                     $attributeId = $option->getAttribute()->getId();
  662.                     if (($isCustomerTypeRetail && $attributeId == Attribute::ATTRIBUTE_ID_OPERATING_SYSTEM) ||
  663.                         !in_array($productTypeId, [
  664.                             ProductType::PRODUCT_TYPE_ID_PC,
  665.                             ProductType::PRODUCT_TYPE_ID_NOTEBOOK,
  666.                             ProductType::PRODUCT_TYPE_ID_MONITOR,
  667.                             ProductType::PRODUCT_TYPE_ID_PC_SET,
  668.                         ])
  669.                     ) {
  670.                         continue;
  671.                     }
  673.                     if (!isset($containerPartsSpecifications[$productId])) {
  674.                         $containerPartsSpecifications[$productId]['title'] = $product->getVendor()->getName() . ' ' . $product->getName();
  675.                     }
  677.                     if (!isset($containerPartsSpecifications[$productId]['attributes'][$attributeId])) {
  678.                         $containerPartsSpecifications[$productId]['attributes'][$attributeId] = [
  679.                             'id' => $attributeId,
  680.                             'title' => $option->getAttribute()->getTitle($this->translator),
  681.                             'options' => [],
  682.                         ];
  684.                         if ($attributeId == Attribute::ATTRIBUTE_ID_WEBCAM) {
  685.                             $isWebcamIncluded = true;
  686.                         }
  687.                     }
  689.                     $title = $option->getLongTitle($this->translator);
  690.                     if (empty($title)) {
  691.                         $title = $option->getTitle($this->translator);
  692.                     }
  694.                     $containerPartsSpecifications[$productId]['attributes'][$attributeId]['options'][$spec->getId()] = [
  695.                         'id' => $spec->getId(),
  696.                         'title' => $title,
  697.                         'shortTitle' => $option->getTitle($this->translator),
  698.                         'multiplier' => $spec->getMultiplier(),
  699.                     ];
  700.                 }
  702.                 foreach ($product->getProductContainers() as $container) {
  703.                     $containerProduct = $container->getChild();
  704.                     $containerProductId = $containerProduct->getId();
  705.                     $containerProductTypeId = $containerProduct->getType()->getId();
  707.                     foreach ($containerProduct->getSpecificationProductAttributeOptions() as $spec) {
  708.                         $option = $spec->getOption();
  709.                         $attributeId = $option->getAttribute()->getId();
  711.                         if (($isCustomerTypeRetail && $attributeId == Attribute::ATTRIBUTE_ID_OPERATING_SYSTEM) || !in_array($containerProductTypeId, [ProductType::PRODUCT_TYPE_ID_NOTEBOOK, ProductType::PRODUCT_TYPE_ID_MONITOR, ProductType::PRODUCT_TYPE_ID_PC_SET])) {
  712.                             continue;
  713.                         }
  715.                         if (!isset($containerPartsSpecifications[$containerProductId])) {
  716.                             $containerPartsSpecifications[$containerProductId]['title'] = $containerProduct->getVendor()->getName() . ' ' . $containerProduct->getName();
  717.                         }
  719.                         if (!isset($containerPartsSpecifications[$containerProductId]['attributes'][$attributeId])) {
  720.                             $containerPartsSpecifications[$containerProductId]['attributes'][$attributeId] = [
  721.                                 'id' => $attributeId,
  722.                                 'title' => $option->getAttribute()->getTitle($this->translator),
  723.                                 'options' => [],
  724.                             ];
  726.                             if ($attributeId == Attribute::ATTRIBUTE_ID_WEBCAM) {
  727.                                 $isWebcamIncluded = true;
  728.                             }
  729.                         }
  731.                         $title = $option->getLongTitle($this->translator);
  732.                         if (empty($title)) {
  733.                             $title = $option->getTitle($this->translator);
  734.                         }
  736.                         $containerPartsSpecifications[$containerProductId]['attributes'][$attributeId]['options'][$spec->getId()] = [
  737.                             'id' => $spec->getId(),
  738.                             'title' => $title,
  739.                             'shortTitle' => $option->getTitle($this->translator),
  740.                             'multiplier' => $spec->getMultiplier(),
  741.                         ];
  742.                     }
  743.                 }
  744.             }
  746.             if ($isContainer && $product->getType()->getId() == ProductType::PRODUCT_TYPE_ID_NOTEBOOK) {
  748.                 /** @var ProductContainer $productContainer */
  749.                 foreach ($product->getProductContainers() as $productContainer) {
  750.                     $childProduct = $productContainer->getChild();
  751.                     if ($childProduct) {
  752.                         if ($childProduct->getType()->getId() == ProductType::PRODUCT_TYPE_ID_SERVICE) {
  753.                             if (str_contains($childProduct->getName(), 'Notebook skin')) {
  754.                                 $containerWithSkin = true;
  755.                                 break;
  756.                             }
  757.                         }
  758.                     }
  759.                 }
  760.             }
  762.             if (!$isWebcamIncluded && $product->getType()->getId() == ProductType::PRODUCT_TYPE_ID_NOTEBOOK) {
  763.                 $specificationAttributes[Attribute::ATTRIBUTE_ID_WEBCAM] = [
  764.                     'id' => Attribute::ATTRIBUTE_ID_WEBCAM,
  765.                     'title' => 'Webcam',
  766.                     'options' => [],
  767.                 ];
  769.                 $specificationAttributes[Attribute::ATTRIBUTE_ID_WEBCAM]['options'][1773] = [
  770.                     'id' => 1773,
  771.                     'title' => $this->translator->trans('No'),
  772.                     'shortTitle' => $this->translator->trans('No'),
  773.                     'multiplier' => 0,
  774.                     'color' => '',
  775.                     'bold' => 0,
  776.                 ];
  777.             }
  779.             foreach ($product->getAccessoryAttributeOptions() as $acc) {
  780.                 if ($acc->hasChildren() || (!is_null($acc->getProduct()) && ($acc->getProduct()->getAvailable() < 1 && $acc->getAttribute()->getId() != 184))) {
  781.                     continue;
  782.                 }
  784.                 $attributeId = $acc->getAttribute()->getId();
  786.                 if (!isset($accessoryAttributes[$attributeId])) {
  787.                     $accessoryAttributes[$attributeId] = [
  788.                         'id' => $attributeId,
  789.                         'title' => $acc->getAttribute()->getTitle($this->translator),
  790.                         'options' => [],
  791.                     ];
  792.                 }
  794.                 if (in_array($acc->getTitle(), ["Don't need", "No OS"])) {
  795.                     continue;
  796.                 }
  798.                 //-> Suggested Price of Attribute
  799.                 $attrOptionProductSuggestedPrice = $attrOptionProductVatSuggestedPrice = 0;
  801.                 if ($this->customerType == self::CUSTOMER_TYPE_WHOLESALE) {
  802.                     $attrOptionProduct = $acc->getProduct();
  804.                     if ($attrOptionProduct) {
  805.                         $attrOptionProductPriceMeta = $attrOptionProduct->getDomainMeta($this->priceDomain);
  807.                         if ($attrOptionProductPriceMeta->getDomainSuggestedPrice() > 0 && $attrOptionProductPriceMeta->getDomainVatSuggestedPrice() > 0) {
  808.                             $attrOptionProductSuggestedPrice = $attrOptionProductPriceMeta->getDomainSuggestedPrice();
  809.                             $attrOptionProductVatSuggestedPrice = $attrOptionProductPriceMeta->getDomainVatSuggestedPrice();
  810.                         }
  811.                     }
  813.                     if ($attrOptionProductSuggestedPrice === 0 && $attrOptionProductVatSuggestedPrice === 0) {
  814.                         $attrOptionRetailPriceMeta = $acc->getDomainMeta($this->multiStore->getRetailDomainByWholesaleDomain());
  816.                         $attrOptionProductSuggestedPrice = $attrOptionRetailPriceMeta->getDomainPrice();
  817.                         $attrOptionProductVatSuggestedPrice = $attrOptionRetailPriceMeta->getDomainVatPrice();
  818.                     }
  819.                 }
  820.                 //<- Suggested Price of Attribute
  822.                 $attrOptionPriceMeta = $acc->getDomainMeta($this->priceDomain);
  824.                 $fixedTitle = $this->translator->trans($acc->getTitle());
  825.                 if ($attributeId == Attribute::ATTRIBUTE_ID_ACCESSORY_KEYBOARD_REPRINT && str_contains($fixedTitle, 'Keyboard reprint')) {
  826.                     $fixedTitle = str_replace('Keyboard reprint', $translatedKeyboardReprint, $fixedTitle);
  827.                 }
  829.                 $accessoryAttributes[$attributeId]['options'][$acc->getId()] = [
  830.                     'id'                => $acc->getId(),
  831.                     'title'             => $fixedTitle,
  832.                     'discounted'        => $attrOptionPriceMeta->isDiscounted(),
  833.                     'price'             => $attrOptionPriceMeta->getDomainPrice(),
  834.                     'vatPrice'          => $attrOptionPriceMeta->getDomainVatPrice(),
  835.                     'discount'          => $attrOptionPriceMeta->getDomainDiscount(),
  836.                     'vatDiscounted'     => $attrOptionPriceMeta->getDomainVatDiscount(),
  837.                     'suggestedPrice'    => $attrOptionProductSuggestedPrice,
  838.                     'vatSuggestedPrice' => $attrOptionProductVatSuggestedPrice,
  839.                     'productId'         => $acc->getProduct() != null ? $acc->getProduct()->getId() : 0,
  840.                 ];
  841.             }
  843.             $sortKeyboardPrintByIds = [5495, 2487];
  844.             if ($this->priceDomain->getId() == DOMAIN::DOMAIN_ID_RT_SK || $this->priceDomain->getId() == DOMAIN::DOMAIN_ID_WS_SK || $this->priceDomain->getId() == DOMAIN::DOMAIN_ID_RT_CZ || $this->priceDomain->getId() == DOMAIN::DOMAIN_ID_WS_CZ) {
  845.                 array_unshift($sortKeyboardPrintByIds, 2444);
  846.             }
  848.             
  849.             if ($this->priceDomain->getId() == DOMAIN::DOMAIN_ID_RT_HU || $this->priceDomain->getId() == DOMAIN::DOMAIN_ID_WS_HU) {
  850.                 array_unshift($sortKeyboardPrintByIds, 2446);
  851.             }
  853.             if (!is_null($accessoryAttributes) && isset($accessoryAttributes[184]['options']) && count($accessoryAttributes[184]['options']) > 0) {
  854.                 foreach ($sortKeyboardPrintByIds as $sortKeyboardPrintById) {
  855.                     if (array_key_exists($sortKeyboardPrintById, $accessoryAttributes[184]['options'])) {
  856.                         $val = $accessoryAttributes[184]['options'][$sortKeyboardPrintById];
  857.                         unset($accessoryAttributes[184]['options'][$sortKeyboardPrintById]);
  858.                         $accessoryAttributes[184]['options'][$sortKeyboardPrintById] = $val;
  859.                     }
  860.                 }
  862.                 foreach ($accessoryAttributes[184]['options'] as $attributeOption) {
  863.                     $foundId = false;
  864.                     foreach ($sortKeyboardPrintByIds as $sortKeyboardPrintById) {
  865.                         if ($attributeOption['id'] == $sortKeyboardPrintById) {
  866.                             $foundId = true;
  867.                         }
  868.                     }
  870.                     if (!$foundId) {
  871.                         $val = $accessoryAttributes[184]['options'][$attributeOption['id']];
  872.                         unset($accessoryAttributes[184]['options'][$attributeOption['id']]);
  873.                         $accessoryAttributes[184]['options'][$attributeOption['id']] = $val;
  874.                     }
  875.                 }
  876.             }
  878.             // Add skinnable accessory choices if conditions are met
  879.             if (!$containerWithSkin && self::hasBadgeByStructuredData('Skinable', $product->getBadges())) {
  880.                 if (!$this->notebookSkinAttributeOptions) {
  881.                     $this->notebookSkinAttribute = $this->entityManager->getRepository(Attribute::class)->findOneById(Attribute::ATTRIBUTE_ID_NOTEBOOK_SKIN);
  883.                     $this->notebookSkinAttributeOptions = $this->entityManager->createQuery("SELECT ao
  884.                             FROM AtechNetCoreBundle:AttributeOption ao
  885.                             LEFT JOIN ao.product p
  886.                             WHERE ao.product IS NOT NULL
  887.                                 AND p.available > 0
  888.                                 AND ao.id != 4062
  889.                                 AND ao.archived = 0
  890.                                 AND ao.attribute = " . $this->notebookSkinAttribute->getId())
  891.                         ->getResult();
  892.                 }
  894.                 $notebookSkinAttributeId = $this->notebookSkinAttribute->getId();
  896.                 $accessoryAttributes[$notebookSkinAttributeId] = [
  897.                     'id' => $notebookSkinAttributeId,
  898.                     'title' => $this->notebookSkinAttribute->getTitle($this->translator),
  899.                     'options' => [],
  900.                 ];
  902.                 foreach ($this->notebookSkinAttributeOptions as $notebookSkinAttributeOption) {
  903.                     $attrOptionPriceMeta = $notebookSkinAttributeOption->getDomainMeta($this->priceDomain);
  905.                     $accessoryAttributes[$notebookSkinAttributeId]['options'][$notebookSkinAttributeOption->getId()] = [
  906.                         'id' => $notebookSkinAttributeOption->getId(),
  907.                         'title' => $this->translator->trans($notebookSkinAttributeOption->getTitle()),
  908.                         'discounted' => $attrOptionPriceMeta->isDiscounted(),
  909.                         'price' => $attrOptionPriceMeta->getDomainPrice(),
  910.                         'vatPrice' => $attrOptionPriceMeta->getDomainVatPrice(),
  911.                         'discount' => $attrOptionPriceMeta->getDomainDiscount(),
  912.                         'vatDiscounted' => $attrOptionPriceMeta->getDomainVatDiscount(),
  913.                         'suggestedPrice' => 0,
  914.                         'vatSuggestedPrice' => 0,
  915.                         'productId' => $notebookSkinAttributeOption->getProduct() != null ? $notebookSkinAttributeOption->getProduct()->getId() : 0,
  916.                     ];
  917.                 }
  918.             }
  919.             
  920.             $accessoryOrder = [
  921.                 Attribute::ATTRIBUTE_ID_NOTEBOOK_SKIN,
  922.                 Attribute::ATTRIBUTE_ID_ACCESSORY_KEYBOARD_REPRINT,
  923.                 Attribute::ATTRIBUTE_ID_ACCESSORY_SSD,
  924.                 Attribute::ATTRIBUTE_ID_ACCESSORY_NB_RAM_DDR2,
  925.                 Attribute::ATTRIBUTE_ID_ACCESSORY_NB_RAM_DDR3,
  926.                 Attribute::ATTRIBUTE_ID_ACCESSORY_NB_RAM_DDR4,
  927.                 Attribute::ATTRIBUTE_ID_ACCESSORY_PC_RAM_DDR2,
  928.                 Attribute::ATTRIBUTE_ID_ACCESSORY_PC_RAM_DDR3,
  929.                 Attribute::ATTRIBUTE_ID_ACCESSORY_PC_RAM_DDR4,
  930.             ];
  932.             $accessoryAttributesBuffer = $accessoryAttributes;
  933.             $accessoryAttributes = [];
  935.             foreach ($accessoryOrder as $accId) {
  936.                 if (isset($accessoryAttributesBuffer[$accId])) {
  937.                     $accessoryAttributes[] = $accessoryAttributesBuffer[$accId];
  938.                 }
  939.             }
  941.             foreach ($accessoryAttributesBuffer as $key => $acc) {
  942.                 if (!in_array($key, $accessoryOrder)) {
  943.                     $accessoryAttributes[$key] = $accessoryAttributesBuffer[$key];
  944.                 }
  945.             }
  947.             // Sort Cable Accessory
  948.             if (isset($accessoryAttributes[Attribute::ATTRIBUTE_ID_ACCESSORY_CABLE])) {
  949.                 if ($product->getType()->getId() != ProductType::PRODUCT_TYPE_ID_MONITOR) {
  950.                     $sortOrder = [
  951.                         AttributeOption::ATTRIBUTE_OPTION_ID_DISPLAY_PORT_CABLE,
  952.                         AttributeOption::ATTRIBUTE_OPTION_ID_HDMI_CABLE,
  953.                         AttributeOption::ATTRIBUTE_OPTION_ID_VGA_CABLE,
  954.                         AttributeOption::ATTRIBUTE_OPTION_ID_DVI_CABLE,
  955.                     ];
  957.                     $accessoryAttributeOptionsBuffer = $accessoryAttributes[Attribute::ATTRIBUTE_ID_ACCESSORY_CABLE]['options'];
  958.                     $accessoryAttributes[Attribute::ATTRIBUTE_ID_ACCESSORY_CABLE]['options'] = [];
  960.                     foreach ($sortOrder as $index) {
  961.                         if (isset($accessoryAttributeOptionsBuffer[$index])) {
  962.                             $accessoryAttributes[Attribute::ATTRIBUTE_ID_ACCESSORY_CABLE]['options'][$index] = $accessoryAttributeOptionsBuffer[$index];
  963.                         }
  964.                     }
  965.                 }
  966.                 else {
  967.                     $sortOrder = [
  968.                         AttributeOption::ATTRIBUTE_OPTION_ID_DISPLAY_PORT_CABLE,
  969.                         AttributeOption::ATTRIBUTE_OPTION_ID_HDMI_CABLE,
  970.                         AttributeOption::ATTRIBUTE_OPTION_ID_VGA_CABLE,
  971.                     ];
  973.                     $accessoryAttributeOptionsBuffer = $accessoryAttributes[Attribute::ATTRIBUTE_ID_ACCESSORY_CABLE]['options'];
  974.                     $accessoryAttributes[Attribute::ATTRIBUTE_ID_ACCESSORY_CABLE]['options'] = [];
  976.                     foreach ($sortOrder as $index) {
  977.                         if (isset($accessoryAttributeOptionsBuffer[$index])) {
  978.                             $accessoryAttributes[Attribute::ATTRIBUTE_ID_ACCESSORY_CABLE]['options'][$index] = $accessoryAttributeOptionsBuffer[$index];
  979.                         }
  980.                     }
  981.                 }
  982.             }
  984.             // Remove attributes with no options
  985.             foreach ($accessoryAttributes as $key => $value) {
  986.                 if (count($value['options']) < 1) {
  987.                     unset($accessoryAttributes[$key]);
  988.                 }
  989.             }
  991.             $images = $product?->getAlbum()?->getPhotos() ?? [];
  993.             $connectedBatteries = $product?->getConnectedBatteries() ?? [];
  995.             if (!empty($connectedBatteries)) {
  996.                 $batterAttributeOptionId = ProductService::getBatteryAttributeOptionIdByPrice($product, $this->localeDomain, $this->historicalEuroRate);
  997.             }
  998.         }
  999.         else if ($viewMode == 'list') {
  1000.             $listAllowedAttributes = $isCustomerTypeRetail ? self::LIST_ALLOWED_ATTRIBUTES_RETAIL : self::LIST_ALLOWED_ATTRIBUTES_WHOLESALE;
  1001.             $specificationAttributes = [];
  1003.             if (isset($listAllowedAttributes[$product->getType()->getId()])) {
  1004.                 /**
  1005.                  * @var ProductAttribute $spec
  1006.                  */
  1007.                 foreach ($product->getSpecificationProductAttributeOptions() as $spec) {
  1008.                     $option = $spec->getOption();
  1009.                     $attributeId = $option->getAttribute()->getId();
  1010.                     $product = $spec->getProduct();
  1012.                     if ($option->getId() == AttributeOption::ATTRIBUTE_OPTION_NO_WEBCAM) {
  1013.                         $noWebcamBadge = true;
  1014.                     }
  1016.                     if (in_array($attributeId, $listAllowedAttributes[$product->getType()->getId()])) {
  1017.                         if (!isset($specificationAttributes[$attributeId])) {
  1018.                             $specificationAttributes[$attributeId] = [
  1019.                                 'id' => $attributeId,
  1020.                                 'title' => $option->getAttribute()->getTitle($this->translator),
  1021.                                 'vendor' => strtok($option->getLongTitle(), ' '),
  1022.                                 'options' => [],
  1023.                             ];
  1024.                         }
  1026.                         $specificationAttributes[$attributeId]['options'][$spec->getId()] = [
  1027.                             'id' => $spec->getId(),
  1028.                             'title' => $option->getTitle($this->translator),
  1029.                             'vendor' => strtok($option->getLongTitle(), ' '),
  1030.                             'multiplier' => $spec->getMultiplier(),
  1031.                         ];
  1032.                     }
  1033.                 }
  1034.             } else {
  1035.                 $specificationCount = 0;
  1037.                 /**
  1038.                  * @var ProductAttribute $spec
  1039.                  */
  1040.                 foreach ($product->getSpecificationProductAttributeOptions() as $spec) {
  1041.                     $specificationCount++;
  1043.                     $option = $spec->getOption();
  1044.                     $attributeId = $option->getAttribute()->getId();
  1046.                     if (!isset($specificationAttributes[$attributeId])) {
  1047.                         $specificationAttributes[$attributeId] = [
  1048.                             'id' => $attributeId,
  1049.                             'title' => $option->getAttribute()->getTitle($this->translator),
  1050.                             'vendor' => strtok($option->getLongTitle(), ' '),
  1051.                             'options' => [],
  1052.                         ];
  1053.                     }
  1055.                     $specificationAttributes[$attributeId]['options'][$spec->getId()] = [
  1056.                         'id' => $spec->getId(),
  1057.                         'title' => $option->getTitle($this->translator),
  1058.                         'vendor' => strtok($option->getLongTitle(), ' '),
  1059.                         'multiplier' => $spec->getMultiplier(),
  1060.                     ];
  1062.                     if ($specificationCount >= 4) {
  1063.                         break;
  1064.                     }
  1065.                 }
  1066.             }
  1068.             $specificationAttributesListText = $this->getAttributeInfoForProductDescription($specificationAttributes);
  1069.         }
  1071.         if ($priceMeta && $priceMeta->isReady() && $priceMeta->isActive() && $product->isReservable() && ($viewMode == 'details' || $viewMode == 'list')) {
  1072.             $outOfStockStatus = $product->getOutOfStockStatus();
  1074.             if ($outOfStockStatus == Product::OutOfStockStatus_VisibleOrderable5Days) {
  1075.                 $orderWaitingDays = 5;
  1076.             } elseif ($outOfStockStatus == Product::OutOfStockStatus_VisibleOrderable10Days) {
  1077.                 $orderWaitingDays = 10;
  1078.             } elseif ($outOfStockStatus == Product::OutOfStockStatus_VisibleOrderable15Days) {
  1079.                 $orderWaitingDays = 15;
  1080.             } else {
  1081.                 $orderWaitingDays = 0;
  1082.             }
  1083.         } else {
  1084.             $orderWaitingDays = 0;
  1085.         }
  1087.         if ($viewMode == 'list' || $viewMode == 'cart' || $viewMode == 'popular') {
  1088.             foreach ($product->getAlbum()->getPhotos() as $photo) {
  1089.                 $images = $photo;
  1091.                 break;
  1092.             }
  1093.         }
  1095.         if ($viewMode == 'configurator') {
  1096.             $images = $product->getAlbum()->getNthPhoto();
  1097.         }
  1099.         if ($withMultipleImage)
  1100.         {
  1101.             $images = $product->getAlbum()->getPhotos()->toArray();
  1102.         }
  1104.         $review_count = 0;
  1105.         $review_stars_sum = 0;
  1106.         $review_stars = 0;
  1107.         $reviews = [];
  1109.         $languageId = $this->multiStore->getDefaultLanguageId();
  1111.         $languageIds = [$languageId];
  1113.         $czReviewFirst = false;
  1115.         if ($languageId == Language::LANGUAGE_ID_CZ) {
  1116.             $languageIds[] = Language::LANGUAGE_ID_SK;
  1117.             $czReviewFirst = true;
  1118.         } elseif ($languageId == Language::LANGUAGE_ID_SK) {
  1119.             $languageIds[] = Language::LANGUAGE_ID_CZ;
  1120.         }
  1122.         $productFamilyReviews = $this->entityManager->createQuery("SELECT r
  1123.                     FROM AtechNetCoreBundle:Review r
  1124.                     LEFT JOIN r.product p
  1125.                     WHERE r.type = :reviewType AND p.name = :productName AND r.language IN(:languageIds) AND r.approved = 1
  1126.                     ORDER BY" . ($czReviewFirst ? ' r.language DESC, ' : '') . " r.created DESC")
  1127.             ->setParameters([
  1128.                 'reviewType' => Review::TYPE_PRODUCT,
  1129.                 'productName' => $product->getName(),
  1130.                 'languageIds' => $languageIds,
  1131.             ])
  1132.             ->getResult();
  1134.         $fs = new Filesystem();
  1136.         /**
  1137.          * @var Review $review
  1138.          * @var ReviewSurveyMedia $reviewSurveyMedia
  1139.          */
  1140.         if (count($productFamilyReviews) > 0) {
  1141.             foreach ($productFamilyReviews as $review) {
  1142.                 $reviewProduct = $review->getProduct();
  1144.                 $review_count = $review_count + 1;
  1145.                 $review_stars_sum = $review_stars_sum + $review->getStars();
  1147.                 $reviewImages = [];
  1149.                 if ($viewMode == 'details') {
  1150.                     foreach ($review->getSurveyMedias() as $reviewSurveyMedia) {
  1151.                         if ($reviewSurveyMedia->isApproved()) {
  1152.                             $surveyMedia = $reviewSurveyMedia->getSurveyMedia();
  1154.                             // CREATE FINAL PATH FOR RESIZED IMAGE
  1155.                             $thumbDirPath = 'storage/image/reviews/' . $review->getId() . '/thumbs';
  1156.                             $popupDirPath = 'storage/image/reviews/' . $review->getId() . '/popup';
  1158.                             $thumbPath = $thumbDirPath . '/' . $surveyMedia->getFilename();
  1159.                             $popupPath = $popupDirPath . '/' . $surveyMedia->getFilename();
  1162.                             if (!$fs->exists($thumbDirPath)) {
  1163.                                 $fs->mkdir($thumbDirPath, 0755);
  1164.                             }
  1166.                             if (!$fs->exists($popupDirPath)) {
  1167.                                 $fs->mkdir($popupDirPath, 0755);
  1168.                             }
  1170.                             // Cloudflare Image (thumb)
  1171.                             $imageThumbPath = $reviewSurveyMedia->getCdnUrl('ProductViewThumb');
  1173.                             // Internal Image (thumb)
  1174.                             if ($imageThumbPath == '' && !$fs->exists($thumbPath)) {
  1175.                                 $resize = new ResizeImage($surveyMedia->getDirectory() . '/' . $surveyMedia->getFilename());
  1176.                                 $resize->resizeTo(Image::PRODUCT_VIEW_THUMB_WIDTH, Image::PRODUCT_VIEW_THUMB_HEIGHT, 'maxWidth');
  1177.                                 $resize->saveImage($thumbPath);
  1179.                                 $imageThumbPath = '/' . $thumbPath;
  1180.                             } elseif ($imageThumbPath == '') {
  1181.                                 $imageThumbPath = '/' . $thumbPath;
  1182.                             }
  1184.                             // Cloudflare Image (popup)
  1185.                             $imagePopupPath = $reviewSurveyMedia->getCdnUrl('ProductViewPop');
  1187.                             // Internal Image (popup)
  1188.                             if ($imagePopupPath == '' && !$fs->exists($popupPath)) {
  1189.                                 $resize = new ResizeImage($surveyMedia->getDirectory() . '/' . $surveyMedia->getFilename());
  1190.                                 $resize->resizeTo(Image::PRODUCT_VIEW_POPUP_WIDTH, Image::PRODUCT_VIEW_POPUP_HEIGHT);
  1191.                                 $resize->saveImage($popupPath);
  1193.                                 $imagePopupPath = '/' . $popupPath;
  1194.                             } elseif ($imagePopupPath == '') {
  1195.                                 $imagePopupPath = '/' . $popupPath;
  1196.                             }
  1198.                             $reviewImages[] = [
  1199.                                 'thumb' => $imageThumbPath,
  1200.                                 'popup' => $imagePopupPath,
  1201.                             ];
  1202.                         }
  1203.                     }
  1204.                 }
  1206.                 if ($viewMode == 'details') {
  1207.                     $reviews[] = [
  1208.                         'stars' => $review->getStars(),
  1209.                         'message' => $review->getText(),
  1210.                         'name' => $review->getName(),
  1211.                         'product_name' => $reviewProduct->getVendor()->getName() . ' ' . $reviewProduct->getName(),
  1212.                         'product_config' => $reviewProduct->getDescription(),
  1213.                         'reviewDate' => $review->getCreated()->format('Y.m.d'),
  1214.                         'reviewImages' => $reviewImages,
  1215.                     ];
  1216.                 }
  1217.             }
  1219.             $review_stars = floor(($review_stars_sum / $review_count) * 2) / 2;
  1220.         }
  1222.         // Badges
  1223.         $badgesRaw = [];
  1225.         if ($noWebcamBadge) {
  1226.             $badgesRaw[] = 'no_webcam';
  1227.         }
  1229.         if ($viewMode == 'details') {
  1230.             $categoryPages = $product->getCategoryPages();
  1232.             foreach ($categoryPages as $categoryPage) {
  1233.                 $categoryId = $categoryPage->getId();
  1235.                 break;
  1236.             }
  1237.         }
  1239.         // Add Quality to Badges
  1240.         $quality = $product->getQualityStatus();
  1242.         if (in_array($quality, [Product::QualityStatus_New, Product::QualityStatus_Platinum, Product::QualityStatus_Gold, Product::QualityStatus_Silver, Product::QualityStatus_Bronze, Product::QualityStatus_Bazaar])) {
  1243.             $badgesRaw[] = strtolower(Product::getQualityStatusTitleForKey($quality));
  1244.         }
  1246.         // Windows
  1247.         $windows = false;
  1248.         $index = count($badgesRaw);
  1250.         $allowedBadges = [
  1251.             'bronze',
  1252.             'silver',
  1253.             'gold',
  1254.             'platinum',
  1255.             'new',
  1256.             'bazaar',
  1257.             'Chromebook',
  1258.             'Windows 11',
  1259.         ];
  1261.         if ($viewMode != 'list' && $viewMode != 'details') {
  1262.             foreach ($product->getBadges() as $badge) {
  1263.                 if (!in_array($badge, $allowedBadges)) {
  1264.                     continue;
  1265.                 }
  1267.                 $isItWindows = strpos($badge, 'win');
  1269.                 if (($isItWindows !== false && !$this->showWindows) || $badge == '24h') {
  1270.                     continue;
  1271.                 }
  1273.                 if ($isItWindows !== false) {
  1274.                     if ($windows !== false) {
  1275.                         unset($badgesRaw[$windows]);
  1276.                     }
  1277.                     $windows = $index;
  1278.                 }
  1280.                 $badgesRaw[$index] = $badge;
  1282.                 $index++;
  1283.             }
  1284.         } else {
  1285.             foreach ($product->getBadges() as $badge) {
  1286.                 if (in_array($badge, $allowedBadges)) {
  1287.                     $badgesRaw[$index] = $badge;
  1288.                 }
  1290.                 $index++;
  1291.             }
  1292.         }
  1294.         // Limit Badges
  1295.         $badges = array_slice($badgesRaw, 0, 4);
  1297.         // Bestseller
  1298.         if ( $product->hasBadgeItem(Product::PRODUCT_BADGE_BESTSELLER) ) {
  1299.             $isBestseller = true;
  1300.         } else {
  1301.             $isBestseller = false;
  1302.         }
  1304.         // Short description
  1305.         if ($this->showWindows) {
  1306.             $shortDescription = $product->getDescription();
  1307.         } else {
  1308.             $shortDescription = str_replace([' | Win 7 Pro COA', ' | Win 7 Home COA', ' | Win 10 Pro', ' | Win 10 Home', ' | MAR Win 10 Pro'], '', $product->getDescription());
  1309.         }
  1311.         $timedSalesStartDate = false;
  1313.         if (!is_null($priceMeta?->getSaleStart())) {
  1314.             $salesStartDate = $priceMeta->getSaleStart();
  1316.             $timedSalesStartDate = [
  1317.                 'year' => $salesStartDate->format('Y'),
  1318.                 'month' => $salesStartDate->format('M'),
  1319.                 'day' => $salesStartDate->format('d'),
  1320.                 'hour' => $salesStartDate->format('H'),
  1321.             ];
  1322.         }
  1324.         $timedSalesEndDate = false;
  1326.         if (!is_null($priceMeta?->getSaleEnd())) {
  1327.             $salesEndDate = $priceMeta->getSaleEnd();
  1329.             $timedSalesEndDate = [
  1330.                 'year' => $salesEndDate->format('Y'),
  1331.                 'month' => $salesEndDate->format('M'),
  1332.                 'day' => $salesEndDate->format('d'),
  1333.                 'hour' => $salesEndDate->format('H'),
  1334.             ];
  1335.         }
  1337.         $currentVatPrice = $priceMeta
  1338.             ? $priceMeta->isDiscounted() ? $priceMeta->getDomainVatDiscount() : $priceMeta->getDomainVatPrice()
  1339.             : null;
  1341.         $couponWithBatch = $this->entityManager->getRepository(Coupon::class)
  1342.             ->getCouponsWithBadge($this->multiStore->getDomainId(), [$product->getType()]);
  1344.         if (!$couponWithBatch?->isAvailableForDiscountedProducts() && $priceMeta->isDiscounted()) {
  1345.             $couponWithBatch = null;
  1346.         }
  1348.         /** @var Coupon $activeCoupon */
  1349.         $activeCoupon = $couponWithBatch ?? $product->getCoupons()->map(function (Coupon $coupon) {
  1350.             if ($coupon->isActive() && $coupon->getDomain()->getId() == $this->priceDomain->getId()) {
  1351.                 return $coupon;
  1352.             }
  1353.             return null;
  1354.         })->filter(function ($coupon) {
  1355.             return !is_null($coupon);
  1356.         })->first() ?: null;
  1358.         if ($activeCoupon?->getCode() == 'SUMMER10') {
  1359.             $activeCoupon = null;
  1360.         }
  1362.         if ($activeCoupon) {
  1363.             switch ($activeCoupon->getDiscountType()) {
  1364.                 case Coupon::DISCOUNT_TYPE_PERCENT:
  1365.                     $discountPercentage = (100 - $activeCoupon->getDiscount()) / 100;
  1366.                     $priceWithCoupon = $priceMeta->getDomainVatPrice() * $discountPercentage;
  1367.                     break;
  1368.                 case Coupon::DISCOUNT_TYPE_PRICE:
  1369.                     $priceWithCoupon = $priceMeta->getDomainVatPrice() - $activeCoupon->getDiscount();
  1370.                     break;
  1371.                 default:
  1372.                     $priceWithCoupon = 0;
  1373.                     break;
  1374.             }
  1375.         } else {
  1376.             $priceWithCoupon = 0;
  1377.         }
  1379.         if ($priceWithCoupon > 0) {
  1380.             if (in_array($this->priceDomain->getId(), [Domain::DOMAIN_ID_WS_HU, Domain::DOMAIN_ID_RT_HU])) {
  1381.                 $priceWithCoupon = ceil($priceWithCoupon / 10) * 10;
  1382.             } elseif (in_array($this->priceDomain->getId(), [Domain::DOMAIN_ID_WS_CZ, Domain::DOMAIN_ID_RT_CZ])) {
  1383.                 $priceWithCoupon = ceil($priceWithCoupon);
  1384.             }
  1385.         }
  1387.         $productModelMeta = $product?->getProductModel()?->getProductModelMetas()->filter(function (ProductModelMeta $productModelMeta) {
  1388.            return $productModelMeta->getLanguage()->getId() == $this->multiStore->getDefaultLanguageId();
  1389.         })->first();
  1391.         $warranties = null;
  1392.         if ($viewMode == 'details') {
  1393.             if (
  1394.                 in_array($product->getType()->getId(), [
  1395.                     ProductType::PRODUCT_TYPE_ID_ALL_IN_ONE,
  1396.                     ProductType::PRODUCT_TYPE_ID_MONITOR,
  1397.                     ProductType::PRODUCT_TYPE_ID_NOTEBOOK,
  1398.                     ProductType::PRODUCT_TYPE_ID_PC,
  1399.                     ProductType::PRODUCT_TYPE_ID_PC_SET,
  1400.                 ])
  1401.                 && $product->getQualityStatus() != Product::QualityStatus_Bazaar
  1402.             ) {
  1403.                 $warranties = [
  1404.                     AttributeOption::ATTRIBUTE_OPTION_1_YEAR_WARRANTY => [
  1405.                         'image'          => 'theme/images/1-year-warranty.svg',
  1406.                         'additionalInfo' => 'total 3 years',
  1407.                         'percentPrice'   => 10,
  1408.                     ],
  1409.                     AttributeOption::ATTRIBUTE_OPTION_2_YEAR_WARRANTY => [
  1410.                         'image'          => 'theme/images/2-year-warranty.svg',
  1411.                         'additionalInfo' => 'total 4 years',
  1412.                         'percentPrice'   => 20,
  1413.                     ],
  1414.                     AttributeOption::ATTRIBUTE_OPTION_3_YEAR_WARRANTY => [
  1415.                         'image'          => 'theme/images/3-year-warranty.svg',
  1416.                         'additionalInfo' => 'total 5 years',
  1417.                         'percentPrice'   => 30,
  1418.                     ],
  1419.                 ];
  1420.             }
  1421.         }
  1423.         return [
  1424.             'id'                      => $product->getId(),
  1425.             'code'                    => $product->getCode(),
  1426.             'partNumber'              => !is_null($product->getPartNumber()) && $product->getPartNumber() != '' ? $product->getPartNumber() : '',
  1427.             'active'                  => $priceMeta?->isActive() ?? false,
  1428.             'listed'                  => $priceMeta?->isListed() ?? false,
  1429.             'orderable'               => $priceMeta && $priceMeta->isActive() && ($product->isAvailable() || ($product->isReservable() && $priceMeta->isReady())) && $priceMeta->isOrderable(),
  1430.             'vendorId'                => $product->getVendor()->getId(),
  1431.             'vendor'                  => $product->getVendor()->getName(),
  1432.             'productTypeId'           => $product->getType()->getId(),
  1433.             'productType'             => $product->getType()->getTitle($this->translator),
  1434.             'title'                   => in_array($this->priceDomainId, [Domain::DOMAIN_ID_RT_EU, Domain::DOMAIN_ID_WS_EU]) ? str_replace([' (Quality: Bazar)', ' (Quality: Bazár)', ' (Quality: Bazár, '], ['', '', ' ('], $product->getName()) : $product->getName(),
  1435.             'width'                   => $product->getWidth(),
  1436.             'height'                  => $product->getHeight(),
  1437.             'length'                  => $product->getlength(),
  1438.             'weight'                  => $product->getWeight(),
  1439.             'shortDescription'        => $shortDescription,
  1440.             'isDiscounted'            => $priceMeta?->isDiscounted() ?? false,
  1441.             'vat'                     => $priceMeta?->getVat() ?? 0,
  1442.             'price'                   => $priceMeta?->getDomainPrice() ?? 0,
  1443.             'rawPrice'                => $priceMeta?->getPrice() ?? 0,
  1444.             'vatPrice'                => $priceMeta?->getDomainVatPrice() ?? 0,
  1445.             'vatPriceWithCoupon'      => $priceWithCoupon,
  1446.             'discountPrice'           => $priceMeta?->getDomainDiscount(),
  1447.             'couponId'                => $activeCoupon?->getId(),
  1448.             'couponCode'              => $activeCoupon?->getCode(),
  1449.             'couponDiscount'          => $activeCoupon?->getDiscount(),
  1450.             'showCouponBadgeOnWebsite'=> $activeCoupon?->isShowBadgeOnWebsite(),
  1451.             'rawDiscountPrice'        => $priceMeta?->getDiscount(),
  1452.             'discountVatPrice'        => $priceMeta?->getDomainVatDiscount(),
  1453.             'suggestedPrice'          => $priceMeta?->getDomainSuggestedPrice(),
  1454.             'suggestedVatPrice'       => $priceMeta?->getDomainVatSuggestedPrice(),
  1455.             'isAvailable'             => $product->isAvailable(),
  1456.             'availableQty'            => $product->getAvailable(),
  1457.             'additionalDetail'        => $localeMeta?->getDetail(),
  1458.             'warranty'                => $priceMeta?->getWarranty(),
  1459.             'bestSeller'              => $priceMeta?->isBestSeller(),
  1460.             'reLenovo'                => $priceMeta?->isReLenovo(),
  1461.             'hpRenew'                 => $priceMeta?->isHpRenew(),
  1462.             'specialPromotion'        => $priceMeta?->isSpecialPromotion(),
  1463.             'badges'                  => $badges, // .label-{badge}
  1464.             'badgesRaw'               => $badgesRaw,
  1465.             'attributes'              => $specificationAttributes,
  1466.             'isContainer'             => $isContainer,
  1467.             'containerParts'          => $containerPartsSpecifications,
  1468.             'attributesListTxt'       => $specificationAttributesListText,
  1469.             'accessories'             => $accessoryAttributes,
  1470.             'defaultOptions'          => self::DEFAULT_ACCESSORY_SELECTIONS,
  1471.             'images'                  => $images,
  1472.             'categoryId'              => $categoryId,
  1473.             'qualityTitle'            => $product->getQualityStatusTitle($product->getQualityStatus()),
  1474.             'qualityStatusId'         => $product->getQualityStatus(),
  1475.             'timedSalesActive'        => $priceMeta?->isTimedSaleActive(true),
  1476.             'timedSalesStartDate'     => $timedSalesStartDate,
  1477.             'timedSalesEndDate'       => $timedSalesEndDate,
  1478.             'reviewCount'             => $review_count,
  1479.             'reviewStars'             => $review_stars,
  1480.             'reviews'                 => $reviews,
  1481.             'freeShipping'            => $freeShipLimit < $currentVatPrice,
  1482.             'isReservable'            => ($priceMeta?->isReady() && $priceMeta?->isActive() && $product->isReservable()),
  1483.             'orderWaitingDays'        => $orderWaitingDays,
  1484.             'outOfStockStatus'        => $product->getOutOfStockStatus(),
  1485.             'productModelDescription' => $productModelMeta ? $this->getProductMetaText($productModelMeta->getText(), $specificationAttributes) : null,
  1486.             'warranties'              => $warranties,
  1487.             'connectedBatteries'      => $connectedBatteries,
  1488.             'batterAttributeOptionId' => $batterAttributeOptionId,
  1489.             'isBestseller'            => $isBestseller, 
  1490.             'isBazaar'                => $product->isBazaar()
  1491.         ];
  1492.     }
  1494.     /**
  1495.      * @param $productIds
  1496.      * @return array
  1497.      */
  1498.     public function getStructuredDataByProductIds($productIds)
  1499.     {
  1500.         $products = [];
  1502.         $productRepo = $this->entityManager->getRepository(Product::class);
  1504.         foreach ($productIds as $productId) {
  1505.             $product = $productRepo->findOneById($productId);
  1507.             if ($product) {
  1508.                 $products[] = $product;
  1509.             }
  1510.         }
  1512.         return $this->getStructuredDataForProducts($products);
  1513.     }
  1515.     /**
  1516.      * @param int $productId
  1517.      * @param string $viewMode
  1518.      * @return array
  1519.      */
  1520.     public function getStructuredDataByProductId(int $productId, string $viewMode = 'details'): array
  1521.     {
  1522.         $productRepo = $this->entityManager->getRepository(Product::class);
  1524.         $product = $productRepo->findOneById($productId);
  1526.         return $product ? $this->getStructuredDataForProduct($product, $viewMode) : [];
  1527.     }
  1529.     /**
  1530.      * @param array $filter
  1531.      * @param array $options
  1532.      * @return array
  1533.      */
  1534.     public function getStructuredDataByFilters(array $filter = [], array $options = []): array
  1535.     {
  1536.         $products = [];
  1537.         if (isset($filter['filterCategoryId'])) {
  1538.             $categoryPage = $this->entityManager->find(CategoryPage::class, $filter['filterCategoryId']);
  1539.             $priorityProducts = $this->getPriorityProductsForCategoryPages($filter, $categoryPage);
  1540.             /**
  1541.              * @var Product $product
  1542.              */
  1543.             foreach ($priorityProducts as $product) {
  1544.                 $products[$product->getId()] = $this->getStructuredDataForProduct($product, 'list');
  1545.             }
  1548.             if (!$this->isUserApplyingFilters($filter, $categoryPage) && count($priorityProducts) > 0) {
  1549.                 $filter['limit'] -= count($priorityProducts) - 1;
  1550.             }
  1551.         }
  1553.         $query = $this->getProductListingQuery($filter, $options);
  1555.         $results = new Paginator($query);
  1557.         /**
  1558.          * @var Product $product
  1559.          */
  1560.         foreach ($results as $product) {
  1561.             $products[$product->getId()] = $this->getStructuredDataForProduct($product, 'list');
  1562.         }
  1564.         return $products;
  1565.     }
  1567.     /**
  1568.      * @param SeoUrlHelper $seoUrlHelper
  1569.      * @param array $filter
  1570.      * @param $translator
  1571.      * @return array
  1572.      */
  1573.     public function getVariantsForFilter(SeoUrlHelper $seoUrlHelper, $translator, array $filter = []): array
  1574.     {
  1575.         $query = $this->getProductVariantsQuery($filter);
  1576.         $results = new Paginator($query, true);
  1578.         $products = [];
  1579.         $i = 0;
  1580.         foreach ($results as $product) {
  1581.             $productData = $this->getStructuredDataByProductId($product->getId(), 'list');
  1583.             $products[$i]['description'] = explode(' | ', $product->getDescription());
  1584.             $products[$i]['link'] = $seoUrlHelper->link('product', [
  1585.                 'product_id' => $product->getId(),
  1586.                 'isBazaar'   => $product->isBazaar()
  1587.             ]);
  1588.             $products[$i]['price'] = $filter['basePrice'] == MultiStore::BASE_PRICE_GROSS ?
  1589.                 ($productData['isDiscounted'] ? $productData['discountVatPrice'] : $productData['vatPrice']) :
  1590.                 ($productData['isDiscounted'] ? $productData['discountPrice'] : $productData['price']);
  1591.             $products[$i]['oldPriceForDiscount'] = $filter['basePrice'] == MultiStore::BASE_PRICE_GROSS ? $productData['vatPrice'] : $productData['price'];
  1592.             $products[$i]['isDiscounted'] = $productData['isDiscounted'];
  1593.             $products[$i]['qualityStatusId'] = $productData['qualityStatusId'];
  1594.             $products[$i]['quality'] = $translator->trans($productData['qualityTitle']);
  1595.             $products[$i]['title'] = $productData['vendor'] . ' ' . $productData['title'];
  1597.             $image = '';
  1599.             if (is_object($productData['images'])) {
  1600.                 $image = $this->getImage($productData['images'], 'product/' . $productData['code'])->resize(Image::PRODUCT_LIST_THUMB_WIDTH, Image::PRODUCT_LIST_THUMB_HEIGHT);
  1601.             }
  1602.             $products[$i]['image'] = $image;
  1604.             $i++;
  1605.         }
  1607.         return $products;
  1608.     }
  1610.     /**
  1611.      * @param array $filter
  1612.      * @return int
  1613.      */
  1614.     public function getTotalByFilters(array $filter = []): int
  1615.     {
  1616.         $query = $this->getProductListingQuery($filter, [
  1617.             'count' => true,
  1618.         ]);
  1619.         $result = $query->getSingleScalarResult();
  1621.         return (int)$result;
  1622.     }
  1625.     /**
  1626.      * @param array $filter
  1627.      * @param array $options
  1628.      * @return array
  1629.      */
  1630.     public function getStructuredDataForWizard(array $filter = [], array $options = []): array
  1631.     {
  1632.         $query = $this->getListForWizard($filter, $options);
  1633.         $results = new Paginator($query, $fetchJoinCollection = true);
  1635.         $products = [];
  1637.         foreach ($results as $result) {
  1638.             $products[$result->getId()] = $this->getStructuredDataForProduct($result, 'list');
  1639.         }
  1641.         return $products;
  1642.     }
  1644.     /**
  1645.      * @param array $filter
  1646.      * @return int
  1647.      */
  1648.     public function getCountForWizard(array $filter = []): int
  1649.     {
  1650.         $query = $this->getListForWizard($filter, [
  1651.             'count' => true,
  1652.         ]);
  1654.         $result = $query->getSingleScalarResult();
  1656.         return (int)$result;
  1657.     }
  1660.     /**
  1661.      * @param array $filter
  1662.      * @param array $options
  1663.      * @return array
  1664.      */
  1665.     public function buildFilterOptions(array $filter, array $options = []): array
  1666.     {
  1667.         // Attribute Filter by Category Page
  1668.         $attributeFilters = [];
  1669.         $vendors = $productTypes = [];
  1671.         // For Latest list page
  1672.         $categoryFilters = [];
  1674.         //Switch for notebook show
  1675.         $notebookShow = false;
  1677.         $useSalesFilters = in_array($filter['filterCategoryId'], CategoryPage::SALE_CATEGORY_PAGES) && !is_null($filter['filterProductType']);
  1679.         if (isset($filter['filterCategoryId']) && $useSalesFilters) {
  1680.             $isOtherCategory = false;
  1681.             if ($filter['filterProductType'] == ProductType::PRODUCT_TYPE_ID_NOTEBOOK) {
  1682.                 $notebookShow = true;
  1683.             } else if ($filter['filterProductType'] == ProductType::PRODUCT_TYPE_ID_OTHER) {
  1684.                 $categoryPage = $filter['filterCategoryId'] > 0
  1685.                     ? $this->entityManager->getRepository(CategoryPage::class)->findOneById($filter['filterCategoryId'])
  1686.                     : false;
  1688.                 if ($categoryPage) {
  1689.                     $isOtherCategory = true;
  1691.                     foreach ($categoryPage->getProducts() as $product) {
  1692.                         $productType = $product->getType();
  1694.                         if (in_array($productType->getId(), ProductType::getSaleProductTypeFilterTypes())) {
  1695.                             continue;
  1696.                         }
  1698.                         if (!isset($productTypes[$productType->getId()])) {
  1699.                             $productTypes[$productType->getId()] = [
  1700.                                 'id'   => $productType->getId(),
  1701.                                 'name' => $productType->getTitle($this->translator),
  1702.                             ];
  1703.                         }
  1704.                     }
  1705.                 }
  1706.             }
  1708.             $filterAttribute = [];
  1710.             if (isset($filter['filterAttribute'])) {
  1711.                 $filterAttribute = $filter['filterAttribute'];
  1712.             }
  1714.             $filters = $isOtherCategory
  1715.                 ? []
  1716.                 : CategoryPage::getFiltersForProductType((int)$filter['filterProductType']);
  1718.             foreach ($filters as $attributeId) {
  1719.                 $attributeFilter = $filterAttribute;
  1721.                 $attribute = $this->entityManager->getRepository(Attribute::class)
  1722.                     ->findOneById($attributeId);
  1724.                 if ($attribute) {
  1725.                     $attributeFilters[$attribute->getId()] = [
  1726.                         'id'      => $attribute->getId(),
  1727.                         'title'   => $attribute->getTitle($this->translator),
  1728.                         'filter'  => $attributeFilter,
  1729.                         'options' => [],
  1730.                     ];
  1731.                 }
  1732.             }
  1733.         }
  1734.         else if (isset($filter['filterCategoryId'])) {
  1735.             $categoryPage = $filter['filterCategoryId'] > 0
  1736.                 ? $this->entityManager->getRepository(CategoryPage::class)->findOneById($filter['filterCategoryId'])
  1737.                 : false;
  1739.             $filterAttribute = [];
  1741.             if (isset($filter['filterAttribute'])) {
  1742.                 $filterAttribute = $filter['filterAttribute'];
  1743.             }
  1745.             if ($categoryPage) {
  1746.                 foreach ($categoryPage->getFilterAttributes() as $categoryFilterAttribute) {
  1747.                     $attributeFilter = $filterAttribute;
  1748.                     $attribute = $categoryFilterAttribute->getAttribute();
  1750.                     $attributeFilters[$attribute->getId()] = [
  1751.                         'id'      => $attribute->getId(),
  1752.                         'title'   => $attribute->getTitle($this->translator),
  1753.                         'filter'  => $attributeFilter,
  1754.                         'options' => [],
  1755.                     ];
  1756.                 }
  1757.             }
  1759.             if ($categoryPage->getProductTypes()->count() == 1) {
  1760.                 $productType = $categoryPage->getProductTypes()->first();
  1761.                 if ($productType->getId() == ProductType::PRODUCT_TYPE_ID_NOTEBOOK) {
  1762.                     $notebookShow = true;
  1763.                 }
  1764.             }
  1766.             if ($categoryPage->getProductTypes()->count() > 1) {
  1767.                 foreach ($categoryPage->getProductTypes() as $key => $productType) {
  1768.                     if ($productType->getId() == ProductType::PRODUCT_TYPE_ID_NOTEBOOK) {
  1769.                         $notebookShow = true;
  1770.                     }
  1771.                     $productTypes[$productType->getId()] = [
  1772.                         'id'   => $productType->getId(),
  1773.                         'name' => $productType->getTitle($this->translator),
  1774.                     ];
  1775.                 }
  1776.             }
  1778.             //show productTypes always
  1779.             if (count($productTypes) == 0) {
  1780.                 /** @var Product $product */
  1781.                 foreach ($categoryPage->getProducts() as $product) {
  1782.                     $productType = $product->getType();
  1783.                     if ($productType->getId() == ProductType::PRODUCT_TYPE_ID_NOTEBOOK) {
  1784.                         $notebookShow = true;
  1785.                     }
  1787.                     $isSetShow = in_array($categoryPage->getId(), [217, 218, 219]) && $productType->getId() == ProductType::PRODUCT_TYPE_ID_NOTEBOOK;
  1788.                     $productTypes[$productType->getId()] = [
  1789.                         'id'   => $productType->getId(),
  1790.                         'name' => $isSetShow ? $this->translator->trans('notebook set') : $productType->getTitle($this->translator),
  1791.                     ];
  1793.                     if ($product->getTags()->count() > 0) {
  1794.                         $newBattery = $product->getTags()->exists(fn(int $index, ProductTag $tag) => $tag->getTitle() == 'New battery - Notebook');
  1796.                         if ($newBattery) {
  1797.                             $attributeFilters['newBattery'] = [
  1798.                                 'id'      => 'newBattery',
  1799.                                 'title'   => $this->translator->trans('New battery'),
  1800.                                 'filter'  => $filterAttribute,
  1801.                                 'options' => [
  1802.                                     [
  1803.                                         'id'        => '1',
  1804.                                         'title'     => $this->translator->trans('Yes'),
  1805.                                         'count'     => 0,
  1806.                                         'sortOrder' => 1,
  1807.                                     ],
  1808.                                 ],
  1809.                             ];
  1810.                         }
  1811.                     }
  1812.                 }
  1813.             }
  1815.             //EXTRA PAGES FOR NOOTEBOOK SHOW
  1816.             if (in_array($categoryPage->getId(), [615, 614, 217, 218, 219, 627, 625])) {
  1817.                 $notebookShow = true;
  1818.             }
  1820.             if ($notebookShow && !isset($attributeFilters['newBattery'])) {
  1821.                 $categoryProductTypes = $categoryPage->getProductTypes();
  1822.                 if ($categoryProductTypes->count() == 1 && $categoryProductTypes->first()->getId() == ProductType::PRODUCT_TYPE_ID_NOTEBOOK) {
  1824.                     $newBatteryProducts = $this->entityManager->getRepository(Product::class)->createQueryBuilder('p')
  1825.                         ->select('COUNT(p.id) as count')
  1826.                         ->innerJoin('p.tags', 't')
  1827.                         ->where('t.title = :newBattery')
  1828.                         ->setParameter('newBattery', 'New battery - Notebook')
  1829.                         ->getQuery()->getSingleScalarResult();
  1832.                     if ($newBatteryProducts > 0) {
  1833.                         $attributeFilters['newBattery'] = [
  1834.                             'id'      => 'newBattery',
  1835.                             'title'   => $this->translator->trans('New battery'),
  1836.                             'filter'  => '',
  1837.                             'options' => [
  1838.                                 [
  1839.                                     'id'        => 'newBattery',
  1840.                                     'title'     => $this->translator->trans('Yes'),
  1841.                                     "count"     => 0,
  1842.                                     'sortOrder' => 1,
  1843.                                 ],
  1844.                             ],
  1845.                         ];
  1846.                     }
  1847.                 }
  1848.             }
  1849.         }
  1850.         else if (isset($filter['isNewProductPage'])) {
  1851.             $categoryFilters = $this->getCategoryFilters($filter['language']);
  1852.         }
  1853.         else if (isset($options['search'])) {
  1854.             // Filter Attribute
  1855.             $filterAttribute = [];
  1857.             if (isset($filter['filterAttribute'])) {
  1858.                 $filterAttribute = $filter['filterAttribute'];
  1859.             }
  1861.             // Add Filter Quality
  1862.             $attribute = $this->entityManager->getRepository(Attribute::class)->findOneById(Attribute::ATTRIBUTE_ID_QUALITY);
  1863.             if ($attribute) {
  1864.                 $attributeFilter = $filterAttribute;
  1866.                 if (isset($attributeFilter[$attribute->getId()])) {
  1867.                     unset($attributeFilter[$attribute->getId()]);
  1868.                 }
  1870.                 $attributeFilters[$attribute->getId()] = [
  1871.                     'id'      => $attribute->getId(),
  1872.                     'title'   => $attribute->getTitle($this->translator),
  1873.                     'filter'  => $attributeFilter,
  1874.                     'options' => [],
  1875.                 ];
  1876.             }
  1877.         }
  1879.         $results = $this->getFilterListingResults($filter, $options);
  1880.         $priceMin = $priceMax = false;
  1881.         
  1882.         $productTypes ? $productTypesSet = true : $productTypesSet = false;
  1884.         if ($notebookShow) {
  1885.             //ADD TN display type
  1886.             $panelIds = $this->getTnDisplayAttributeOptionIds();
  1887.             if ($panelIds != '') {
  1888.                 $attributeFilters[Attribute::ATTRIBUTE_ID_DISPLAY_TECHNOLOGY]['options'][] = [
  1889.                     'id' => $panelIds,
  1890.                     'title' => 'TN',
  1891.                     'sortOrder' => 1,
  1892.                 ];
  1893.             }
  1894.         }
  1896.         /** @var Product $product */
  1897.         foreach ($results as $product) {
  1898.             $vendor = $product->getVendor();
  1900.             if ($vendor) {
  1901.                 if (!isset($vendors[$vendor->getId()])) {
  1902.                     $vendors[$vendor->getId()] = [
  1903.                         'id' => $vendor->getId(),
  1904.                         'name' => $vendor->getName(),
  1905.                         'count' => 0,
  1906.                         'sortOrder' => $vendor->getSortIndex(),
  1907.                     ];
  1908.                 }
  1909.             }
  1911.             $productType = $product->getType();
  1913.             if ($productType && isset($options['search'])) {
  1914.                 if (!isset($productTypes[$productType->getId()])) {
  1915.                     $productTypes[$productType->getId()] = [
  1916.                         'id' => $productType->getId(),
  1917.                         'name' => $productType->getTitle($this->translator),
  1918.                         'count' => 0,
  1919.                     ];
  1920.                 }
  1921.             }
  1923.             $productMeta = $product->getDomainMeta($this->priceDomain);
  1925.             if ($productMeta) {
  1926.                 $price = (float)$productMeta->getCurrentVatPrice();
  1928.                 if ($priceMin === false || $priceMax === false) {
  1929.                     $priceMin = $priceMax = $price;
  1930.                 }
  1932.                 if ($priceMin > $price) {
  1933.                     $priceMin = $price;
  1934.                 }
  1936.                 if ($priceMax < $price) {
  1937.                     $priceMax = $price;
  1938.                 }
  1939.             }
  1941.             if (!empty($attributeFilters)) {
  1942.                 $productAttributes = $product->getProductAttributes();
  1944.                 if ($productAttributes) {
  1945.                     /** @var ProductAttribute $productAttribute */
  1946.                     foreach ($productAttributes as $productAttribute) {
  1947.                         $option = $productAttribute->getOption();
  1948.                         $attribute = $option->getAttribute();
  1950.                         if (isset($attributeFilters[$attribute->getId()]) && isset($attributeFilters[$attribute->getId()]['filter'])) {
  1951.                             if (!isset($attributeFilters[$attribute->getId()]['options'][$option->getId()])) {
  1952.                                 $attributeFilter = $attributeFilters[$attribute->getId()]['filter'];
  1953.                                 $attributeFilter[$attribute->getId()] = $option->getId();
  1955.                                 $attributeFilters[$attribute->getId()]['options'][$option->getId()] = [
  1956.                                     'id' => $option->getId(),
  1957.                                     'title' => $option->getTitle($this->translator),
  1958.                                     'count' => 0,
  1959.                                     'sortOrder' => $option->getSortIndex(),
  1960.                                 ];
  1961.                             }
  1962.                         }
  1963.                     }
  1964.                 }
  1965.             }
  1966.         }
  1968.         if (!$productTypesSet && count($productTypes) < 2) {
  1969.             $productTypes = [];
  1970.         }
  1972.         $sortedVendors = [];
  1973.         if (!empty($vendors)) {
  1974.             //HP, DELL, LENOVO AND APPLE
  1975.             $mainVendors = [];
  1976.             $otherVendors = [];
  1978.             $mainNameHelper = [];
  1979.             $otherNameHelper = [];
  1980.             foreach ($vendors as $key => $row) {
  1981.                 if (in_array($key, Vendor::MAIN_NOTEBOOK_VENDOR_LIST) || in_array($key, explode(',', $filter['filterVendor']))) {
  1982.                     $mainVendors[$key] = $row;
  1983.                     $mainNameHelper[$key] = $row['name'];
  1984.                 } else {
  1985.                     $otherVendors[$key] = $row;
  1986.                     $otherNameHelper[$key] = $row['name'];
  1987.                 }
  1988.             }
  1989.             array_multisort($mainNameHelper, SORT_ASC, $mainVendors);
  1990.             array_multisort($otherNameHelper, SORT_ASC, $otherVendors);
  1993.             if ($notebookShow) {
  1994.                 $sortedVendors = [
  1995.                     'main' => $mainVendors,
  1996.                     'other' => $otherVendors,
  1997.                 ];
  1998.             } else {
  1999.                 $sortedVendors = array_merge($mainVendors, $otherVendors);
  2000.             }
  2001.         }
  2003.         if (!empty($productTypes)) {
  2004.             $name = [];
  2005.             foreach ($productTypes as $key => $row) {
  2006.                 $name[$key] = $row['name'];
  2007.             }
  2008.             array_multisort($name, SORT_ASC, $productTypes);
  2009.         }
  2011.         if (!empty($attributeFilters)) {
  2012.             foreach ($attributeFilters as $attributeId => $attribute) {
  2013.                 $sortOrder = [];
  2014.                 $options = $attribute['options'];
  2016.                 if (in_array($attributeId, [1, 12, 25, 45, 46, 63, 68, 141])) {
  2017.                     foreach ($options as $key => $value) {
  2018.                         $sortOrder[$key] = $value['title'];
  2019.                     }
  2020.                 } else {
  2021.                     foreach ($options as $key => $value) {
  2022.                         $sortOrder[$key] = $value['sortOrder'];
  2023.                     }
  2024.                 }
  2026.                 if ($attributeId == Attribute::ATTRIBUTE_ID_CPU_PC_FAMILY) {
  2027.                     array_multisort($sortOrder, SORT_DESC, $options);
  2028.                 } else {
  2029.                     array_multisort($sortOrder, SORT_ASC, $options);
  2030.                 }
  2032.                 if ($attributeId == Attribute::ATTRIBUTE_ID_CONF_NOTEBOOK_SKIN) {
  2033.                     $this->updateFilterOptionsWithThumbnails($options);
  2034.                 }
  2036.                 $attributeFilters[$attributeId]['options'] = $options;
  2037.             }
  2038.         }
  2040.         return [
  2041.             'list'         => in_array($filter['filterCategoryId'], CategoryPage::SALE_CATEGORY_PAGES) && !$useSalesFilters
  2042.                 ? ['main' => []]
  2043.                 : $this->buildFilterSections($productTypes, $categoryFilters, $sortedVendors, $attributeFilters, $filter, $notebookShow),
  2044.             'priceMin'     => floor($priceMin),
  2045.             'priceMax'     => ceil($priceMax),
  2046.             'cpuMarkMin'   => $filter['filterCpuMarkMin'] ?? null,
  2047.             'cpuMarkMax'   => $filter['filterCpuMarkMax'] ?? null,
  2048.             'notebookShow' => $notebookShow,
  2049.             'productTypes' => $productTypes,
  2050.         ];
  2051.     }
  2053.     /**
  2054.      * @param array $productTypes
  2055.      * @param array $categoryFilters
  2056.      * @param array $vendors
  2057.      * @param array $attributeFilters
  2058.      */
  2059.     private function buildFilterSections(array $productTypes, array $categoryFilters, array $vendors, array $attributeFilters, array $checkedFilterList, bool $notebookShow): array
  2060.     {
  2061.         $filterList = [];
  2063.         if (count($categoryFilters) > 0) {
  2064.             $filterList = [
  2065.                 'categoryFilters' => [
  2066.                     'sortOrder' => 0,
  2067.                     'collapseTitle' => 'Categories',
  2068.                     'templateId' => 'category',
  2069.                     'inputName' => 'category',
  2070.                     'checkedList' => $checkedFilterList['filterCategories'],
  2071.                     'isCollapsed' => false,
  2072.                     'filters' => $categoryFilters,
  2073.                 ],
  2074.             ];
  2075.         }
  2077.         $filterList[] = [
  2078.             'sortOrder' => 1,
  2079.             'collapseTitle' => 'Product type',
  2080.             'templateId' => 'productType',
  2081.             'inputName' => 'product-type',
  2082.             'checkedList' => $checkedFilterList['filterProductType'] ?? null,
  2083.             'isCollapsed' => false,
  2084.             'filters' => $productTypes,
  2085.         ];
  2087.         $filterList[] = [
  2088.             'sortOrder' => 2,
  2089.             'collapseTitle' => 'Brand',
  2090.             'templateId' => 'vendorFilter',
  2091.             'inputName' => 'vendor',
  2092.             'checkedList' => $checkedFilterList['filterVendor'],
  2093.             'isCollapsed' => false,
  2094.             'filters' => $vendors,
  2095.         ];
  2097.         $filterSorting = [
  2098.             $this->translator->trans('Categories')             => 0,
  2099.             $this->translator->trans('Product type')           => 1,
  2100.             $this->translator->trans('Brand')                  => 2,
  2101.             $this->translator->trans('Year of production')     => 3,
  2102.             $this->translator->trans('Quality')                => 4,
  2103.             $this->translator->trans('Operating system')       => 5,
  2104.             $this->translator->trans('Screen size')            => 6,
  2105.             $this->translator->trans('CPU mark')               => 7,
  2106.             $this->translator->trans('RAM size')               => 8,
  2107.             $this->translator->trans('SSD')                    => 9,
  2108.             $this->translator->trans('New battery')            => 10,
  2109.             $this->translator->trans('CPU NB FAMILY')          => 11,
  2110.             $this->translator->trans('Maximum resolution')     => 12,
  2111.             $this->translator->trans('Notebook skin')          => 13,
  2112.             $this->translator->trans('Touchscreen')            => 14,
  2113.             $this->translator->trans('Webcam')                 => 15,
  2114.             $this->translator->trans('Connectors external NB') => 16,
  2115.             $this->translator->trans('NumPad')                 => 17,
  2116.             $this->translator->trans('CPU Generation')         => 18,
  2117.             $this->translator->trans('VGA')                    => 19,
  2118.             $this->translator->trans('RAM NB type')            => 20,
  2119.             $this->translator->trans('Display Technology')     => 21,
  2120.             $this->translator->trans('ODD NB')                 => 22,
  2121.             $this->translator->trans('HDD 2,5"')               => 23,
  2122.             $this->translator->trans('Disk capacity')          => 24,
  2123.             $this->translator->trans('Contrast ratio')         => 25,
  2124.             $this->translator->trans('Keyboard language')      => 26,
  2125.         ];
  2127.         // Attribute Option Groups
  2128.         $attributeOptionGroups = AttributeOption::getAttributeOptionGroups();
  2130.         $count = 0;
  2131.         $sortOrderCount = count($filterSorting);
  2133.         foreach ($attributeFilters as $attributeFilter) {
  2134.             $count++;
  2135.             $extraInfo = null;
  2136.             $customCountToShow = null;
  2138.             if (!isset($attributeFilter['id'])){
  2139.                 continue;
  2140.             }
  2142.             $filterOptions = in_array($attributeFilter['id'], [141, 142]) //142 == CPU NB FAMILY
  2143.                 ? array_reverse($attributeFilter['options'])
  2144.                 : $attributeFilter['options'];
  2146.             if ($notebookShow) {
  2147.                 //Screen size
  2148.                 if ($attributeFilter['id'] == Attribute::ATTRIBUTE_ID_SCREEN_SIZE) {
  2149.                     //NE TOROLD KI A SPACEKETE AZ IDNEL " "
  2150.                     $screenSizeFilter = [
  2151.                         0 => [
  2152.                             'title' => 'filterTranslation.screenSize.small',
  2153.                             'id' => ' ',
  2154.                         ],
  2155.                         1 => [
  2156.                             'title' => 'filterTranslation.screenSize.medium',
  2157.                             'id' => ' ',
  2158.                         ],
  2159.                         2 => [
  2160.                             'title' => 'filterTranslation.screenSize.big',
  2161.                             'id' => ' ',
  2162.                         ],
  2163.                     ];
  2164.                     foreach ($filterOptions as $option) {
  2165.                         preg_match('/\d+,\d+"/', $option['title'], $matches);
  2166.                         if (!empty($matches)) {
  2167.                             $screenSize = (float)str_replace(',', '.', $matches[0]);
  2168.                             if ($screenSize < 13) {
  2169.                                 $screenSizeFilter[0]['id'] .= $option['id'] . ',';
  2170.                             } elseif ($screenSize < 15) {
  2171.                                 $screenSizeFilter[1]['id'] .= $option['id'] . ',';
  2172.                             } else {
  2173.                                 $screenSizeFilter[2]['id'] .= $option['id'] . ',';
  2174.                             }
  2175.                         }
  2176.                     }
  2179.                     // Remove trailing commas from screen size filters
  2180.                     $screenSizeFilter[0]['id'] = rtrim($screenSizeFilter[0]['id'], ',');
  2181.                     $screenSizeFilter[1]['id'] = rtrim($screenSizeFilter[1]['id'], ',');
  2182.                     $screenSizeFilter[2]['id'] = rtrim($screenSizeFilter[2]['id'], ',');
  2184.                     $filterOptions = $screenSizeFilter;
  2185.                 }
  2187.                 //Ram size
  2188.                 if ($attributeFilter['id'] == Attribute::ATTRIBUTE_ID_RAM_SIZE) {
  2189.                     //NE TOROLD KI A SPACEKETE AZ IDNEL " "
  2190.                     $ramSizeFilter = [
  2191.                         0 => [
  2192.                             'title' => 'filterTranslation.ramSize.small',
  2193.                             'id' => ' ',
  2194.                         ],
  2195.                         1 => [
  2196.                             'title' => '8GB',
  2197.                             'id' => ' ',
  2198.                         ],
  2199.                         2 => [
  2200.                             'title' => '16GB',
  2201.                             'id' => ' ',
  2202.                         ],
  2203.                         3 => [
  2204.                             'title' => 'filterTranslation.ramSize.big',
  2205.                             'id' => ' ',
  2206.                         ],
  2207.                     ];
  2208.                     foreach ($filterOptions as $option) {
  2209.                         preg_match('/\d+GB/', $option['title'], $matches);
  2210.                         if (!empty($matches)) {
  2211.                             $ramSize = (int)$matches[0];
  2212.                             if ($ramSize < 8) {
  2213.                                 $ramSizeFilter[0]['id'] .= $option['id'] . ',';
  2214.                             } elseif ($ramSize < 16) {
  2215.                                 $ramSizeFilter[1]['id'] .= $option['id'] . ',';
  2216.                             } elseif ($ramSize == 16) {
  2217.                                 $ramSizeFilter[2]['id'] .= $option['id'] . ',';
  2218.                             } else {
  2219.                                 $ramSizeFilter[3]['id'] .= $option['id'] . ',';
  2220.                             }
  2221.                         }
  2222.                     }
  2224.                     $ramSizeFilter[0]['id'] = rtrim($ramSizeFilter[0]['id'], ',');
  2225.                     $ramSizeFilter[1]['id'] = rtrim($ramSizeFilter[1]['id'], ',');
  2226.                     $ramSizeFilter[2]['id'] = rtrim($ramSizeFilter[2]['id'], ',');
  2228.                     $filterOptions = $ramSizeFilter;
  2229.                 }
  2231.                 //SSD size
  2232.                 if ($attributeFilter['id'] == Attribute::ATTRIBUTE_ID_SSD) {
  2233.                     //NE TOROLD KI A SPACEKETE AZ IDNEL " "
  2234.                     $ssdSizeFilter = [
  2235.                         0 => [
  2236.                             'title' => 'filterTranslation.ssdSize.small',
  2237.                             'id' => ' ',
  2238.                         ],
  2239.                         1 => [
  2240.                             'title' => 'filterTranslation.ssdSize.normal',
  2241.                             'id' => ' ',
  2242.                         ],
  2243.                         2 => [
  2244.                             'title' => 'filterTranslation.ssdSize.medium',
  2245.                             'id' => ' ',
  2246.                         ],
  2247.                         3 => [
  2248.                             'title' => 'filterTranslation.ssdSize.big',
  2249.                             'id' => ' ',
  2250.                         ],
  2251.                     ];
  2252.                     foreach ($filterOptions as $option) {
  2253.                         preg_match('/\d+GB/', $option['title'], $matches);
  2254.                         if (!empty($matches)) {
  2255.                             $ssdSize = (int)$matches[0];
  2256.                             if ($ssdSize < 240) {
  2257.                                 $ssdSizeFilter[0]['id'] .= $option['id'] . ',';
  2258.                             } elseif ($ssdSize <= 256) {
  2259.                                 $ssdSizeFilter[1]['id'] .= $option['id'] . ',';
  2260.                             } elseif ($ssdSize <= 512) {
  2261.                                 $ssdSizeFilter[2]['id'] .= $option['id'] . ',';
  2262.                             } else {
  2263.                                 $ssdSizeFilter[3]['id'] .= $option['id'] . ',';
  2264.                             }
  2265.                         } else {
  2266.                             preg_match('/\d+TB/', $option['title'], $matches);
  2268.                             if (!empty($matches)) {
  2269.                                 $ssdSizeFilter[3]['id'] .= $option['id'] . ',';
  2270.                             }
  2271.                         }
  2272.                     }
  2274.                     $ssdSizeFilter[0]['id'] = rtrim($ssdSizeFilter[0]['id'], ',');
  2275.                     $ssdSizeFilter[1]['id'] = rtrim($ssdSizeFilter[1]['id'], ',');
  2276.                     $ssdSizeFilter[2]['id'] = rtrim($ssdSizeFilter[2]['id'], ',');
  2277.                     $ssdSizeFilter[3]['id'] = rtrim($ssdSizeFilter[2]['id'], ',');
  2279.                     $filterOptions = $ssdSizeFilter;
  2280.                 }
  2282.                 //QUALITY sorting + info text
  2283.                 if ($attributeFilter['id'] == Attribute::ATTRIBUTE_ID_QUALITY) {
  2284.                     usort($filterOptions, function ($a, $b) {
  2285.                         return $a['id'] <=> $b['id'];
  2286.                     });
  2288.                     switch ($this->localeDomainId) {
  2289.                         case Domain::DOMAIN_ID_RT_HU:
  2290.                         case Domain::DOMAIN_ID_WS_HU:
  2291.                             $pageId = 27;
  2292.                             break;
  2293.                         case Domain::DOMAIN_ID_RT_SK:
  2294.                         case Domain::DOMAIN_ID_WS_SK:
  2295.                             $pageId = 11;
  2296.                             break;
  2297.                         case Domain::DOMAIN_ID_RT_CZ:
  2298.                         case Domain::DOMAIN_ID_WS_CZ:
  2299.                             $pageId = 60;
  2300.                             break;
  2301.                         case Domain::DOMAIN_ID_RT_EU:
  2302.                         case Domain::DOMAIN_ID_WS_EU:
  2303.                         case Domain::DOMAIN_ID_B2C_EU:
  2304.                             $pageId = 100;
  2305.                             break;
  2306.                     }
  2308.                     $extraInfo = [
  2309.                         'transKey' => 'filterExtraInfos.quality',
  2310.                         'url' => $this->router->generate('page_show', [
  2311.                             'pageId' => $pageId,
  2312.                         ], UrlGeneratorInterface::ABSOLUTE_URL),
  2313.                     ];
  2314.                 }
  2316.                 //Notebook skin remove and replace with custom hint text
  2317.                 if ($attributeFilter['id'] == Attribute::ATTRIBUTE_ID_CONF_NOTEBOOK_SKIN) {
  2318.                     $filterOptions = [];
  2319.                     $extraInfo = [
  2320.                         'transKey' => 'filterExtraInfos.colors',
  2321.                     ];
  2322.                 }
  2324.                 if ($attributeFilter['id'] == Attribute::ATTRIBUTE_ID_TOUCH_SCREEN) {
  2325.                     $touchScreenFilter = [
  2326.                         [
  2327.                             'id' => AttributeOption::ATTRIBUTE_OPTION_TOUCHSCREEN,
  2328.                             'title' => 'yes',
  2329.                         ],
  2330.                     ];
  2331.                     $filterOptions = $touchScreenFilter;
  2332.                 }
  2334.                 if ($attributeFilter['id'] == Attribute::ATTRIBUTE_ID_WEBCAM) {
  2335.                     $webcamIds = '';
  2336.                     foreach ($filterOptions as $option) {
  2337.                         if ($option['id'] != AttributeOption::ATTRIBUTE_OPTION_NO_WEBCAM) {
  2338.                             $webcamIds .= $option['id'] . ',';
  2339.                         }
  2340.                     }
  2342.                     $webcamIds = rtrim($webcamIds, ',');
  2344.                     $webcamFilter = [
  2345.                         [
  2346.                             'id'    => $webcamIds,
  2347.                             'title' => 'yes',
  2348.                         ],
  2349.                         [
  2350.                             'id'    => AttributeOption::ATTRIBUTE_OPTION_NO_WEBCAM,
  2351.                             'title' => 'no',
  2352.                         ],
  2353.                     ];
  2355.                     $filterOptions = $webcamFilter;
  2356.                 }
  2358.                 //Remove the keyboard languages from the filter
  2359.                 if ($attributeFilter['id'] == Attribute::ATTRIBUTE_ID_KEYBOARD_LANGUAGE) {
  2360.                     $filterOptions = [];
  2361.                 }
  2363.                 if ($attributeFilter['id'] == Attribute::ATTRIBUTE_ID_EXTERNAL_CONNECTORS) {
  2364.                     $connectorsFilter = [];
  2365.                     $textToFinc = [
  2366.                         'HDMI',
  2367.                         'VGA',
  2368.                         'Display port',
  2369.                         'Thunderbolt',
  2370.                         'USB 2',
  2371.                         'USB 3',
  2372.                         'USB Type-C',
  2373.                         'RJ45 (LAN)',
  2374.                     ];
  2376.                     foreach ($filterOptions as $option) {
  2377.                         foreach ($textToFinc as $key => $title) {
  2378.                             //option title contains the title
  2379.                             if (str_contains(strtoupper($option['title']), strtoupper($title))) {
  2380.                                 if (!isset($connectorsFilter[$key])) {
  2381.                                     $connectorsFilter[$key] = [
  2382.                                         'id' => $option['id'],
  2383.                                         'title' => $title,
  2384.                                     ];
  2385.                                 } else {
  2386.                                     $connectorsFilter[$key]['id'] .= ',' . $option['id'];
  2387.                                 }
  2388.                             }
  2389.                         }
  2390.                     }
  2392.                     ksort($connectorsFilter);
  2393.                     $filterOptions = $connectorsFilter;
  2394.                 }
  2396.                 if ($attributeFilter['id'] == Attribute::ATTRIBUTE_ID_NUMPAD) {
  2397.                     $numpadFilter = [
  2398.                         [
  2399.                             'id' => AttributeOption::ATTRIBUTE_OPTION_NUMPAD,
  2400.                             'title' => 'yes',
  2401.                         ], [
  2402.                             'id' => AttributeOption::ATTRIBUTE_OPTION_NO_NUMPAD,
  2403.                             'title' => 'no',
  2404.                         ],
  2405.                     ];
  2407.                     $filterOptions = $numpadFilter;
  2408.                 }
  2410.                 if ($attributeFilter['id'] == Attribute::ATTRIBUTE_ID_DISPLAY_TECHNOLOGY) {
  2411.                     $order = ['TN', 'IPS', 'OLED'];
  2413.                     usort($filterOptions, function ($a, $b) use ($order) {
  2414.                         return array_search($a['title'], $order) <=> array_search($b['title'], $order);
  2415.                     });
  2416.                 }
  2418.                 if ($attributeFilter['id'] == Attribute::ATTRIBUTE_ID_OPTICAL_DRIVER) {
  2419.                     $opticalDriverIdString = ' ';
  2420.                     foreach ($filterOptions as $option) {
  2421.                         if ($option['id'] != AttributeOption::ATTRIBUTE_OPTION_NO_OOD) {
  2422.                             $opticalDriverIdString .= $option['id'] . ',';
  2423.                         }
  2424.                     }
  2426.                     $opticalDriverIdString = rtrim($opticalDriverIdString, ',');
  2427.                     $opticalDriverFilter = [
  2428.                         [
  2429.                             'id' => $opticalDriverIdString,
  2430.                             'title' => 'yes',
  2431.                         ], [
  2432.                             'id' => AttributeOption::ATTRIBUTE_OPTION_NO_OOD,
  2433.                             'title' => 'no',
  2434.                         ],
  2435.                     ];
  2437.                     $filterOptions = $opticalDriverFilter;
  2438.                 }
  2440.                 if ($attributeFilter['id'] == Attribute::ATTRIBUTE_ID_VGA) {
  2441.                     //NE TOROLD KI A SPACEKETE AZ IDNEL " "
  2442.                     $vgaFilter = [
  2443.                         [
  2444.                             'id' => ' ',
  2445.                             'title' => 'filterTranslation.vga.integrated',
  2446.                         ], [
  2447.                             'id' => ' ',
  2448.                             'title' => 'filterTranslation.vga.gaming',
  2449.                         ], [
  2450.                             'id' => ' ',
  2451.                             'title' => 'filterTranslation.vga.graphic',
  2452.                         ],
  2453.                     ];
  2455.                     foreach ($filterOptions as $option) {
  2456.                         //Gaming
  2457.                         if (str_contains(strtoupper($option['title']), 'RTX')
  2458.                             || str_contains(strtoupper($option['title']), 'GTX')
  2459.                             || str_contains(strtoupper($option['title']), 'GT')) {
  2460.                             $vgaFilter[1]['id'] .= ',' . $option['id'];
  2461.                         }
  2462.                         //Graphic
  2463.                         elseif (str_contains(strtoupper($option['title']), 'QUADRO')
  2464.                             || str_contains(strtoupper($option['title']), 'FIREPRO')) {
  2465.                             $vgaFilter[2]['id'] .= ',' . $option['id'];
  2466.                             //Other
  2467.                         } else {
  2468.                             $vgaFilter[0]['id'] .= ',' . $option['id'];
  2469.                         }
  2470.                     }
  2472.                     $filterOptions = $vgaFilter;
  2473.                 }
  2475.                 if ($attributeFilter['id'] == Attribute::ATTRIBUTE_ID_YEAR_OF_PRODUCTION) {
  2476.                     $yearFilter = [
  2477.                         [
  2478.                             'id' => $this->getAttributeOptionIdsBasedOnTheAge(self::AGE_0_to_2_YEARS),
  2479.                             'title' => '0-2',
  2480.                         ], [
  2481.                             'id' => $this->getAttributeOptionIdsBasedOnTheAge(self::AGE_3_to_5_YEARS),
  2482.                             'title' => '3-5',
  2483.                         ], [
  2484.                             'id' => $this->getAttributeOptionIdsBasedOnTheAge(self::AGE_6_PLUS_YEARS),
  2485.                             'title' => '6+',
  2486.                         ],
  2487.                     ];
  2489.                     $filterOptions = $yearFilter;
  2490.                 }
  2492.                 if ($attributeFilter['id'] == Attribute::ATTRIBUTE_ID_ACCESSORY_OS) {
  2493.                     $osFilter = [
  2494.                         1 => [
  2495.                             'title' => 'Windows 11',
  2496.                             'id' => ' ',
  2497.                         ],
  2498.                         0 => [
  2499.                             'title' => 'Windows 10',
  2500.                             'id' => ' ',
  2501.                         ],
  2502.                         2 => [
  2503.                             'title' => 'Mac OS',
  2504.                             'id' => ' ',
  2505.                         ],
  2506.                     ];
  2508.                     foreach ($filterOptions as $option) {
  2509.                         if (str_contains(strtoupper($option['title']), 'WINDOWS 10')) {
  2510.                             $osFilter[0]['id'] .= $option['id'] . ',';
  2511.                         } elseif (str_contains(strtoupper($option['title']), 'WINDOWS 11')) {
  2512.                             $osFilter[1]['id'] .= $option['id'] . ',';
  2513.                         } elseif (str_contains(strtoupper($option['title']), 'MAC OS') || str_contains(strtoupper($option['title']), 'MACOS')) {
  2514.                             $osFilter[2]['id'] .= $option['id'] . ',';
  2515.                         }
  2516.                     }
  2518.                     $osFilter[0]['id'] = rtrim($osFilter[0]['id'], ',');
  2519.                     $osFilter[1]['id'] = rtrim($osFilter[1]['id'], ',');
  2520.                     $osFilter[2]['id'] = rtrim($osFilter[2]['id'], ',');
  2522.                     $filterOptions = $osFilter;
  2523.                 }
  2525.                 if ($attributeFilter['id'] == Attribute::ATTRIBUTE_ID_MAXIMUM_RESOLUTION) {
  2526.                     $resolutionFilter = [
  2527.                         0 => [
  2528.                             'title' => 'filterTranslation.resolution.small',
  2529.                             'id' => ' ',
  2530.                         ],
  2531.                         1 => [
  2532.                             'title' => 'filterTranslation.resolution.fullHd',
  2533.                             'id' => ' ',
  2534.                         ],
  2535.                         2 => [
  2536.                             'title' => 'filterTranslation.resolution.big',
  2537.                             'id' => ' ',
  2538.                         ],
  2539.                     ];
  2540.                     foreach ($filterOptions as $option) {
  2541.                         if (preg_match('/(\d+)\s*x/', $option['title'], $matches)) {
  2542.                             $numberBeforeX = $matches[1];
  2544.                             if ($numberBeforeX < 1920) {
  2545.                                 $resolutionFilter[0]['id'] .= $option['id'] . ',';
  2546.                             } elseif ($numberBeforeX == 1920) {
  2547.                                 if (preg_match('/x\s*(\d+)/', $option['title'], $matches)) {
  2548.                                     $numberAfterX = $matches[1];
  2549.                                     if (in_array($numberAfterX, [1080, 1200])) {
  2550.                                         $resolutionFilter[1]['id'] .= $option['id'] . ',';
  2551.                                     } else {
  2552.                                         $resolutionFilter[2]['id'] .= $option['id'] . ',';
  2553.                                     }
  2554.                                 }
  2555.                             } else {
  2556.                                 $resolutionFilter[2]['id'] .= $option['id'] . ',';
  2557.                             }
  2558.                         }
  2559.                     }
  2561.                     $resolutionFilter[0]['id'] = rtrim($resolutionFilter[0]['id'], ',');
  2562.                     $resolutionFilter[1]['id'] = rtrim($resolutionFilter[1]['id'], ',');
  2563.                     $resolutionFilter[2]['id'] = rtrim($resolutionFilter[2]['id'], ',');
  2565.                     $customCountToShow = 3;
  2567.                     $filterOptions = array_merge($resolutionFilter, $filterOptions);
  2568.                 }
  2570.                 if ($attributeFilter['id'] == Attribute::ATTRIBUTE_ID_CPU_MARK) {
  2572.                     $pageId = match ($this->localeDomain->getId()) {
  2573.                         Domain::DOMAIN_ID_RT_HU, Domain::DOMAIN_ID_WS_HU => 175,
  2574.                         Domain::DOMAIN_ID_RT_SK, Domain::DOMAIN_ID_WS_SK => 176,
  2575.                         Domain::DOMAIN_ID_RT_CZ, Domain::DOMAIN_ID_WS_CZ => 177,
  2576.                         Domain::DOMAIN_ID_RT_EU, Domain::DOMAIN_ID_WS_EU => 178,
  2577.                     };
  2579.                     $extraInfo = [
  2580.                         'transKey' => 'filterExtraInfos.cpu_mark',
  2581.                         'url' => $this->router->generate('page_show', [
  2582.                             'pageId' => $pageId,
  2583.                         ], UrlGeneratorInterface::ABSOLUTE_URL),
  2584.                     ];
  2585.                 }
  2586.             }
  2587.             else {
  2588.                 // Merge option rows
  2589.                 if (isset($attributeOptionGroups[$attributeFilter['id']])) {
  2590.                     foreach ($attributeOptionGroups[$attributeFilter['id']] as $group) {
  2591.                         $countItems = 0;
  2592.                         $affectedAttributeOptions = [];
  2594.                         foreach ($attributeFilter['options'] as $key => $option) {
  2595.                             if (in_array($option['id'], $group)) {
  2596.                                 $affectedAttributeOptions[(int)$option['id']] = $key;
  2598.                                 $countItems += (int)$option['count'];
  2599.                             }
  2600.                         }
  2602.                         foreach ($group as $optionId) {
  2603.                             if (isset($affectedAttributeOptions[$optionId])) {
  2604.                                 unset($affectedAttributeOptions[$optionId]);
  2606.                                 $filterOptions[$key]['count'] = $countItems;
  2608.                                 break;
  2609.                             }
  2610.                         }
  2612.                         foreach ($affectedAttributeOptions as $key) {
  2613.                             unset($filterOptions[$key]);
  2614.                         }
  2615.                     }
  2616.                 }
  2617.             }
  2619.             // 5 = SSD, 12 = Screen, 384 = Ram, 101 = Quality, 139 = Touchscreen, 19 = Webcam, 45 = Connectors, 118 = DisplayTechnology,
  2620.             // 11 = OpticalDriver, 25 = VGA, 17 = Numpad, 21 = OperationSystem, 63 = MaxResolution
  2621.             $skipShortingIds = $notebookShow
  2622.                 ? [5, 3, 9, 4, 12, 384, 101, 139, 19, 45, 118, 11, 25, 17, 21, 63]
  2623.                 : [5, 3, 9, 4, 101];
  2625.             if (!in_array($attributeFilter['id'], $skipShortingIds)) {
  2626.                 $filterOptions = $this->orderArrayBy($filterOptions, 'title');
  2627.             }
  2629.             switch ($attributeFilter['id']) {
  2630.                 case Attribute::ATTRIBUTE_ID_CPU_GENERATION:
  2631.                     $filterOptions = $this->orderArrayBy($filterOptions, 'sortOrder');
  2632.                     break;
  2633.                 case Attribute::ATTRIBUTE_ID_RAM_SIZE:
  2634.                     if (!$notebookShow) {
  2635.                         $filterOptions = $this->orderArrayBy($filterOptions, 'title', 'GB');
  2636.                     }
  2637.                     break;
  2638.             }
  2640.             $checkedList = $checkedFilterList['filterAttribute'] && array_key_exists($attributeFilter['id'], $checkedFilterList['filterAttribute'])
  2641.                 ? $checkedFilterList['filterAttribute'][$attributeFilter['id']]
  2642.                 : '';
  2644.             if (in_array($attributeFilter['id'], [
  2645.                 Attribute::ATTRIBUTE_ID_RAM_NB_TYPE,
  2646.                 ])) {
  2647.                 $collapsed = true;
  2649.             } elseif (in_array($attributeFilter['id'], [
  2650.                 Attribute::ATTRIBUTE_ID_YEAR_OF_PRODUCTION,
  2651.                 Attribute::ATTRIBUTE_ID_SCREEN_SIZE,
  2652.                 Attribute::ATTRIBUTE_ID_CPU_MARK,
  2653.                 Attribute::ATTRIBUTE_ID_ACCESSORY_OS,
  2654.                 'newBattery',
  2655.             ])) {
  2656.                 $collapsed = false;
  2658.             } else {
  2659.                 $collapsed = ($count > 5 && $checkedList == '' && $attributeFilter['id'] != Attribute::ATTRIBUTE_ID_SSD);
  2660.             }
  2662.             $filterList[] = [
  2663.                 'sortOrder' => isset($filterSorting[$attributeFilter['title']]) ? $filterSorting[$attributeFilter['title']] : $sortOrderCount++,
  2664.                 'filterId' => $attributeFilter['id'],
  2665.                 'collapseTitle' => $attributeFilter['title'],
  2666.                 'templateId' => 'attributeFilter-' . $attributeFilter['id'],
  2667.                 'inputName' => $attributeFilter['id'] == Attribute::ATTRIBUTE_ID_CPU_MARK ? 'CPU mark' : 'attribute',
  2668.                 'checkedList' => $checkedList,
  2669.                 'isCollapsed' => $collapsed,
  2670.                 'filters' => $filterOptions,
  2671.                 'extraInfo' => $extraInfo,
  2672.                 'customCountToShow' => $customCountToShow,
  2673.             ];
  2675.             if ($attributeFilter['id'] == Attribute::ATTRIBUTE_ID_HDD_25) {
  2676.                 $filterList[key(array_slice($filterList, -1, 1, true))]['collapseTitle'] = "HDD";
  2677.             }
  2678.         }
  2680.         if ($notebookShow) {
  2681.             usort($filterList, function ($a, $b) {
  2682.                 return $a['sortOrder'] <=> $b['sortOrder'];
  2683.             });
  2684.         }
  2686.         return [
  2687.             'main' => $filterList,
  2688.         ];
  2689.     }
  2691.     /**
  2692.      * @param array $items
  2693.      * @param string $attr
  2694.      * @param string $textToRemove
  2695.      * @param string $order
  2696.      * @return array
  2697.      */
  2698.     private function orderArrayBy(array $items, string $attr, string $textToRemove = '', string $order = 'asc'): array
  2699.     {
  2700.         $sortedItems = [];
  2702.         foreach ($items as $item) {
  2703.             $key = is_object($item) ? str_replace($textToRemove, '', $item->{$attr}) : str_replace($textToRemove, '', $item[$attr]);
  2705.             $sortedItems[$key] = $item;
  2706.         }
  2708.         if ($order === 'desc') {
  2709.             krsort($sortedItems);
  2710.         } else {
  2711.             ksort($sortedItems);
  2712.         }
  2714.         return array_values($sortedItems);
  2715.     }
  2717.     /**
  2718.      * @param array &$filterOptions
  2719.      */
  2720.     private function updateFilterOptionsWithThumbnails(array &$filterOptions): void
  2721.     {
  2722.         $filterOptionIds = array_column($filterOptions, 'id');
  2724.         $attributeOptions = $this->entityManager->getRepository(AttributeOption::class)->findBy([
  2725.             'id' => $filterOptionIds,
  2726.         ]);
  2728.         /**
  2729.          * @var AttributeOption $attributeOption
  2730.          */
  2731.         foreach ($attributeOptions as $key => $attributeOption) {
  2732.             if ($attributeOption->getProduct() != null) {
  2733.                 $filterOptions[$key]['thumb'] = $this->getImage($attributeOption->getProduct()->getAlbum()->getNthPhoto(), 'product/' . $attributeOption->getProduct()->getCode())->resize(Image::PRODUCT_LIST_THUMB_WIDTH, Image::PRODUCT_LIST_THUMB_HEIGHT);
  2734.             }
  2735.         }
  2736.     }
  2738.     /**
  2739.      * @param string $language
  2740.      * @return array
  2741.      */
  2742.     private function getCategoryFilters(string $language): array
  2743.     {
  2744.         // Translator
  2745.         $translator = $this->translator;
  2747.         // Filter Categories
  2748.         $categoryFilters = [];
  2750.         switch ($this->multiStore->getDefaultLocale()) {
  2751.             case 'sk':
  2752.                 $categoryFilters = [
  2753.                     CategoryPage::SK_CATEGORYPAGE_ID_PC => [
  2754.                         'id' => CategoryPage::SK_CATEGORYPAGE_ID_PC,
  2755.                         'name' => $translator->trans('Computers'),
  2756.                     ],
  2757.                     CategoryPage::SK_CATEGORYPAGE_ID_NOTEBOOK => [
  2758.                         'id' => CategoryPage::SK_CATEGORYPAGE_ID_NOTEBOOK,
  2759.                         'name' => $translator->trans('Notebooks'),
  2760.                     ],
  2761.                     CategoryPage::SK_CATEGORYPAGE_ID_MONITOR => [
  2762.                         'id' => CategoryPage::SK_CATEGORYPAGE_ID_MONITOR,
  2763.                         'name' => $translator->trans('Monitors'),
  2764.                     ],
  2765.                     CategoryPage::SK_CATEGORYPAGE_ID_MOBIL => [
  2766.                         'id' => CategoryPage::SK_CATEGORYPAGE_ID_MOBIL,
  2767.                         'name' => $translator->trans('Smartphones'),
  2768.                     ],
  2769.                     CategoryPage::SK_CATEGORYPAGE_ID_TABLET => [
  2770.                         'id' => CategoryPage::SK_CATEGORYPAGE_ID_TABLET,
  2771.                         'name' => 'Tablet',
  2772.                     ],
  2773.                     CategoryPage::SK_CATEGORYPAGE_ID_SMARTWATCH => [
  2774.                         'id' => CategoryPage::SK_CATEGORYPAGE_ID_SMARTWATCH,
  2775.                         'name' => 'Smartwatch',
  2776.                     ],
  2777.                     CategoryPage::SK_CATEGORYPAGE_ID_ELECTRIC_SCOOTER => [
  2778.                         'id' => CategoryPage::SK_CATEGORYPAGE_ID_ELECTRIC_SCOOTER,
  2779.                         'name' => $translator->trans('Electric scooters'),
  2780.                     ],
  2781.                 ];
  2782.                 break;
  2783.             case 'hu':
  2784.                 $categoryFilters = [
  2785.                     CategoryPage::HU_CATEGORYPAGE_ID_PC => [
  2786.                         'id' => CategoryPage::HU_CATEGORYPAGE_ID_PC,
  2787.                         'name' => $translator->trans('Computers'),
  2788.                     ],
  2789.                     CategoryPage::HU_CATEGORYPAGE_ID_NOTEBOOK => [
  2790.                         'id' => CategoryPage::HU_CATEGORYPAGE_ID_NOTEBOOK,
  2791.                         'name' => $translator->trans('Notebooks'),
  2792.                     ],
  2793.                     CategoryPage::HU_CATEGORYPAGE_ID_MONITOR => [
  2794.                         'id' => CategoryPage::HU_CATEGORYPAGE_ID_MONITOR,
  2795.                         'name' => $translator->trans('Monitors'),
  2796.                     ],
  2797.                     CategoryPage::HU_CATEGORYPAGE_ID_MOBIL => [
  2798.                         'id' => CategoryPage::HU_CATEGORYPAGE_ID_MOBIL,
  2799.                         'name' => $translator->trans('Smartphones'),
  2800.                     ],
  2801.                     CategoryPage::HU_CATEGORYPAGE_ID_TABLET => [
  2802.                         'id' => CategoryPage::HU_CATEGORYPAGE_ID_TABLET,
  2803.                         'name' => 'Tablet',
  2804.                     ],
  2805.                     CategoryPage::HU_CATEGORYPAGE_ID_SMARTWATCH => [
  2806.                         'id' => CategoryPage::HU_CATEGORYPAGE_ID_SMARTWATCH,
  2807.                         'name' => 'Smartwatch',
  2808.                     ],
  2809.                     CategoryPage::HU_CATEGORYPAGE_ID_ELECTRIC_SCOOTER => [
  2810.                         'id' => CategoryPage::HU_CATEGORYPAGE_ID_ELECTRIC_SCOOTER,
  2811.                         'name' => $translator->trans('Electric scooters'),
  2812.                     ],
  2813.                 ];
  2814.                 break;
  2815.             case 'cz':
  2816.                 $categoryFilters = [
  2817.                     CategoryPage::CZ_CATEGORYPAGE_ID_PC => [
  2818.                         'id' => CategoryPage::CZ_CATEGORYPAGE_ID_PC,
  2819.                         'name' => $translator->trans('Computers'),
  2820.                     ],
  2821.                     CategoryPage::CZ_CATEGORYPAGE_ID_NOTEBOOK => [
  2822.                         'id' => CategoryPage::CZ_CATEGORYPAGE_ID_NOTEBOOK,
  2823.                         'name' => $translator->trans('Notebooks'),
  2824.                     ],
  2825.                     CategoryPage::CZ_CATEGORYPAGE_ID_MONITOR => [
  2826.                         'id' => CategoryPage::CZ_CATEGORYPAGE_ID_MONITOR,
  2827.                         'name' => $translator->trans('Monitors'),
  2828.                     ],
  2829.                     CategoryPage::CZ_CATEGORYPAGE_ID_MOBIL => [
  2830.                         'id' => CategoryPage::CZ_CATEGORYPAGE_ID_MOBIL,
  2831.                         'name' => $translator->trans('Smartphones'),
  2832.                     ],
  2833.                     CategoryPage::CZ_CATEGORYPAGE_ID_TABLET => [
  2834.                         'id' => CategoryPage::CZ_CATEGORYPAGE_ID_TABLET,
  2835.                         'name' => 'Tablet',
  2836.                     ],
  2837.                     CategoryPage::CZ_CATEGORYPAGE_ID_SMARTWATCH => [
  2838.                         'id' => CategoryPage::CZ_CATEGORYPAGE_ID_SMARTWATCH,
  2839.                         'name' => 'Smartwatch',
  2840.                     ],
  2841.                     CategoryPage::CZ_CATEGORYPAGE_ID_ELECTRIC_SCOOTER => [
  2842.                         'id' => CategoryPage::CZ_CATEGORYPAGE_ID_ELECTRIC_SCOOTER,
  2843.                         'name' => $translator->trans('Electric scooters'),
  2844.                     ],
  2845.                 ];
  2846.                 break;
  2847.             case 'en':
  2848.                 $categoryFilters = [
  2849.                     CategoryPage::EU_CATEGORYPAGE_ID_PC => [
  2850.                         'id' => CategoryPage::EU_CATEGORYPAGE_ID_PC,
  2851.                         'name' => $translator->trans('Computers'),
  2852.                     ],
  2853.                     CategoryPage::EU_CATEGORYPAGE_ID_NOTEBOOK => [
  2854.                         'id' => CategoryPage::EU_CATEGORYPAGE_ID_NOTEBOOK,
  2855.                         'name' => $translator->trans('Notebooks'),
  2856.                     ],
  2857.                     CategoryPage::EU_CATEGORYPAGE_ID_MONITOR => [
  2858.                         'id' => CategoryPage::EU_CATEGORYPAGE_ID_MONITOR,
  2859.                         'name' => $translator->trans('Monitors'),
  2860.                     ],
  2861.                     CategoryPage::EU_CATEGORYPAGE_ID_MOBIL => [
  2862.                         'id' => CategoryPage::EU_CATEGORYPAGE_ID_MOBIL,
  2863.                         'name' => $translator->trans('Smartphones'),
  2864.                     ],
  2865.                     CategoryPage::EU_CATEGORYPAGE_ID_TABLET => [
  2866.                         'id' => CategoryPage::EU_CATEGORYPAGE_ID_TABLET,
  2867.                         'name' => 'Tablet',
  2868.                     ],
  2869.                     CategoryPage::EU_CATEGORYPAGE_ID_SMARTWATCH => [
  2870.                         'id' => CategoryPage::EU_CATEGORYPAGE_ID_SMARTWATCH,
  2871.                         'name' => 'Smartwatch',
  2872.                     ],
  2873.                     CategoryPage::EU_CATEGORYPAGE_ID_ELECTRIC_SCOOTER => [
  2874.                         'id' => CategoryPage::EU_CATEGORYPAGE_ID_ELECTRIC_SCOOTER,
  2875.                         'name' => $translator->trans('Electric scooters'),
  2876.                     ],
  2877.                 ];
  2878.                 break;
  2879.         }
  2881.         return $categoryFilters;
  2882.     }
  2884.     /**
  2885.      * @param array $filter
  2886.      * @return array
  2887.      */
  2888.     public function buildPriceFilterForWizard(array $filter): array
  2889.     {
  2890.         $results = $this->getListForWizard($filter, [
  2891.             'filterOptions' => true,
  2892.         ])->getResult();
  2894.         $priceMin = $priceMax = false;
  2896.         foreach ($results as $result) {
  2897.             $productMeta = $result->getDomainMeta($this->priceDomain);
  2899.             if ($productMeta) {
  2900.                 $price = (float)$productMeta->getCurrentVatPrice();
  2902.                 if ($priceMin === false || $priceMax === false) {
  2903.                     $priceMin = $priceMax = $price;
  2904.                 }
  2906.                 if ($priceMin > $price) {
  2907.                     $priceMin = $price;
  2908.                 }
  2910.                 if ($priceMax < $price) {
  2911.                     $priceMax = $price;
  2912.                 }
  2913.             }
  2914.         }
  2916.         return [
  2917.             'priceMin' => floor($priceMin),
  2918.             'priceMax' => ceil($priceMax),
  2919.         ];
  2920.     }
  2922.     /**
  2923.      * @param array $filter
  2924.      * @param array $options
  2925.      * @return array
  2926.      */
  2927.     private function getFilterListingResults(array $filter, array $options = [])
  2928.     {
  2929.         if (isset($filter['filterCategoryId']) && in_array($filter['filterCategoryId'], CategoryPage::SALE_CATEGORY_PAGES)) {
  2930.             $filterListing = [
  2931.                 'filterCategoryId'  => $filter['filterCategoryId'],
  2932.                 'filterProductType' => $filter['filterProductType'],
  2933.             ];
  2934.         }
  2935.         else if (isset($filter['filterCategoryId'])) {
  2936.             $filterListing = [
  2937.                 'filterCategoryId' => $filter['filterCategoryId'],
  2938.             ];
  2939.         }
  2940.         else if (isset($options['search'])) {
  2941.             $filterListing = $filter;
  2943.             // Remove Quality Filter
  2944.             if (isset($filterListing['filterAttribute'][101])) {
  2945.                 unset($filterListing['filterAttribute'][101]);
  2946.             }
  2948.             // Remove Price Filter
  2949.             if (isset($filterListing['filterPriceMin'])) {
  2950.                 unset($filterListing['filterPriceMin']);
  2951.             }
  2952.             if (isset($filterListing['filterPriceMax'])) {
  2953.                 unset($filterListing['filterPriceMax']);
  2954.             }
  2955.         }
  2956.         else {
  2957.             $filterListing = [];
  2958.         }
  2960.         $query = $this->getProductListingQuery($filterListing, [
  2961.             'filterOptions' => true,
  2962.         ]);
  2964.         return $query->getResult();
  2965.     }
  2967.     /**
  2968.      * @param int $categoryId
  2969.      * @param int $limit
  2970.      */
  2971.     public function getPopularItemsByCategory($categoryId, $limit = 3)
  2972.     {
  2973.         $categoryPage = $this->entityManager->getRepository(CategoryPage::class)->findOneById($categoryId);
  2975.         $manuallyAddedProducts = $categoryPage->getPopularProducts();
  2977.         $results = [];
  2979.         if ($manuallyAddedProducts->count() < 3) {
  2980.             $query = $this->getProductListingQuery([
  2981.                 'filterCategoryId' => $categoryId,
  2982.                 'filterDiscounted' => 1,
  2983.                 'filterOrderable' => 1,
  2984.                 'start' => 0,
  2985.                 'order' => 'discountedDate',
  2986.                 'sort' => 'DESC',
  2987.                 'limit' => $limit - $manuallyAddedProducts->count(),
  2988.             ]);
  2990.             foreach ($manuallyAddedProducts as $key => $product) {
  2991.                 array_push($results, $product);
  2992.             }
  2994.             $popularProductsByDiscountedDate = new Paginator($query, $fetchJoinCollection = true);
  2996.             foreach ($popularProductsByDiscountedDate as $key => $product) {
  2997.                 array_push($results, $product);
  2998.             }
  2999.         } else {
  3000.             $results = $manuallyAddedProducts;
  3001.         }
  3003.         if (count($results) < 3) {
  3004.             $query = $this->getProductListingQuery([
  3005.                 'filterCategoryId' => $categoryId,
  3006.                 'filterDiscounted' => 0,
  3007.                 'filterOrderable' => 1,
  3008.                 'start' => 0,
  3009.                 'order' => 'lastSale',
  3010.                 'sort' => 'ASC',
  3011.                 'limit' => $limit - count($results),
  3012.             ]);
  3014.             $popularProductsByLastSale = new Paginator($query, $fetchJoinCollection = true);
  3016.             foreach ($popularProductsByLastSale as $key => $product) {
  3017.                 array_push($results, $product);
  3018.             }
  3019.         }
  3021.         $products = [];
  3022.         $count = 0;
  3024.         foreach ($results as $result) {
  3025.             $count++;
  3027.             if ($count > 3) {
  3028.                 break;
  3029.             }
  3031.             $products[$result->getId()] = $this->getStructuredDataForProduct($result, 'popular');
  3032.         }
  3034.         return $products;
  3035.     }
  3037.     /**
  3038.      * @param int $categoryId
  3039.      * @param int $vendorId
  3040.      * @param int $limit
  3041.      */
  3042.     public function getSimilarItemsByCategoryVendor($categoryId, $vendorId, $limit = 4)
  3043.     {
  3044.         $query = $this->getProductListingQuery([
  3045.             'filterCategoryId' => $categoryId,
  3046.             'filterVendor' => $vendorId,
  3047.             'filterOrderable' => 1,
  3048.             'start' => 0,
  3049.             'limit' => $limit,
  3050.         ]);
  3052.         $results = new Paginator($query, $fetchJoinCollection = true);
  3054.         $products = [];
  3056.         foreach ($results as $result) {
  3057.             $products[$result->getId()] = $this->getStructuredDataForProduct($result, 'list');
  3058.         }
  3060.         return $products;
  3061.     }
  3063.     /**
  3064.      * @param int $productId
  3065.      * @param int $limit
  3066.      * @return array
  3067.      * @throws \Doctrine\ORM\NoResultException
  3068.      * @throws \Doctrine\ORM\NonUniqueResultException
  3069.      */
  3070.     public function getSimilarProducts($productId, $limit = 3)
  3071.     {
  3072.         $product = $this->entityManager->getRepository(Product::class)->findOneById($productId);
  3073.         $domain = $this->priceDomain;
  3075.         $productsWithSameTypeVendor = $this->entityManager
  3076.             ->createQuery("SELECT COUNT(p.id)
  3077.               FROM AtechNetCoreBundle:Product p
  3078.               LEFT JOIN AtechNetCoreBundle:ProductMeta pm WITH pm.product = p AND pm.domain = :domain
  3079.               WHERE p.type = :type AND p.vendor = :vendor AND p.id != :currentProductId AND p.available > 0 AND pm.active = 1 AND pm.orderable = 1 AND p.qualityStatus != :qualityStatus")
  3080.             ->setParameters([
  3081.                 'domain' => $domain,
  3082.                 'type' => $product->getType(),
  3083.                 'vendor' => $product->getVendor(),
  3084.                 'currentProductId' => $product->getId(),
  3085.                 'qualityStatus' => Product::QualityStatus_Bazaar,
  3086.             ])
  3087.             ->setMaxResults($limit)
  3088.             ->getSingleScalarResult();
  3090.         $where = "p.type = :type";
  3091.         $parameters = [
  3092.             'domain' => $domain,
  3093.             'type' => $product->getType(),
  3094.             'currentProductId' => $product->getId(),
  3095.             'qualityStatus' => Product::QualityStatus_Bazaar,
  3096.         ];
  3098.         if ($productsWithSameTypeVendor >= $limit) {
  3099.             $where .= " AND p.vendor = :vendor";
  3100.             $parameters['vendor'] = $product->getVendor();
  3101.         }
  3103.         $results = $this->entityManager
  3104.             ->createQuery("SELECT p, (CASE WHEN v.name = '" . $product->getVendor()->getName() . "' THEN 1 ELSE 0 END) AS HIDDEN vndr
  3105.               FROM AtechNetCoreBundle:Product p
  3106.               LEFT JOIN AtechNetCoreBundle:ProductMeta pm WITH pm.product = p AND pm.domain = :domain
  3107.               LEFT JOIN p.vendor v
  3108.               WHERE " . $where . " AND p.id != :currentProductId AND p.available > 0 AND pm.active = 1 AND pm.orderable = 1 AND p.qualityStatus != :qualityStatus
  3109.               ORDER BY vndr DESC, pm.currentVatPrice ASC")
  3110.             ->setParameters($parameters)
  3111.             ->setMaxResults($limit)
  3112.             ->getResult();
  3114.         $products = [];
  3116.         foreach ($results as $result) {
  3117.             $products[$result->getId()] = $this->getStructuredDataForProduct($result, 'list');
  3118.         }
  3120.         return $products;
  3121.     }
  3123.     private function productIdsFromCategoryPagesProducts(array $categoryIds)
  3124.     {
  3125.         $ret = $this->entityManager->createQueryBuilder()
  3126.             ->from('category_pages_products', 'cpps')
  3127.             ->select('cpps.product_id AS pId')
  3128.             ->where('cpps.category_page_id IN :categoryId')
  3129.             ->setParameter(':categoryId', $categoryIds);
  3131.         return $ret->getDQL();
  3132.     }
  3134.     /**
  3135.      * @param $filter
  3136.      * @param array $options
  3137.      * @return Query
  3138.      */
  3139.     protected function getListForWizard($filter, $options = []): Query
  3140.     {
  3141.         $queryBuilder = $this->entityManager->createQueryBuilder();
  3143.         if (isset($options['count'])) {
  3144.             $queryBuilder
  3145.                 ->select(
  3146.                     $queryBuilder->expr()->countDistinct('p.id')
  3147.                 );
  3148.         } else {
  3149.             $queryBuilder->select('p');
  3150.         }
  3152.         $queryBuilder
  3153.             ->from(Product::class, 'p')
  3154.             ->leftJoin('p.metas', 'm')
  3155.             ->leftJoin('p.vendor', 'v')
  3156.             ->leftJoin('p.categoryPages', 'cp')
  3157.             ->leftJoin('cp.products', 'cpp', 'WITH', 'cpp.id IN(:categoryIds)')
  3158.             ->setParameter(':categoryIds', $this->productIdsFromCategoryPagesProducts($filter['categoryIds']));
  3160.         if (isset($filter['filterType']) && !is_null($filter['filterType'])) {
  3161.             $productTypes = [];
  3163.             $productTypesRaw = explode(',', $filter['filterType']);
  3164.             foreach ($productTypesRaw as $productType) {
  3165.                 $productTypes[] = (int)$productType;
  3166.             }
  3168.             $queryBuilder
  3169.                 ->leftJoin('p.type', 'ppt')
  3170.                 ->andWhere(
  3171.                     $queryBuilder->expr()->in('ppt.id', $productTypes)
  3172.                 );
  3173.         }
  3175.         if (isset($filter['filterBadge']) && !is_null($filter['filterBadge'])) {
  3176.             $badges = explode(',', $filter['filterBadge']);
  3178.             $orX = $queryBuilder->expr()->orX();
  3179.             foreach ($badges as $index => $badge) {
  3180.                 $orX->add(
  3181.                     $queryBuilder->expr()->like(
  3182.                         'p.badges',
  3183.                         $queryBuilder->expr()->literal('%"' . $badge . '"%')
  3184.                     )
  3185.                 );
  3186.             }
  3188.             $queryBuilder->andWhere($orX);
  3189.         }
  3191.         if (isset($filter['filterAttribute']) && !is_null($filter['filterAttribute'])) {
  3192.             // Create OR
  3193.             if (isset($filter['filterGroupOr']) && !is_null($filter['filterGroupOr'])) {
  3194.                 $orGroup = explode(',', $filter['filterGroupOr']);
  3196.                 $hasOrGroup = false;
  3198.                 $orX = $queryBuilder->expr()->orX();
  3200.                 foreach ($filter['filterAttribute'] as $attributeId => $attribute) {
  3201.                     if (in_array($attributeId, $orGroup)) {
  3202.                         $attributeOptions = [];
  3204.                         $optionsRaw = explode(',', $attribute);
  3205.                         foreach ($optionsRaw as $option) {
  3206.                             $attributeOptions[] = (int)$option;
  3207.                         }
  3209.                         $queryBuilder->leftJoin('p.productAttributes', 'pa' . $attributeId);
  3211.                         $orX->add(
  3212.                             $queryBuilder->expr()->in('pa' . $attributeId . '.option', $attributeOptions)
  3213.                         );
  3215.                         $hasOrGroup = true;
  3217.                         unset($filter['filterAttribute'][$attributeId]);
  3218.                     }
  3219.                 }
  3221.                 if ($hasOrGroup) {
  3222.                     $queryBuilder->andWhere($orX);
  3223.                 }
  3224.             }
  3226.             foreach ($filter['filterAttribute'] as $attributeId => $attribute) {
  3227.                 $attributeOptions = [];
  3229.                 $optionsRaw = explode(',', $attribute);
  3230.                 foreach ($optionsRaw as $option) {
  3231.                     $attributeOptions[] = (int)$option;
  3232.                 }
  3234.                 $queryBuilder
  3235.                     ->leftJoin('p.productAttributes', 'pa' . $attributeId)
  3236.                     ->andWhere(
  3237.                         $queryBuilder->expr()->in('pa' . $attributeId . '.option', $attributeOptions)
  3238.                     );
  3239.             }
  3240.         }
  3242.         if (!empty($filter['filterPriceMin'])) {
  3243.             $queryBuilder
  3244.                 ->andWhere('m.currentVatPrice >= :filterPriceMin')
  3245.                 ->setParameter(':filterPriceMin', $filter['filterPriceMin']);
  3246.         }
  3248.         if (!empty($filter['filterPriceMax'])) {
  3249.             $queryBuilder
  3250.                 ->andWhere('m.currentVatPrice <= :filterPriceMax')
  3251.                 ->setParameter(':filterPriceMax', $filter['filterPriceMax']);
  3252.         }
  3254.         $queryBuilder
  3255.             ->andWhere('m.domain = :domainId')
  3256.             ->setParameter(':domainId', $this->priceDomainId)
  3257.             ->andWhere('m.price > 0')
  3258.             ->andWhere('m.active = 1')
  3259.             ->andWhere('m.listed = 1')
  3260.             ->andWhere('p.archived = 0')
  3261.             ->andWhere('p.available > 0');
  3263.         if (!isset($options['count']) && !isset($options['filterOptions'])) {
  3264.             if (!empty($filter['sort']) && !empty($filter['order'])) {
  3265.                 if ($filter['sort'] == 'price' && $filter['order'] == 'asc') {
  3266.                     $queryBuilder->orderBy('m.currentVatPrice', 'ASC');
  3267.                 } elseif ($filter['sort'] == 'price' && $filter['order'] == 'desc') {
  3268.                     $queryBuilder->orderBy('m.currentVatPrice', 'DESC');
  3269.                 } elseif ($filter['sort'] == 'created' && $filter['order'] == 'asc') {
  3270.                     $queryBuilder->orderBy('p.created', 'ASC');
  3271.                 } elseif ($filter['sort'] == 'created' && $filter['order'] == 'desc') {
  3272.                     $queryBuilder->orderBy('p.created', 'DESC');
  3273.                 } elseif ($filter['sort'] == 'name' && $filter['order'] == 'asc') {
  3274.                     $queryBuilder->orderBy(
  3275.                         $queryBuilder->expr()->concat(
  3276.                             'v.name',
  3277.                             $queryBuilder->expr()->concat(
  3278.                                 $queryBuilder->expr()->literal(' '),
  3279.                                 'p.name'
  3280.                             )
  3281.                         ),
  3282.                         'ASC'
  3283.                     );
  3284.                 } elseif ($filter['sort'] == 'name' && $filter['order'] == 'desc') {
  3285.                     $queryBuilder->orderBy(
  3286.                         $queryBuilder->expr()->concat(
  3287.                             'v.name',
  3288.                             $queryBuilder->expr()->concat(
  3289.                                 $queryBuilder->expr()->literal(' '),
  3290.                                 'p.name'
  3291.                             )
  3292.                         ),
  3293.                         'DESC'
  3294.                     );
  3295.                 } else {
  3296.                     $queryBuilder->orderBy('p.available', 'DESC');
  3297.                 }
  3298.             }
  3300.             if (isset($filter['start']) && isset($filter['limit'])) {
  3301.                 if ($filter['start'] < 0) {
  3302.                     $filter['start'] = 0;
  3303.                 }
  3305.                 if ($filter['limit'] < 1) {
  3306.                     $filter['limit'] = 12;
  3307.                 }
  3309.                 $queryBuilder
  3310.                     ->setFirstResult($filter['start'])
  3311.                     ->setMaxResults($filter['limit']);
  3312.             }
  3313.         }
  3315.         return $queryBuilder->getQuery();
  3316.     }
  3318.     /**
  3319.      * @param array $filter
  3320.      * @return \Doctrine\ORM\Query
  3321.      */
  3322.     protected function getProductVariantsQuery(array $filter): Query
  3323.     {
  3324.         $queryBuilder = $this->entityManager->createQueryBuilder();
  3326.         $queryBuilder
  3327.             ->select('p')
  3328.             ->from(Product::class, 'p')
  3329.             ->leftJoin('p.metas', 'm')
  3330.             ->leftJoin('p.vendor', 'v');
  3332.         if (isset($filter['vendorId']) && !is_null($filter['vendorId'])) {
  3333.             $queryBuilder
  3334.                 ->andWhere('v.id = ' . $filter['vendorId']);
  3335.         }
  3337.         if (isset($filter['name']) && !is_null($filter['name'])) {
  3338.             $queryBuilder
  3339.                 ->andWhere(
  3340.                     $queryBuilder->expr()->like(
  3341.                         'p.name',
  3342.                         $queryBuilder->expr()->literal('%' . $filter['name'] . '%')
  3343.                     )
  3344.                 );
  3345.         }
  3347.         if (isset($filter['typeId']) && !is_null($filter['typeId'])) {
  3348.             $queryBuilder
  3349.                 ->leftJoin('p.type', 'ppt')
  3350.                 ->andWhere('ppt.id = ' . $filter['typeId']);
  3351.         }
  3353.         $queryBuilder
  3354.             ->andWhere('m.domain = :domainId')
  3355.             ->setParameter(':domainId', $this->priceDomainId)
  3356.             ->andWhere('m.currentVatPrice > 0')
  3357.             ->andWhere('p.archived = 0')
  3358.             ->andWhere('p.available > 0')
  3359.             ->andWhere('p.id != :productId')
  3360.             ->setParameter(':productId', $filter['productId'])
  3361.             ->andWhere('p.qualityStatus != :qualityStatus')
  3362.             ->setParameter(':qualityStatus', Product::QualityStatus_Bazaar)
  3363.             ->setMaxResults(3)
  3364.             ->andWhere('m.orderable = 1')
  3365.             ->andWhere('m.active = 1')
  3366.             ->orderBy('m.currentVatPrice');
  3368.         return $queryBuilder->getQuery();
  3369.     }
  3371.     /**
  3372.      * @param array $filter
  3373.      * @param array $options
  3374.      * @return Query
  3375.      * @throws NotSupported
  3376.      */
  3377.     protected function getProductListingQuery(array $filter, array $options = [])
  3378.     {
  3379.         $queryBuilder = $this->entityManager->createQueryBuilder();
  3381.         if (isset($options['count'])) {
  3382.             $queryBuilder
  3383.                 ->select(
  3384.                     $queryBuilder->expr()->countDistinct('p.id')
  3385.                 );
  3386.         } else {
  3387.             $queryBuilder->select('p');
  3388.         }
  3390.         $queryBuilder
  3391.             ->from(Product::class, 'p')
  3392.             ->leftJoin('p.metas', 'm')
  3393.             ->leftJoin('p.vendor', 'v')
  3394.             ->leftJoin('p.type', 'ppt');
  3396.         /**
  3397.          * @var CategoryPage $categoryInfo
  3398.          */
  3399.         if (isset($filter['filterCategoryId'])) {
  3400.             $categoryInfo = $this->entityManager->getRepository(CategoryPage::class)->findOneById($filter['filterCategoryId']);
  3402.             if ($categoryInfo) {
  3403.                 $countVendors = $categoryInfo->getVendors()->count();
  3404.                 $countProductTypes = $categoryInfo->getProductTypes()->count();
  3406.                 if ($countVendors > 0) {
  3407.                     $queryBuilder
  3408.                         ->leftJoin('v.categoryPages', 'vc', 'WITH', 'vc.id = :categoryId');
  3409.                 }
  3411.                 if ($countProductTypes > 0) {
  3412.                     $queryBuilder
  3413.                         ->leftJoin('p.type', 't')
  3414.                         ->leftJoin('t.categoryPages', 'tc', 'WITH', 'tc.id = :categoryId');
  3415.                 }
  3417.                 $categoryInfoBadges = json_decode($categoryInfo->getBadges(), true);
  3419.                 $queryBuilder->leftJoin('p.categoryPages', 'c', 'WITH', 'c.id = :categoryId');
  3421.                 if ($countVendors > 0 || $countProductTypes > 0 || (is_array($categoryInfoBadges) && count($categoryInfoBadges) > 0)) {
  3422.                     if ($countProductTypes > 0) {
  3423.                         $queryBuilder
  3424.                             ->andWhere(
  3425.                                 $queryBuilder->expr()->orX(
  3426.                                     $queryBuilder->expr()->eq('c.id', ':categoryId'),
  3427.                                     $queryBuilder->expr()->andX(
  3428.                                         $queryBuilder->expr()->isNotNull('tc.id')
  3429.                                     )
  3430.                                 )
  3431.                             );
  3432.                     }
  3434.                     if ($countVendors > 0) {
  3435.                         $queryBuilder
  3436.                             ->andWhere(
  3437.                                 $queryBuilder->expr()->orX(
  3438.                                     $queryBuilder->expr()->eq('c.id', ':categoryId'),
  3439.                                     $queryBuilder->expr()->andX(
  3440.                                         $queryBuilder->expr()->isNotNull('vc.id')
  3441.                                     )
  3442.                                 )
  3443.                             );
  3444.                     }
  3446.                     if (is_array($categoryInfoBadges) && count($categoryInfoBadges) > 0) {
  3447.                         $orX = $queryBuilder->expr()->orX();
  3448.                         foreach ($categoryInfoBadges as $badge) {
  3449.                             $orX->add(
  3450.                                 $queryBuilder->expr()->like(
  3451.                                     'p.badges',
  3452.                                     $queryBuilder->expr()->literal('%"' . $badge . '"%')
  3453.                                 )
  3454.                             );
  3455.                         }
  3457.                         $queryBuilder->andWhere($orX);
  3458.                     }
  3459.                 } else {
  3460.                     $queryBuilder->andWhere(
  3461.                         $queryBuilder->expr()->isNotNull('c.id')
  3462.                     );
  3463.                 }
  3465.                 $queryBuilder->setParameter('categoryId', $filter['filterCategoryId']);
  3466.             }
  3467.         } elseif (isset($filter['filterCategories']) && $filter['filterCategories'] != null) {
  3468.             $categoryInfos = $this->entityManager->getRepository(CategoryPage::class)->findBy([
  3469.                 'id' => explode(',', $filter['filterCategories']),
  3470.             ]);
  3472.             $countVendors = $countProductTypes = 0;
  3473.             $categoryInfoBadges = [];
  3475.             foreach ($categoryInfos as $categoryPageItem) {
  3476.                 $countVendors += $categoryPageItem->getVendors()->count();
  3477.                 $countProductTypes += $categoryPageItem->getProductTypes()->count();
  3479.                 $categoryInfoBadges = array_merge($categoryInfoBadges, $categoryPageItem->getBadges() != "" ? json_decode($categoryPageItem->getBadges(), true) : []);
  3480.             }
  3482.             if ($countVendors > 0) {
  3483.                 $queryBuilder
  3484.                     ->leftJoin('v.categoryPages', 'vc', 'WITH', 'vc.id IN(:categoryIds)');
  3485.             }
  3487.             if ($countProductTypes > 0) {
  3488.                 $queryBuilder
  3489.                     ->leftJoin('p.type', 't')
  3490.                     ->leftJoin('t.categoryPages', 'tc', 'WITH', 'tc.id IN(:categoryIds)');
  3491.             }
  3493.             $queryBuilder->leftJoin('p.categoryPages', 'c', 'WITH', 'c.id IN(:categoryIds)');
  3495.             if ($countVendors > 0 || $countProductTypes > 0 || (is_array($categoryInfoBadges) && count($categoryInfoBadges) > 0)) {
  3496.                 if ($countProductTypes > 0) {
  3497.                     $queryBuilder
  3498.                         ->andWhere(
  3499.                             $queryBuilder->expr()->orX(
  3500.                                 $queryBuilder->expr()->in('c.id', ':categoryIds'),
  3501.                                 $queryBuilder->expr()->andX(
  3502.                                     $queryBuilder->expr()->isNotNull('tc.id')
  3503.                                 )
  3504.                             )
  3505.                         );
  3506.                 }
  3508.                 if ($countVendors > 0) {
  3509.                     $queryBuilder
  3510.                         ->andWhere(
  3511.                             $queryBuilder->expr()->orX(
  3512.                                 $queryBuilder->expr()->in('c.id', ':categoryIds'),
  3513.                                 $queryBuilder->expr()->andX(
  3514.                                     $queryBuilder->expr()->isNotNull('vc.id')
  3515.                                 )
  3516.                             )
  3517.                         );
  3518.                 }
  3520.                 if (is_array($categoryInfoBadges) && count($categoryInfoBadges) > 0) {
  3521.                     $orX = $queryBuilder->expr()->orX();
  3522.                     foreach ($categoryInfoBadges as $badge) {
  3523.                         $orX->add(
  3524.                             $queryBuilder->expr()->like(
  3525.                                 'p.badges',
  3526.                                 $queryBuilder->expr()->literal('%"' . $badge . '"%')
  3527.                             )
  3528.                         );
  3529.                     }
  3531.                     $queryBuilder->andWhere($orX);
  3532.                 }
  3533.             } else {
  3534.                 $queryBuilder->andWhere(
  3535.                     $queryBuilder->expr()->isNotNull('c.id')
  3536.                 );
  3537.             }
  3539.             $queryBuilder->setParameter('categoryIds', explode(',', $filter['filterCategories']));
  3540.         }
  3542.         if (isset($filter['filterProductType']) && !is_null($filter['filterProductType']) && $filter['filterProductType'] != '') {
  3543.             $productTypes = [];
  3545.             $productTypesRaw = explode(',', $filter['filterProductType']);
  3546.             foreach ($productTypesRaw as $productType) {
  3547.                 $productTypes[] = (int)$productType;
  3548.             }
  3550.             $queryBuilder
  3551.                 ->andWhere(
  3552.                     $queryBuilder->expr()->in('p.type', $productTypes)
  3553.                 );
  3554.         }
  3556.         if (isset($filter['filterVendor']) && !is_null($filter['filterVendor']) && $filter['filterVendor'] != '') {
  3557.             $vendors = [];
  3559.             $vendorsRaw = explode(',', $filter['filterVendor']);
  3560.             foreach ($vendorsRaw as $vendor) {
  3561.                 $vendors[] = (int)$vendor;
  3562.             }
  3564.             $queryBuilder
  3565.                 ->andWhere(
  3566.                     $queryBuilder->expr()->in('v.id', $vendors)
  3567.                 );
  3568.         }
  3570.         if (isset($filter['filterType']) && !is_null($filter['filterType'])) {
  3571.             $productTypes = [];
  3573.             $productTypesRaw = explode(',', $filter['filterType']);
  3574.             foreach ($productTypesRaw as $productType) {
  3575.                 $productTypes[] = (int)$productType;
  3576.             }
  3578.             $queryBuilder
  3579.                 ->andWhere(
  3580.                     $queryBuilder->expr()->in('ppt.id', $productTypes)
  3581.                 );
  3582.         }
  3584.         if (isset($filter['filterBadge']) && !is_null($filter['filterBadge'])) {
  3585.             $badges = explode(',', $filter['filterBadge']);
  3587.             $orX = $queryBuilder->expr()->orX();
  3588.             foreach ($badges as $index => $badge) {
  3589.                 $orX->add(
  3590.                     $queryBuilder->expr()->like(
  3591.                         'p.badges',
  3592.                         $queryBuilder->expr()->literal('%"' . $badge . '"%')
  3593.                     )
  3594.                 );
  3595.             }
  3597.             $queryBuilder->andWhere($orX);
  3598.         }
  3600.         if (isset($filter['filterAttribute']) && $filter['filterAttribute'] != '') {
  3601.             // Attribute Option Groups
  3602.             $attributeOptionGroups = AttributeOption::getAttributeOptionGroups();
  3604.             // Create OR
  3605.             if (isset($filter['filterGroupOr']) && !is_null($filter['filterGroupOr'])) {
  3606.                 $orGroup = explode(',', $filter['filterGroupOr']);
  3608.                 $hasOrGroup = false;
  3610.                 $orX = $queryBuilder->expr()->orX();
  3612.                 foreach ($filter['filterAttribute'] as $attributeId => $attribute) {
  3613.                     if (in_array($attributeId, $orGroup)) {
  3614.                         $attributeOptions = [];
  3616.                         $optionsRaw = explode(',', $attribute);
  3617.                         foreach ($optionsRaw as $option) {
  3618.                             $attributeOptions[] = (int)$option;
  3619.                         }
  3621.                         if (isset($attributeOptionGroups[$attributeId])) {
  3622.                             foreach ($attributeOptionGroups[$attributeId] as $group) {
  3623.                                 $merge = false;
  3625.                                 foreach ($group as $optionId) {
  3626.                                     if (in_array((int)$optionId, $attributeOptions)) {
  3627.                                         $merge = true;
  3628.                                     }
  3629.                                 }
  3631.                                 if ($merge) {
  3632.                                     $attributeOptions = array_merge($attributeOptions, $group);
  3633.                                 }
  3634.                             }
  3636.                             array_unique($attributeOptions, SORT_NUMERIC);
  3637.                         }
  3639.                         $queryBuilder->leftJoin('p.productAttributes', 'pa' . $attributeId);
  3641.                         $orX->add(
  3642.                             $queryBuilder->expr()->in('pa' . $attributeId . '.option', $attributeOptions)
  3643.                         );
  3645.                         $hasOrGroup = true;
  3647.                         unset($filter['filterAttribute'][$attributeId]);
  3648.                     }
  3649.                 }
  3651.                 if ($hasOrGroup) {
  3652.                     $queryBuilder->andWhere($orX);
  3653.                 }
  3654.             }
  3656.             foreach ($filter['filterAttribute'] as $attributeId => $attribute) {
  3657.                 //TN panel is not set so we need to use id is not query... (â–º__â—„)
  3658.                 if ($attributeId == Attribute::ATTRIBUTE_ID_DISPLAY_TECHNOLOGY
  3659.                     && $attribute == $this->getTnDisplayAttributeOptionIds()) {
  3660.                     $queryBuilder
  3661.                         ->andWhere(
  3662.                             $queryBuilder->expr()->not(
  3663.                                 $queryBuilder->expr()->exists(
  3664.                                     $this->entityManager->createQueryBuilder()
  3665.                                         ->select('1')
  3666.                                         ->from('AtechNetCoreBundle:ProductAttribute', 'paDT')
  3667.                                         ->innerJoin('AtechNetCoreBundle:AttributeOption', 'ao', 'WITH', 'paDT.option = ao.id')
  3668.                                         ->where('paDT.product = p.id')
  3669.                                         ->andWhere('ao.attribute = :attributeId')
  3670.                                         ->getDQL()
  3671.                                 )
  3672.                             )
  3673.                         )
  3674.                         ->setParameter(':attributeId', Attribute::ATTRIBUTE_ID_DISPLAY_TECHNOLOGY);
  3675.                     
  3676.                     continue;
  3677.                 }
  3678.                 //SAME WITH THE NUMPAD THE NO NUMPAD ATTRIBUTE OPTION IS NOT USED (ï¿£ i ï¿£)
  3679.                 else if ($attributeId == Attribute::ATTRIBUTE_ID_NUMPAD
  3680.                     && $attribute == AttributeOption::ATTRIBUTE_OPTION_NO_NUMPAD) {
  3681.                     $queryBuilder
  3682.                         ->andWhere(
  3683.                             $queryBuilder->expr()->not(
  3684.                                 $queryBuilder->expr()->exists(
  3685.                                     $this->entityManager->createQueryBuilder()
  3686.                                         ->select('1')
  3687.                                         ->from('AtechNetCoreBundle:ProductAttribute', 'paNum')
  3688.                                         ->innerJoin('AtechNetCoreBundle:AttributeOption', 'ao', 'WITH', 'paNum.option = ao.id')
  3689.                                         ->where('paNum.product = p.id')
  3690.                                         ->andWhere('ao.attribute = :attributeId')
  3691.                                         ->getDQL()
  3692.                                 )
  3693.                             )
  3694.                         )
  3695.                         ->setParameter(':attributeId', Attribute::ATTRIBUTE_ID_NUMPAD);
  3697.                     continue;
  3698.                 }
  3699.                 else if ($attributeId == 'newBattery') {
  3700.                     $queryBuilder->innerJoin('p.tags', 'tag')
  3701.                         ->andWhere('tag.title = :newBattery')
  3702.                         ->setParameter(':newBattery', 'New battery - Notebook');
  3704.                     continue;
  3705.                 }
  3706.                 
  3707.                 $attributeOptions = [];
  3709.                 $optionsRaw = explode(',', $attribute);
  3710.                 foreach ($optionsRaw as $option) {
  3711.                     $attributeOptions[] = (int)$option;
  3712.                 }
  3714.                 if (isset($attributeOptionGroups[$attributeId])) {
  3715.                     foreach ($attributeOptionGroups[$attributeId] as $group) {
  3716.                         $merge = false;
  3718.                         foreach ($group as $optionId) {
  3719.                             if (in_array((int)$optionId, $attributeOptions)) {
  3720.                                 $merge = true;
  3721.                             }
  3722.                         }
  3724.                         if ($merge) {
  3725.                             $attributeOptions = array_merge($attributeOptions, $group);
  3726.                         }
  3727.                     }
  3729.                     array_unique($attributeOptions, SORT_NUMERIC);
  3730.                 }
  3732.                 $queryBuilder
  3733.                     ->leftJoin('p.productAttributes', 'pa' . $attributeId)
  3734.                     ->andWhere(
  3735.                         $queryBuilder->expr()->in('pa' . $attributeId . '.option', $attributeOptions)
  3736.                     );
  3737.             }
  3738.         }
  3740.         if (!empty($filter['filterPriceMin'])) {
  3741.             $queryBuilder
  3742.                 ->andWhere('m.currentVatPrice >= :filterPriceMin')
  3743.                 ->setParameter(':filterPriceMin', $filter['filterPriceMin']);
  3744.         }
  3746.         if (!empty($filter['filterPriceMax'])) {
  3747.             $queryBuilder
  3748.                 ->andWhere('m.currentVatPrice <= :filterPriceMax')
  3749.                 ->setParameter(':filterPriceMax', $filter['filterPriceMax']);
  3750.         }
  3752.         if (!empty($filter['filterCpuMarkMin'])) {
  3753.             $queryBuilder
  3754.                 ->andWhere('p.cpuMark != 0')
  3755.                 ->andWhere('p.cpuMark >= :filterCpuMarkMin')
  3756.                 ->setParameter(':filterCpuMarkMin', self::CPU_MARK_HELPER_MIN[$filter['filterCpuMarkMin']]);
  3757.         }
  3759.         if (!empty($filter['filterCpuMarkMax'])) {
  3760.             $queryBuilder
  3761.                 ->andWhere('p.cpuMark != 0')
  3762.                 ->andWhere('p.cpuMark <= :filterCpuMarkMax')
  3763.                 ->setParameter(':filterCpuMarkMax', self::CPU_MARK_HELPER_MAX[$filter['filterCpuMarkMax']]);
  3765.         }
  3767.         //page without discount
  3768.         if (isset($categoryInfo) && in_array($categoryInfo->getId(), [659, CategoryPage::UJVARI_FURDO_BANNER_SK, CategoryPage::UJVARI_FURDO_BANNER_HU, CategoryPage::UJVARI_FURDO_BANNER_CZ, 689, 690])) {
  3769.             $queryBuilder->andWhere('m.discounted = 0');
  3770.         }
  3772.         if (!empty($filter['filterDiscounted']) || (isset($categoryInfo) && $categoryInfo->isShowOnlyDiscounted())) {
  3773.             $filterValue = isset($categoryInfo) && $categoryInfo->isShowOnlyDiscounted() ? 1 : (int)$filter['filterDiscounted'];
  3774.             $queryBuilder
  3775.                 ->andWhere('m.discounted = :filterDiscounted')
  3776.                 ->setParameter(':filterDiscounted', $filterValue);
  3777.         }
  3779.         if (isset($categoryInfo) && $categoryInfo->isShowOnlyFlashSales()) {
  3780.             $queryBuilder
  3781.                 ->andWhere('m.discounted = 1 AND (m.saleStart IS NOT NULL OR m.saleEnd IS NOT NULL) AND (
  3782.                     (m.saleStart IS NOT NULL AND m.saleEnd IS NULL AND m.saleStart < :currentDate) OR (m.saleStart IS NULL AND m.saleEnd IS NOT NULL AND m.saleEnd > :currentDate) OR (m.saleStart IS NOT NULL AND m.saleEnd IS NOT NULL AND m.saleStart < :currentDate AND m.saleEnd > :currentDate)
  3783.                 )')
  3784.                 ->setParameter(':currentDate', (new \DateTime()));
  3785.         }
  3787.         if (isset($categoryInfo) && $categoryInfo->isShowOnlyBazaar()) {
  3788.             $queryBuilder
  3789.                 ->andWhere('p.qualityStatus = :bazaar')
  3790.                 ->setParameter(':bazaar', Product::QualityStatus_Bazaar);
  3792.         }
  3793.         else if (in_array($this->multiStore->getDomainId(), MultiStore::getWholesaleDomainIDs())) {
  3794.             //note WSen minden kategoriaban ott lehet a bazar, Katival megbeszelve
  3795.         }
  3796.         else if ((!isset($categoryInfo) || (isset($categoryInfo) && $categoryInfo->isIncludeBazaar() === false)) && empty($filter['filterSearch'])) {
  3797.             $queryBuilder
  3798.                 ->andWhere('p.qualityStatus != :bazaar')
  3799.                 ->setParameter(':bazaar', Product::QualityStatus_Bazaar);
  3800.         }
  3803.         if (!empty($filter['filterLastPieces'])) {
  3804.             $queryBuilder
  3805.                 ->andWhere('p.available = :filterLastPieces')
  3806.                 ->setParameter(':filterLastPieces', (int)$filter['filterLastPieces']);
  3807.         }
  3809.         $queryBuilder
  3810.             ->andWhere('m.domain = :domainId')
  3811.             ->setParameter(':domainId', $this->priceDomainId)
  3812.             ->andWhere('m.price > 0')
  3813.             ->andWhere('p.archived = 0');
  3815.         if (!isset($options['show_not_available'])) {
  3816.             $queryBuilder
  3817.                 ->andWhere('m.active = :active')
  3818.                 ->setParameter(':active', 1)
  3819.                 ->andWhere('m.listed = :listed')
  3820.                 ->setParameter(':listed', 1);
  3822.             $orX = $queryBuilder->expr()->orX(
  3823.                 $queryBuilder->expr()->andX(
  3824.                     $queryBuilder->expr()->gt(
  3825.                         'p.available',
  3826.                         0
  3827.                     ),
  3828.                     $queryBuilder->expr()->not(
  3829.                         $queryBuilder->expr()->eq(
  3830.                             'p.outOfStockStatus',
  3831.                             Product::OutOfStockStatus_VisibleShadow
  3832.                         )
  3833.                     )
  3834.                 )
  3835.             );
  3837.             $queryBuilder->andWhere($orX);
  3838.         }
  3840.         if (isset($filter['filterBestseller'])) {
  3841.             $queryBuilder
  3842.                 ->andWhere('m.bestSeller = :bestSeller')
  3843.                 ->setParameter(':bestSeller', (int)$filter['filterBestseller']);
  3844.         }
  3846.         if (isset($filter['filterOrderable'])) {
  3847.             $queryBuilder
  3848.                 ->andWhere('m.orderable = :orderable')
  3849.                 ->setParameter(':orderable', (int)$filter['filterOrderable']);
  3850.         }
  3852.         if (!empty($filter['filterSearch'])) {
  3853.             $andX = $queryBuilder->expr()->andX();
  3855.             $words = explode(' ', trim(preg_replace('/\s+/', ' ', $filter['filterSearch'])));
  3856.             foreach ($words as $index => $word) {
  3857.                 $andX
  3858.                     ->add(
  3859.                         $queryBuilder->expr()->like(
  3860.                             $queryBuilder->expr()->concat(
  3861.                                 'v.name',
  3862.                                 $queryBuilder->expr()->literal(' '),
  3863.                                 'ppt.title',
  3864.                                 $queryBuilder->expr()->literal(' '),
  3865.                                 'p.name'
  3866.                             ),
  3867.                             $queryBuilder->expr()->literal('%' . $word . '%')
  3868.                         )
  3869.                     );
  3870.             }
  3872.             $orX = $queryBuilder->expr()->orX(
  3873.                 $queryBuilder->expr()->andX(
  3874.                     $queryBuilder->expr()->gt(
  3875.                         'p.available',
  3876.                         0
  3877.                     ),
  3878.                     $queryBuilder->expr()->not(
  3879.                         $queryBuilder->expr()->eq(
  3880.                             'p.outOfStockStatus',
  3881.                             Product::OutOfStockStatus_VisibleShadow
  3882.                         )
  3883.                     )
  3884.                 )
  3885.             );
  3887.             $queryBuilder
  3888.                 ->andWhere(
  3889.                     $queryBuilder->expr()->orX(
  3890.                         $andX,
  3891.                         $queryBuilder->expr()->like(
  3892.                             'p.code',
  3893.                             $queryBuilder->expr()->literal('%' . $filter['filterSearch'] . '%')
  3894.                         )
  3895.                     )
  3896.                 )
  3897.                 ->orWhere('p.ean = ' . $queryBuilder->expr()->literal($filter['filterSearch']))
  3898.                 ->orWhere('p.partNumber = ' . $queryBuilder->expr()->literal($filter['filterSearch']))
  3899.                 ->andWhere('m.currentVatPrice != 0')
  3900.                 ->andWhere($orX);
  3901.         }
  3903.         $isNewProductPage = key_exists('filterCategories', $filter);
  3905.         if ($isNewProductPage) {
  3906.             $queryBuilder
  3907.                 ->andWhere('m.activationDate > :currentDateMinus1Month')
  3908.                 ->setParameter(':currentDateMinus1Month', (new \DateTime('-1 month')));
  3909.         }
  3911.         if (!isset($options['count']) && !isset($options['filterOptions'])) {
  3912.             if (!empty($filter['sort']) && !empty($filter['order'])) {
  3913.                 $orderByOption = false;
  3915.                 switch ($filter['sort']) {
  3916.                     case 'price':
  3917.                         $orderByOption = 'm.currentVatPrice';
  3918.                         break;
  3919.                     case 'created':
  3920.                         $orderByOption = 'm.activationDate';
  3921.                         break;
  3922.                     case 'name':
  3923.                         $orderByOption = $queryBuilder->expr()->concat(
  3924.                             'v.name',
  3925.                             $queryBuilder->expr()->concat(
  3926.                                 $queryBuilder->expr()->literal(' '),
  3927.                                 'p.name'
  3928.                             )
  3929.                         );
  3930.                         break;
  3931.                     case 'popular':
  3932.                         $orderByOption = 'p.soldDuringTimeFrame';
  3933.                         break;
  3934.                     case 'discountedDate':
  3935.                         $orderByOption = 'm.discountedDate';
  3936.                         break;
  3937.                     case 'lastSale':
  3938.                         $orderByOption = 'p.lastSale';
  3939.                         break;
  3940.                 }
  3942.                 $order = $filter['order'] == 'asc' ? 'asc' : 'desc';
  3944.                 $queryBuilder->addOrderBy(
  3945.                     $orderByOption ?: ($isNewProductPage ? 'm.activationDate' : 'p.available'),
  3946.                     $order
  3947.                 );
  3948.             }
  3950.             if (isset($filter['start']) && isset($filter['limit'])) {
  3951.                 if ($filter['start'] < 0) {
  3952.                     $filter['start'] = 0;
  3953.                 }
  3955.                 if ($filter['limit'] < 1) {
  3956.                     $filter['limit'] = 12;
  3957.                 }
  3959.                 $queryBuilder
  3960.                     ->setFirstResult($filter['start'])
  3961.                     ->setMaxResults($filter['limit']);
  3962.             }
  3963.         }
  3965.         if (isset($filter['searchInDockTonerDesc']) && $filter['searchInDockTonerDesc']) {
  3966.             $orWhereString = "p.type IN (16,92,106,128) AND m.detail LIKE :filterSearchLike";
  3968.             $queryBuilder
  3969.                 ->setParameter('filterSearchLike', '%' . $filter['filterSearch'] . '%');
  3971.             if (isset($filter['filterPriceMax']) && $filter['filterPriceMax'] > 0) {
  3972.                 $orWhereString .= ' AND m.currentVatPrice >= :filterPriceMin AND m.currentVatPrice <= :filterPriceMax';
  3974.                 $queryBuilder
  3975.                     ->setParameter('filterPriceMin', $filter['filterPriceMin'])
  3976.                     ->setParameter('filterPriceMax', $filter['filterPriceMax']);
  3977.             }
  3979.             $queryBuilder
  3980.                 ->orWhere($orWhereString);
  3981.         }
  3983.         return $queryBuilder->getQuery();
  3984.     }
  3986.     /**
  3987.      * @param Product $product
  3988.      * @return array
  3989.      */
  3990.     protected function getProductIcons(Product $product)
  3991.     {
  3992.         $productAttributeOptions = $product->getSpecificationProductAttributeOptions();
  3993.         $badges = $product->getBadges();
  3994.         $productTypeId = $product->getType()->getId();
  3996.         $icons = [
  3997.             [
  3998.                 'attributeId' => 141,            // PC Processor family
  3999.                 'attributeOptionId' => 1339,        // i3
  4000.                 'file' => 'processor-i3.svg',
  4001.                 'sortOrder' => 1,
  4002.                 'title' => 'Intel Core i3',
  4003.             ], [
  4004.                 'attributeId' => 141,            // PC Processor family
  4005.                 'attributeOptionId' => 1340,        // i5
  4006.                 'file' => 'processor-i5.svg',
  4007.                 'sortOrder' => 2,
  4008.                 'title' => 'Intel Core i5',
  4009.             ], [
  4010.                 'attributeId' => 141,            // PC Processor family
  4011.                 'attributeOptionId' => 1341,        // i7
  4012.                 'file' => 'processor-i7.svg',
  4013.                 'sortOrder' => 3,
  4014.                 'title' => 'Intel Core i7',
  4015.             ], [
  4016.                 'attributeId' => 142,            // PC Processor family
  4017.                 'attributeOptionId' => 1357,        // i3
  4018.                 'file' => 'processor-i3.svg',
  4019.                 'sortOrder' => 4,
  4020.                 'title' => 'Intel Core i3',
  4021.             ], [
  4022.                 'attributeId' => 142,            // PC Processor family
  4023.                 'attributeOptionId' => 1358,        // i5
  4024.                 'file' => 'processor-i5.svg',
  4025.                 'sortOrder' => 5,
  4026.                 'title' => 'Intel Core i5',
  4027.             ], [
  4028.                 'attributeId' => 142,            // PC Processor family
  4029.                 'attributeOptionId' => 1359,        // i7
  4030.                 'file' => 'processor-i7.svg',
  4031.                 'sortOrder' => 6,
  4032.                 'title' => 'Intel Core i7',
  4033.             ], [
  4034.                 'attributeId' => 15,            // Bluetooth
  4035.                 'attributeOptionId' => 567,            // Yes
  4036.                 'file' => 'bluetooth.svg',
  4037.                 'sortOrder' => 7,
  4038.                 'title' => 'Bluetooth',
  4039.             ], [
  4040.                 'attributeId' => 118,            // Technology
  4041.                 'attributeOptionId' => 926,            // IPS
  4042.                 'file' => 'ips.svg',
  4043.                 'sortOrder' => 8,
  4044.                 'title' => 'IPS display',
  4045.             ], [
  4046.                 'attributeId' => 5,            // SSD
  4047.                 'attributeOptionId' => false,        // More Options
  4048.                 'file' => 'ssd.svg',
  4049.                 'sortOrder' => 9,
  4050.                 'title' => 'SSD disc',
  4051.             ], [
  4052.                 'attributeId' => 16,            // Wi-Fi
  4053.                 'attributeOptionId' => 217,            // Yes
  4054.                 'file' => 'wifi.svg',
  4055.                 'sortOrder' => 10,
  4056.                 'title' => 'Wifi',
  4057.             ], [
  4058.                 'attributeId' => 139,            // Touchscreen
  4059.                 'attributeOptionId' => 1295,        // Yes
  4060.                 'file' => 'touchdisplay.svg',
  4061.                 'sortOrder' => 11,
  4062.                 'title' => 'Touch display',
  4063.             ], [
  4064.                 'attributeId' => 17,            // NumPad
  4065.                 'attributeOptionId' => 555,            // Yes
  4066.                 'file' => 'numeric.svg',
  4067.                 'sortOrder' => 12,
  4068.                 'title' => 'Numeric keyboard',
  4069.             ], [
  4070.                 'attributeId' => 50,            // Night light
  4071.                 'attributeOptionId' => 556,            // Yes
  4072.                 'file' => 'keyboardlight.svg',
  4073.                 'sortOrder' => 13,
  4074.                 'title' => 'Night light',
  4075.             ], [
  4076.                 'attributeId' => 46,            // Connectors external PC
  4077.                 'attributeOptionId' => 504,            // HDMI
  4078.                 'file' => 'hdmi.svg',
  4079.                 'sortOrder' => 14,
  4080.                 'title' => 'HDMI connector',
  4081.             ], [
  4082.                 'attributeId' => 45,            // Connectors external NB
  4083.                 'attributeOptionId' => 544,            // HDMI
  4084.                 'file' => 'hdmi.svg',
  4085.                 'sortOrder' => 15,
  4086.                 'title' => 'HDMI connector',
  4087.             ], [
  4088.                 'attributeId' => 68,            // Graphical inputs
  4089.                 'attributeOptionId' => 733,            // HDMI
  4090.                 'file' => 'hdmi.svg',
  4091.                 'sortOrder' => 16,
  4092.                 'title' => 'HDMI connector',
  4093.             ], [
  4094.                 'attributeId' => 55,            // Fingerprint
  4095.                 'attributeOptionId' => 564,            // Yes
  4096.                 'file' => 'fingerprint.svg',
  4097.                 'sortOrder' => 17,
  4098.                 'title' => 'Fingerprint sensor',
  4099.             ], [
  4100.                 'attributeId' => 63,            // Maximum resolution
  4101.                 'attributeOptionId' => 632,            // Full HD (1920 x 1080)
  4102.                 'file' => 'fullhd.svg',
  4103.                 'sortOrder' => 18,
  4104.                 'title' => 'Full HD display',
  4105.             ], [
  4106.                 'attributeId' => 12,            // Screen size
  4107.                 'attributeOptionId' => 201,            // 19
  4108.                 'file' => 'screen-size-19.svg',
  4109.                 'sortOrder' => 19,
  4110.                 'title' => '19"',
  4111.             ], [
  4112.                 'attributeId' => 12,            // Screen size
  4113.                 'attributeOptionId' => 1283,        // 20
  4114.                 'file' => 'screen-size-20.svg',
  4115.                 'sortOrder' => 20,
  4116.                 'title' => '20"',
  4117.             ], [
  4118.                 'attributeId' => 12,            // Screen size
  4119.                 'attributeOptionId' => 1019,        // 21.5
  4120.                 'file' => 'screen-size-21-3.svg',
  4121.                 'sortOrder' => 21,
  4122.                 'title' => '21.3"',
  4123.             ], [
  4124.                 'attributeId' => 12,            // Screen size
  4125.                 'attributeOptionId' => 402,        // 21.5
  4126.                 'file' => 'screen-size-21-5.svg',
  4127.                 'sortOrder' => 21,
  4128.                 'title' => '21.5"',
  4129.             ], [
  4130.                 'attributeId' => 12,            // Screen size
  4131.                 'attributeOptionId' => 202,            // 22
  4132.                 'file' => 'screen-size-22.svg',
  4133.                 'sortOrder' => 22,
  4134.                 'title' => '22"',
  4135.             ], [
  4136.                 'attributeId' => 12,            // Screen size
  4137.                 'attributeOptionId' => 203,            // 23
  4138.                 'file' => 'screen-size-23.svg',
  4139.                 'sortOrder' => 23,
  4140.                 'title' => '23"',
  4141.             ], [
  4142.                 'attributeId' => 12,            // Screen size
  4143.                 'attributeOptionId' => 204,            // 24
  4144.                 'file' => 'screen-size-24.svg',
  4145.                 'sortOrder' => 24,
  4146.                 'title' => '24"',
  4147.             ], [
  4148.                 'attributeId' => 12,            // Screen size
  4149.                 'attributeOptionId' => 205,            // 27
  4150.                 'file' => 'screen-size-27.svg',
  4151.                 'sortOrder' => 25,
  4152.                 'title' => '27"',
  4153.             ], [
  4154.                 'attributeId' => 10,            // ODD PC
  4155.                 'attributeOptionId' => 179,            // DVD-RW
  4156.                 'file' => 'optical-drive-dvd-rw.svg',
  4157.                 'sortOrder' => 25,
  4158.                 'title' => 'DVD-RW',
  4159.             ], [
  4160.                 'attributeId' => 11,            // ODD NB
  4161.                 'attributeOptionId' => 189,            // DVD-RW
  4162.                 'file' => 'optical-drive-dvd-rw.svg',
  4163.                 'sortOrder' => 25,
  4164.                 'title' => 'DVD-RW',
  4165.             ], [
  4166.                 'attributeId' => 46,            // Connector PC
  4167.                 'attributeOptionId' => 503,            // Displayport
  4168.                 'file' => 'displayport.svg',
  4169.                 'sortOrder' => 25,
  4170.                 'title' => 'display port',
  4171.             ], [
  4172.                 'attributeId' => 45,            // Connector NB
  4173.                 'attributeOptionId' => 547,            // Displayport
  4174.                 'file' => 'displayport.svg',
  4175.                 'sortOrder' => 25,
  4176.                 'title' => 'display port',
  4177.             ], [
  4178.                 'attributeId' => 68,            // Graphical input
  4179.                 'attributeOptionId' => 628,            // Displayport
  4180.                 'file' => 'displayport.svg',
  4181.                 'sortOrder' => 25,
  4182.                 'title' => 'display port',
  4183.             ], [
  4184.                 'attributeId' => 71,            // Speakers
  4185.                 'attributeOptionId' => 596,            // Built in
  4186.                 'file' => 'speakers.svg',
  4187.                 'sortOrder' => 25,
  4188.                 'title' => 'speakers',
  4189.             ], [
  4190.                 'attributeId' => 19,            // Webcam
  4191.                 'attributeOptionId' => 571,            // Webcam
  4192.                 'file' => 'webcam.svg',
  4193.                 'sortOrder' => 25,
  4194.                 'title' => 'web camera',
  4195.             ], [
  4196.                 'attributeId' => 19,            // Webcam
  4197.                 'attributeOptionId' => 574,            // Webcam HD
  4198.                 'file' => 'webcam.svg',
  4199.                 'sortOrder' => 25,
  4200.                 'title' => 'web camera',
  4201.             ], [
  4202.                 'attributeId' => 19,            // Webcam
  4203.                 'attributeOptionId' => 763,            // standard
  4204.                 'file' => 'webcam.svg',
  4205.                 'sortOrder' => 25,
  4206.                 'title' => 'web camera',
  4207.             ], [
  4208.                 'attributeId' => 19,            // Webcam
  4209.                 'attributeOptionId' => 1481,        // Full hd
  4210.                 'file' => 'webcam.svg',
  4211.                 'sortOrder' => 25,
  4212.                 'title' => 'web camera',
  4213.             ], [
  4214.                 'attributeId' => 34,       // Monitor - LED screen
  4215.                 'attributeOptionId' => 452,
  4216.                 'file' => 'led-screen.svg',
  4217.                 'sortOrder' => 30,
  4218.                 'title' => 'LED screen',
  4219.             ], [
  4220.                 'badge' => 'senior',    // Senior
  4221.                 'attributeId' => false,
  4222.                 'attributeOptionId' => false,
  4223.                 'file' => 'senior.svg',
  4224.                 'sortOrder' => 26,
  4225.             ], [
  4226.                 'badge' => 'gamer',    // Gamer
  4227.                 'attributeId' => false,
  4228.                 'attributeOptionId' => false,
  4229.                 'file' => 'gaming.svg',
  4230.                 'sortOrder' => 27,
  4231.             ], [
  4232.                 'badge' => 'internet',    // Internet
  4233.                 'attributeId' => false,
  4234.                 'attributeOptionId' => false,
  4235.                 'file' => 'internet.svg',
  4236.                 'sortOrder' => 28,
  4237.             ], [
  4238.                 'badge' => 'business',    // Work
  4239.                 'attributeId' => false,
  4240.                 'attributeOptionId' => false,
  4241.                 'file' => 'company.svg',
  4242.                 'sortOrder' => 29,
  4243.             ],
  4244.         ];
  4246.         $productIcons = [];
  4248.         foreach ($productAttributeOptions as $productAttributeOption) {
  4249.             $attributeOption = $productAttributeOption->getOption();
  4250.             $attribute = $attributeOption->getAttribute();
  4252.             foreach ($icons as $icon) {
  4253.                 if ((int)$icon['attributeId'] == (int)$attribute->getId()) {
  4254.                     if ((bool)$icon['attributeOptionId'] === false) {
  4255.                         $productIcons[$icon['file']] = $icon;
  4257.                         break;
  4258.                     } elseif ((int)$icon['attributeOptionId'] == (int)$attributeOption->getId()) {
  4259.                         $productIcons[$icon['file']] = $icon;
  4261.                         break;
  4262.                     }
  4263.                 }
  4264.             }
  4265.         }
  4267.         foreach ($badges as $badge) {
  4268.             foreach ($icons as $icon) {
  4269.                 if (isset($icon['badge']) && $icon['badge'] == $badge) {
  4270.                     $productIcons[$icon['file']] = $icon;
  4272.                     break;
  4273.                 }
  4274.             }
  4275.         }
  4277.         foreach ($icons as $icon) {
  4278.             if (isset($icon['productTypeId']) && $icon['productTypeId'] == $productTypeId) {
  4279.                 $productIcons[$icon['file']] = $icon;
  4280.             }
  4281.         }
  4283.         $sortOrder = [];
  4285.         foreach ($productIcons as $key => $value) {
  4286.             $sortOrder[$key] = $value['sortOrder'];
  4287.         }
  4289.         array_multisort($sortOrder, SORT_ASC, $productIcons);
  4291.         return array_slice($productIcons, 0, 5);
  4292.     }
  4294.     /**
  4295.      * @param string|null $detail
  4296.      * @return string
  4297.      */
  4298.     public static function createFormatedDetail(?string $detail): string
  4299.     {
  4300.         $result = '';
  4302.         $lines = preg_split('/\\n\\r*/', $detail);
  4304.         $is_list = false;
  4306.         foreach ($lines as $line) {
  4307.             $line = trim($line);
  4309.             $line = str_replace('[b]', '<strong>', $line);
  4310.             $line = str_replace('[/b]', '</strong>', $line);
  4312.             $line = str_replace('[bl]', '', $line);
  4313.             $line = str_replace('[/bl]', '', $line);
  4315.             $line = str_replace('[r]', '', $line);
  4316.             $line = str_replace('[/r]', '', $line);
  4318.             if ($line == '[l]' && !$is_list) {
  4319.                 $result .= '<ul>';
  4320.                 $is_list = true;
  4321.             } elseif ($line == '[/l]' && $is_list) {
  4322.                 $result .= '</ul>';
  4323.                 $is_list = false;
  4324.             } elseif ($is_list) {
  4325.                 $result .= '<li>' . $line . '</li>';
  4326.             } elseif ($line != '') {
  4327.                 $result .= '<span>' . $line . '</span>';
  4328.             }
  4329.         }
  4331.         return $result;
  4332.     }
  4334.     /**
  4335.      * @param Product $product
  4336.      * @param Domain $domain
  4337.      * @param int $limit
  4338.      * @return array
  4339.      * @throws \Doctrine\DBAL\DBALException
  4340.      * @throws \Doctrine\ORM\NoResultException
  4341.      * @throws \Doctrine\ORM\NonUniqueResultException
  4342.      */
  4343.     public function getRecommendedProducts(Product $product, Domain $domain, $limit = 4)
  4344.     {
  4345.         $upsellProducts = [];
  4347.         // Antivirus Software
  4348.         if (in_array($product->getType()->getId(), [52, 60, 107, 116])) {
  4349.             // Except Chromebook & Apple Products
  4350.             if (!in_array('Chromebook', $product->getBadges()) && $product->getVendor()->getId() !== 70) {
  4351.                 $products = $this->entityManager
  4352.                     ->createQuery("SELECT p 
  4353.                         FROM AtechNetCoreBundle:Product p 
  4354.                         LEFT JOIN p.productAttributes pa 
  4355.                         LEFT JOIN AtechNetCoreBundle:ProductMeta pm WITH pm.product = p.id AND pm.domain = :domain 
  4356.                         WHERE pm.active = 1 AND pm.orderable = 1 AND p.qualityStatus != :qualityStatus AND p.type = 82 AND p.vendor IN ( 141, 21 ) ORDER BY p.vendor DESC")
  4357.                     ->setParameters([
  4358.                         'domain' => $domain,
  4359.                         'qualityStatus' => Product::QualityStatus_Bazaar,
  4360.                     ])
  4361.                     ->getResult();
  4363.                 foreach ($products as $p) {
  4364.                     if (!isset($upsellProducts[$p->getId()]) && count($upsellProducts) < 3) {
  4365.                         $upsellProducts[$p->getId()] = $this->getStructuredDataForProduct($p, 'list');
  4366.                     }
  4367.                 }
  4368.             }
  4369.         }
  4371.         // Other Accessory
  4372.         $recommendedProductTypes = self::getRecommendedProductsStructureByProductType($product->getType()->getId());
  4374.         if (count($recommendedProductTypes) > 0) {
  4375.             $recommendedProducts = [];
  4377.             foreach ($recommendedProductTypes as $rpt) {
  4378.                 $where = "";
  4380.                 $where .= count($rpt['productTypeIDs']) > 0 ? "p.type IN (" . implode(',', $rpt['productTypeIDs']) . ")" : '';
  4382.                 if (count($rpt['productAttributeOptionIDs']) > 0) {
  4383.                     if ($where != "") {
  4384.                         $where .= " AND ";
  4385.                     }
  4387.                     $where .= count($rpt['productTypeIDs']) > 0 ? "pa.option IN (" . implode(',', $rpt['productAttributeOptionIDs']) . ")" : '';
  4388.                 }
  4390.                 if (count($rpt['productIDs']) > 0) {
  4391.                     if ($where != "") {
  4392.                         $where .= " AND ";
  4393.                     }
  4395.                     $where .= "p.id IN (" . implode(',', $rpt['productIDs']) . ")";
  4396.                 }
  4398.                 if ($rpt['priceRange']['min'] || $rpt['priceRange']['max']) {
  4399.                     if ($where != "") {
  4400.                         $where .= " AND ";
  4401.                     }
  4403.                     if ($rpt['priceRange']['min']) {
  4404.                         $where .= "pm.currentVatPrice >= " . $rpt['priceRange']['min'];
  4405.                     }
  4407.                     if ($rpt['priceRange']['max']) {
  4408.                         if ($rpt['priceRange']['min']) {
  4409.                             $where .= " AND ";
  4410.                         }
  4411.                         $where .= "pm.currentVatPrice <= " . $rpt['priceRange']['max'];
  4412.                     }
  4413.                 }
  4415.                 if ($rpt['matchingVendor']) {
  4416.                     if ($where != "") {
  4417.                         $where .= " AND ";
  4418.                     }
  4420.                     $where .= "p.vendor = " . $product->getVendor()->getId();
  4421.                 }
  4423.                 $products = $this
  4424.                     ->entityManager
  4425.                     ->createQuery("SELECT p
  4426.                         FROM AtechNetCoreBundle:Product p
  4427.                         LEFT JOIN p.productAttributes pa
  4428.                         LEFT JOIN AtechNetCoreBundle:ProductMeta pm WITH pm.product = p.id AND pm.domain = :domain
  4429.                         WHERE pm.active = 1 AND pm.orderable = 1 AND p.qualityStatus != :qualityStatus AND " . $where)
  4430.                     ->setParameters([
  4431.                         'domain' => $domain,
  4432.                         'qualityStatus' => Product::QualityStatus_Bazaar,
  4433.                     ])
  4434.                     ->setMaxResults($rpt['limit'])
  4435.                     ->getResult();
  4437.                 foreach ($products as $p) {
  4438.                     if (!isset($recommendedProducts[$p->getId()]) && count($recommendedProducts) < $limit) {
  4439.                         $recommendedProducts[$p->getId()] = $p;
  4440.                     }
  4441.                 }
  4442.             }
  4444.             foreach ($recommendedProducts as $p) {
  4445.                 $upsellProducts[$p->getId()] = $this->getStructuredDataForProduct($p, 'list');
  4446.             }
  4448.             $upsellProductCount = count($upsellProducts);
  4450.             if ($upsellProductCount < $limit && $product->getType()->getId() != 41) {
  4451.                 $missingProductsCount = $limit - $upsellProductCount;
  4453.                 $additionalUpsellProducts = $this->getSimilarProducts($product->getId(), $missingProductsCount);
  4455.                 foreach ($additionalUpsellProducts as $ap) {
  4456.                     $upsellProducts[] = $ap;
  4457.                 }
  4458.             }
  4459.         }
  4461.         return $upsellProducts;
  4462.     }
  4464.     /**
  4465.      * @param int $productTypeId
  4466.      * @param CacheItemPoolInterface $cache
  4467.      * @param Domain $domain
  4468.      * @param Request $request
  4469.      * @param SeoUrlHelper $seoUrlHelper
  4470.      * @param EntityManagerInterface $entityManager
  4471.      * @return array
  4472.      */
  4473.     public function getRecommendedProductCategories(int $productTypeId, CacheItemPoolInterface $cache, Domain $domain, Request $request, SeoUrlHelper $seoUrlHelper, EntityManagerInterface $entityManager)
  4474.     {
  4475.         $recommendedProductCategoriesCacheKey = 'product.v1.recommendedProductCategories.' . $productTypeId . '.' . $domain->getId() . '.' . $request->getLocale();
  4476.         $recommendedProductCategoriesCacheItem = $cache->getItem($recommendedProductCategoriesCacheKey);
  4478.         if (!$recommendedProductCategoriesCacheItem->isHit()) {
  4479.             $recommendedCategories = [];
  4480.             $language = $domain->getLanguage(); // TODO: Localise Title of Categories
  4482.             foreach (self::getRecommendedProductTypesStructure($domain->getId(), $productTypeId) as $categoryId) {
  4483.                 $category = $entityManager->getRepository(CategoryPage::class)->findOneById($categoryId);
  4485.                 /**
  4486.                  * @var CategoryPage $category
  4487.                  */
  4488.                 if ($category) {
  4489.                     // Parent
  4490.                     if ($category->getParentCategory()) {
  4491.                         $parentId = $category->getParentCategory()->getId();
  4492.                     } else {
  4493.                         $parentId = 0;
  4494.                     }
  4496.                     $recommendedCategories[] = [
  4497.                         'id' => $category->getId(),
  4498.                         'title' => $category->getMetaByLanguage($language)->getTitle(),
  4499.                         'href' => $seoUrlHelper->link('category', [
  4500.                             'path'      => ($parentId > 0 ? $parentId . '_' : '') . $category->getId(), 
  4501.                             'isBazaar'  => $category->isShowOnlyBazaar()
  4502.                         ]),
  4503.                     ];
  4504.                 }
  4505.             }
  4507.             $recommendedProductCategoriesCacheItem->set($recommendedCategories);
  4508.             $recommendedProductCategoriesCacheItem->expiresAfter(604800);
  4510.             $cache->save($recommendedProductCategoriesCacheItem);
  4512.             return $recommendedCategories;
  4513.         } else {
  4514.             return $recommendedProductCategoriesCacheItem->get();
  4515.         }
  4516.     }
  4518.     /**
  4519.      * @param $requestUrl
  4520.      * @param $structuredDataResults
  4521.      * @param $imagePlaceholder
  4522.      * @return array
  4523.      */
  4524.     public function convertStructuredDataToListViewData($requestUrl, $structuredDataResults, $imagePlaceholder): array
  4525.     {
  4526.         $convertedData = [];
  4528.         foreach ($structuredDataResults as $result) {
  4529.             $image = $imagePlaceholder;
  4531.             if (is_object($result['images'])) {
  4532.                 $image = $this->getImage($result['images'], 'product/' . $result['code'])->resize(Image::PRODUCT_LIST_THUMB_WIDTH, Image::PRODUCT_LIST_THUMB_HEIGHT);
  4533.             }
  4535.             $result['title'] = in_array($requestUrl->getDomainId(), [Domain::DOMAIN_ID_RT_EU, Domain::DOMAIN_ID_WS_EU]) ?
  4536.                 str_replace([' (Quality: Bazar)', ' (Quality: Bazár)', ' (Quality: Bazár, '], ['', '', ' ('], $result['title']) :
  4537.                 $result['title'];
  4539.             $convertedData[] = [
  4540.                 'id' => $result['id'],
  4541.                 'title' => ProductHelper::shortenProductName($result['vendor'], $result['title']),
  4542.                 'vendor' => $result['vendor'],
  4543.                 'vendorId' => $result['vendorId'],
  4544.                 'typeId' => $result['productTypeId'],
  4545.                 'labels' => $result['badges'],
  4546.                 'price' => $result['vatPrice'],
  4547.                 'special' => ($result['isDiscounted'] ? $result['discountVatPrice'] : false),
  4548.                 'rawPrice' => $result['rawPrice'],
  4549.                 'rawDiscountPrice' => $result['rawDiscountPrice'],
  4550.                 'image' => $image,
  4551.                 'attributes' => $result['attributes'],
  4552.                 'attributesListTxt' => $result['attributesListTxt'],
  4553.                 'available' => $result['availableQty'],
  4554.                 'href' => $requestUrl->link('product', [
  4555.                     'product_id' => $result['id'], 
  4556.                     'isBazaar'   => $result['isBazaar'] ?? 0
  4557.                 ]),
  4558.                 'active' => $result['active'],
  4559.                 'timedSalesActive' => $result['timedSalesActive'],
  4560.                 'reviewCount' => $result['reviewCount'],
  4561.                 'reviewStars' => $result['reviewStars'],
  4562.                 'reviews' => $result['reviews'],
  4563.                 'freeShipping' => $result['freeShipping'],
  4564.                 'labelOS' => $this->getOSLabel($result),
  4565.                 'qualityStatusId' => $result['qualityStatusId'],
  4566.                 'qualityStatusTitle' => Product::getQualityStatusChoices()[$result['qualityStatusId']],
  4567.                 'isBestseller' => $result['isBestseller'] ?? false
  4568.             ];
  4569.         }
  4571.         return $convertedData;
  4572.     }
  4574.     /**
  4575.      * @param string $productGroupTitle
  4576.      * @param Domain $domain
  4577.      * @return array{
  4578.      *      productGroupProducts: array<int,Product>, 
  4579.      *      productGroupCodesAdded: array<int,string>, 
  4580.      *      productsToDisplay: int, 
  4581.      *      isRandom: bool|null, 
  4582.      *      customData: array<int, array{title: string, description?: string}>}
  4583.      * }
  4584.      */
  4585.     public function getProductGroupProducts(string $productGroupTitle, Domain $domain): array
  4586.     {
  4587.         /** @var ProductGroup|null $productGroup */
  4588.         $productGroup = $this->entityManager->getRepository(ProductGroup::class)->findOneBy([
  4589.             'title'  => $productGroupTitle, 
  4590.             'domain' => $domain
  4591.         ]);
  4593.         $productGroupProducts = [];
  4594.         $productGroupCodesAdded = [];
  4595.         $customData = [];
  4597.         if ( !is_null($productGroup) ) {
  4598.             /** @var ProductGroupMember $member */
  4599.             foreach ($productGroup->getMembers() as $member) {
  4600.                 if (count($productGroupCodesAdded) >= $productGroup->getProductsToDisplay()) {
  4601.                     continue;
  4602.                 }
  4604.                 $product = $member->getProduct();
  4605.                 $productMeta = $product->getDomainMeta($domain);
  4607.                 if (!is_null($member->getTitle())) {
  4608.                     $customData[$product->getId()]['title'] = $member->getTitle();
  4609.                 }
  4611.                 if (!is_null($member->getDescription())) {
  4612.                     $customData[$product->getId()]['description'] = $member->getDescription();
  4613.                 }
  4615.                 if ( str_contains($productGroupTitle, '.bazaar') ) {
  4616.                     if ( $product->getAvailable() > 0 
  4617.                         && $productMeta->isActive() 
  4618.                         && $productMeta->isOrderable() 
  4619.                         && $productMeta->isListed() 
  4620.                         && $product->getQualityStatus() == Product::QualityStatus_Bazaar 
  4621.                     ) {
  4622.                         $productGroupProducts[] = $product;
  4623.                         $productGroupCodesAdded[] = $product->getCode();
  4624.                     }                    
  4625.                 } elseif ($productGroupTitle == 'homepage.main' && $domain->getType() == 'retail') {
  4626.                     if ($product->getAvailable() > 0
  4627.                         && $productMeta->isActive()
  4628.                         && $productMeta->isOrderable()
  4629.                         && $productMeta->isListed()
  4630.                         && $product->getQualityStatus() != Product::QualityStatus_Bazaar)
  4631.                     {
  4632.                         $productGroupProducts[] = $product;
  4633.                         $productGroupCodesAdded[] = $product->getCode();
  4634.                     }
  4635.                 } else {
  4636.                     if ($product->getAvailable() > 0
  4637.                         && $productMeta->isActive()
  4638.                         && $productMeta->isOrderable()
  4639.                         && $productMeta->isListed())
  4640.                     {
  4641.                         $productGroupProducts[] = $product;
  4642.                         $productGroupCodesAdded[] = $product->getCode();
  4643.                     }
  4644.                 }
  4645.             }
  4646.         }
  4648.         return [
  4649.             'productGroupProducts' => $productGroupProducts,
  4650.             'productGroupCodesAdded' => $productGroupCodesAdded,
  4651.             'productsToDisplay' => !is_null($productGroup) ? $productGroup->getProductsToDisplay() : 0,
  4652.             'isRandom' => $productGroup?->getShowRandom(),
  4653.             'customData' => $customData,
  4654.         ];
  4655.     }
  4657.     /**
  4658.      * @param Domain $domain
  4659.      * @param integer $categoryGroupType
  4660.      * @param SeoUrlHelper $seoUrlHelper
  4661.      * @return array<string,string|bool|int>
  4662.      */
  4663.     public function getCategoryGroup(Domain $domain, int $categoryGroupType, SeoUrlHelper $seoUrlHelper): array
  4664.     {
  4665.         $categoryGroup = $this->entityManager->getRepository(CategoryGroup::class)->findOneBy([
  4666.             'type' => $categoryGroupType,
  4667.             'domain' => $domain,
  4668.             'active' => true,
  4669.         ]);
  4671.         $result = [];
  4673.         if (!is_null($categoryGroup)) {
  4674.             if (in_array($categoryGroup->getType(), [CategoryGroup::CG_TYPE_FEATURED_CATEGORIES_UPPER, CategoryGroup::CG_TYPE_FEATURED_CATEGORIES_LOWER])) {
  4675.                 $categoryMember = $categoryGroup->getCategories()->count() > 0 ? $categoryGroup->getCategories()->first() : [];
  4677.                 $result['title'] = $categoryMember->getTitle();
  4678.                 $result['description'] = $categoryMember->getDescription();
  4679.                 $result['isWizard'] = $categoryMember->isWizard();
  4680.                 $result['href'] = $categoryMember->isWizard() ? '/wizard' : $seoUrlHelper->link('category', [
  4681.                     'path' => $categoryMember->getCategory()->getId(),
  4682.                     'isBazaar'  => $categoryMember->getCategory()->isShowOnlyBazaar()
  4683.                 ]);
  4685.                 $image = $categoryMember->getImage();
  4687.                 $imageFilenames = [
  4688.                     'filename' => $image ? $image->getFilename() : '',
  4689.                     'originalName' => $image ? $image->getOriginalName() : '',
  4690.                 ];
  4692.                 $result['image'] = $image ? $this->getImage($imageFilenames, CategoryGroupMemberImage::CLASS_IMAGE_DIRECTORY)->resize(Image::HEADER_FEATURED_CATEGORY_WIDTH, Image::HEADER_FEATURED_CATEGORY_HEIGHT) : '';
  4693.             }
  4694.         }
  4696.         return $result;
  4697.     }
  4699.     /**
  4700.      * @param $vendor
  4701.      * @param $name
  4702.      * @return string
  4703.      */
  4704.     public static function shortenProductName($vendor, $name): string
  4705.     {
  4706.         $title = $name;
  4707.         $maxFullTitleLength = 75;
  4709.         $longTitle = $vendor . ' ' . $name;
  4711.         if (mb_strlen($longTitle) > $maxFullTitleLength) {
  4712.             $vendorLength = mb_strlen($vendor . ' ');
  4714.             $length = $maxFullTitleLength - $vendorLength;
  4715.             $title = mb_substr($title, 0, $length) . '...';
  4716.         }
  4718.         return $title;
  4719.     }
  4721.     /**
  4722.      * @param Product $product
  4723.      * @param Domain $domain
  4724.      * @return bool
  4725.      */
  4726.     public static function isFlashSaleValidForProduct(Product $product, Domain $domain): bool
  4727.     {
  4728.         $pm = $product->getDomainMeta($domain);
  4729.         $currentDateTime = new \DateTime();
  4731.         if ($product->getAvailable() > 0 && $pm->isActive() && $pm->isOrderable() && $pm->isListed() && $pm->isDiscounted()
  4732.             && (
  4733.                 (!is_null($pm->getSaleStart()) && !is_null($pm->getSaleEnd()) && $pm->getSaleStart() < $currentDateTime && $currentDateTime < $pm->getSaleEnd())
  4734.                 || (!is_null($pm->getSaleStart()) && is_null($pm->getSaleEnd()) && $pm->getSaleStart() < $currentDateTime)
  4735.                 || (is_null($pm->getSaleStart()) && !is_null($pm->getSaleEnd()) && $currentDateTime < $pm->getSaleEnd())
  4736.             )
  4737.         ) {
  4738.             return true;
  4739.         }
  4741.         return false;
  4742.     }
  4744.     /**
  4745.      * @param $product
  4746.      * @param bool $skipType
  4747.      * @return string
  4748.      */
  4749.     public static function getHeadingTitle($product, bool $skipType = false)
  4750.     {
  4751.         $productType = $skipType ? '' : ' ' . $product['productType'];
  4752.         return $product['title'] . $productType . ' - ' . $product['code'];
  4753.     }
  4755.     /**
  4756.      * @param $product
  4757.      * @param $translator
  4758.      */
  4759.     public static function getLongTitleWithConfig($product, $translator)
  4760.     {
  4761.         if ($product['qualityStatusId'] != Product::QualityStatus_New) {
  4762.             $isTinyPc = self::hasBadgeByStructuredData('Tiny PC', $product['badgesRaw']);
  4764.             switch ($product['productTypeId']) {
  4765.                 case ProductType::PRODUCT_TYPE_ID_SMARTPHONE:
  4766.                     $h1Title = $product['title'] . ' - ' . $product['code'];
  4767.                     $h1Title .= (!in_array($product['qualityStatusId'], [Product::QualityStatus_New, Product::QualityStatus_Platinum]) ? ' (' . $translator->trans('refurbished') . ')' : '');
  4768.                     break;
  4769.                 case ProductType::PRODUCT_TYPE_ID_MONITOR:
  4770.                     $h1Title = $product['title'] . ' - ' . $product['code'];
  4771.                     break;
  4772.                 case ProductType::PRODUCT_TYPE_ID_NOTEBOOK:
  4773.                     $h1Title = $product['title'] . ' - ' . $product['code'];
  4774.                     break;
  4775.                 case ProductType::PRODUCT_TYPE_ID_PC:
  4776.                 case ProductType::PRODUCT_TYPE_ID_PC_SET:
  4777.                     $h1Title = $product['title'] . ' - ' . $product['code'];
  4778.                     break;
  4779.                 case ProductType::PRODUCT_TYPE_ID_ALL_IN_ONE:
  4780.                     $h1Title = $product['title'] . ' - ' . $product['code'];
  4781.                     break;
  4782.                 default:
  4783.                     $h1Title = $product['title'] . ' - ' . $product['code'];
  4784.             }
  4785.         } else {
  4786.             $h1Title = $product['title'] . ' - ' . $product['code'];
  4787.         }
  4789.         return $h1Title;
  4790.     }
  4792.     /**
  4793.      * @param array $attributes
  4794.      * @return string
  4795.      */
  4796.     public static function getConfigurationInTitle($attributes)
  4797.     {
  4798.         $configurationInTitle = '';
  4799.         $configsToAdd = [
  4800.             32, 33, 35, 36, // Processors
  4801.             25, // VGA
  4802.             3, // RAM PC
  4803.             4, // RAM NB
  4804.             5, // SSD
  4805.             6, 7, 8, 9, // HDD
  4806.             12, // Screen size
  4807.             63, // Display resolution
  4808.             118, // IPS
  4809.         ];
  4811.         foreach ($configsToAdd as $configToAdd) {
  4812.             if (isset($attributes[$configToAdd])) {
  4813.                 if ($configurationInTitle != '') {
  4814.                     $configurationInTitle .= ', ';
  4815.                 }
  4817.                 $shortTitle = reset($attributes[$configToAdd]['options'])['shortTitle'];
  4819.                 $type = '';
  4820.                 if (in_array(substr($shortTitle, 0, 2), ['i3', 'i5', 'i7'])) {
  4821.                     $type = 'Intel Core ';
  4822.                 }
  4824.                 $postFix = '';
  4825.                 if ($configToAdd == 5) { // SSD
  4826.                     $postFix = ' SSD';
  4827.                 }
  4828.                 if (in_array($configToAdd, [6, 7, 8, 9])) { // HDD
  4829.                     $postFix = ' HDD';
  4830.                 }
  4832.                 if (in_array($configToAdd, [3, 4])) { // RAM
  4833.                     $postFix = ' RAM';
  4834.                 }
  4836.                 $configurationInTitle .= $type . $shortTitle . $postFix;
  4837.             }
  4838.         }
  4840.         return $configurationInTitle;
  4841.     }
  4843.     /**
  4844.      * @param $badgeTocheck
  4845.      * @param $badges
  4846.      * @return bool
  4847.      */
  4848.     private static function hasBadgeByStructuredData($badgeTocheck, $badges)
  4849.     {
  4850.         $hasBadge = false;
  4852.         foreach ($badges as $badge) {
  4853.             if (!$hasBadge && $badge == $badgeTocheck) {
  4854.                 $hasBadge = true;
  4855.             }
  4856.         }
  4858.         return $hasBadge;
  4859.     }
  4861.     /**
  4862.      * @param $productTypeId
  4863.      * @return array|array[]
  4864.      */
  4865.     private static function getRecommendedProductsStructureByProductType($productTypeId)
  4866.     {
  4867.         switch ($productTypeId) {
  4868.             case 60: // PC
  4869.             case 107: // PC SET
  4870.             case 116: // All in one
  4871.                 $recommendedProductTypes = [
  4872.                     [
  4873.                         // basic wired mouse
  4874.                         'productTypeIDs' => [
  4875.                             46,
  4876.                         ],
  4877.                         'productAttributeOptionIDs' => [
  4878.                             2020,
  4879.                         ],
  4880.                         'productIDs' => [],
  4881.                         'priceRange' => [
  4882.                             'min' => false,
  4883.                             'max' => false,
  4884.                         ],
  4885.                         'matchingVendor' => false,
  4886.                         'limit' => 4,
  4887.                     ],
  4888.                     [
  4889.                         // basic wireless mouse
  4890.                         'productTypeIDs' => [
  4891.                             46,
  4892.                         ],
  4893.                         'productAttributeOptionIDs' => [
  4894.                             2021,
  4895.                         ],
  4896.                         'productIDs' => [],
  4897.                         'priceRange' => [
  4898.                             'min' => false,
  4899.                             'max' => false,
  4900.                         ],
  4901.                         'matchingVendor' => false,
  4902.                         'limit' => 4,
  4903.                     ],
  4904.                     [
  4905.                         // middle wired mouse
  4906.                         'productTypeIDs' => [
  4907.                             46,
  4908.                         ],
  4909.                         'productAttributeOptionIDs' => [
  4910.                             2020,
  4911.                         ],
  4912.                         'productIDs' => [],
  4913.                         'priceRange' => [
  4914.                             'min' => false,
  4915.                             'max' => false,
  4916.                         ],
  4917.                         'matchingVendor' => false,
  4918.                         'limit' => 4,
  4919.                     ],
  4920.                     [
  4921.                         // middle wireless mouse
  4922.                         'productTypeIDs' => [
  4923.                             46,
  4924.                         ],
  4925.                         'productAttributeOptionIDs' => [
  4926.                             2021,
  4927.                         ],
  4928.                         'productIDs' => [],
  4929.                         'priceRange' => [
  4930.                             'min' => false,
  4931.                             'max' => false,
  4932.                         ],
  4933.                         'matchingVendor' => false,
  4934.                         'limit' => 4,
  4935.                     ],
  4936.                     [
  4937.                         // gamer wired mouse
  4938.                         'productTypeIDs' => [
  4939.                             46,
  4940.                         ],
  4941.                         'productAttributeOptionIDs' => [
  4942.                             2020,
  4943.                         ],
  4944.                         'productIDs' => [],
  4945.                         'priceRange' => [
  4946.                             'min' => false,
  4947.                             'max' => false,
  4948.                         ],
  4949.                         'matchingVendor' => false,
  4950.                         'limit' => 4,
  4951.                     ],
  4952.                     [
  4953.                         // gamer wireless mouse
  4954.                         'productTypeIDs' => [
  4955.                             46,
  4956.                         ],
  4957.                         'productAttributeOptionIDs' => [
  4958.                             2021,
  4959.                         ],
  4960.                         'productIDs' => [],
  4961.                         'priceRange' => [
  4962.                             'min' => false,
  4963.                             'max' => false,
  4964.                         ],
  4965.                         'matchingVendor' => false,
  4966.                         'limit' => 2,
  4967.                     ],
  4968.                     [
  4969.                         // wireless keyboard
  4970.                         'productTypeIDs' => [
  4971.                             38,
  4972.                         ],
  4973.                         'productAttributeOptionIDs' => [
  4974.                             2021,
  4975.                         ],
  4976.                         'productIDs' => [],
  4977.                         'priceRange' => [
  4978.                             'min' => false,
  4979.                             'max' => false,
  4980.                         ],
  4981.                         'matchingVendor' => false,
  4982.                         'limit' => 4,
  4983.                     ],
  4984.                     [
  4985.                         // wired keyboard
  4986.                         'productTypeIDs' => [
  4987.                             38,
  4988.                         ],
  4989.                         'productAttributeOptionIDs' => [
  4990.                             2020,
  4991.                         ],
  4992.                         'productIDs' => [],
  4993.                         'priceRange' => [
  4994.                             'min' => false,
  4995.                             'max' => false,
  4996.                         ],
  4997.                         'matchingVendor' => false,
  4998.                         'limit' => 4,
  4999.                     ],
  5000.                     [
  5001.                         // gamer keyboard
  5002.                         'productTypeIDs' => [
  5003.                             38,
  5004.                         ],
  5005.                         'productAttributeOptionIDs' => [],
  5006.                         'productIDs' => [],
  5007.                         'priceRange' => [
  5008.                             'min' => false,
  5009.                             'max' => false,
  5010.                         ],
  5011.                         'matchingVendor' => false,
  5012.                         'limit' => 2,
  5013.                     ],
  5014.                     [
  5015.                         // wireless headphones
  5016.                         'productTypeIDs' => [
  5017.                             35,
  5018.                         ],
  5019.                         'productAttributeOptionIDs' => [
  5020.                             2021,
  5021.                         ],
  5022.                         'productIDs' => [],
  5023.                         'priceRange' => [
  5024.                             'min' => false,
  5025.                             'max' => false,
  5026.                         ],
  5027.                         'matchingVendor' => false,
  5028.                         'limit' => 4,
  5029.                     ],
  5030.                     [
  5031.                         // wired headphones
  5032.                         'productTypeIDs' => [
  5033.                             35,
  5034.                         ],
  5035.                         'productAttributeOptionIDs' => [
  5036.                             2020,
  5037.                         ],
  5038.                         'productIDs' => [],
  5039.                         'priceRange' => [
  5040.                             'min' => false,
  5041.                             'max' => false,
  5042.                         ],
  5043.                         'matchingVendor' => false,
  5044.                         'limit' => 4,
  5045.                     ],
  5046.                     [
  5047.                         // wireless headphones
  5048.                         'productTypeIDs' => [
  5049.                             35,
  5050.                         ],
  5051.                         'productAttributeOptionIDs' => [
  5052.                             2021,
  5053.                         ],
  5054.                         'productIDs' => [],
  5055.                         'priceRange' => [
  5056.                             'min' => false,
  5057.                             'max' => false,
  5058.                         ],
  5059.                         'matchingVendor' => false,
  5060.                         'limit' => 4,
  5061.                     ],
  5062.                     [
  5063.                         // wired headphones
  5064.                         'productTypeIDs' => [
  5065.                             35,
  5066.                         ],
  5067.                         'productAttributeOptionIDs' => [
  5068.                             2020,
  5069.                         ],
  5070.                         'productIDs' => [],
  5071.                         'priceRange' => [
  5072.                             'min' => false,
  5073.                             'max' => false,
  5074.                         ],
  5075.                         'matchingVendor' => false,
  5076.                         'limit' => 4,
  5077.                     ],
  5078.                     [
  5079.                         // headset combo
  5080.                         'productTypeIDs' => [
  5081.                             35,
  5082.                         ],
  5083.                         'productAttributeOptionIDs' => [
  5084.                             2021,
  5085.                         ],
  5086.                         'productIDs' => [],
  5087.                         'priceRange' => [
  5088.                             'min' => false,
  5089.                             'max' => false,
  5090.                         ],
  5091.                         'matchingVendor' => false,
  5092.                         'limit' => 2,
  5093.                     ],
  5094.                     [
  5095.                         // webcam
  5096.                         'productTypeIDs' => [
  5097.                             104,
  5098.                         ],
  5099.                         'productAttributeOptionIDs' => [],
  5100.                         'productIDs' => [],
  5101.                         'priceRange' => [
  5102.                             'min' => false,
  5103.                             'max' => false,
  5104.                         ],
  5105.                         'matchingVendor' => false,
  5106.                         'limit' => 2,
  5107.                     ],
  5108.                     [
  5109.                         // Speaker
  5110.                         'productTypeIDs' => [
  5111.                             84,
  5112.                         ],
  5113.                         'productAttributeOptionIDs' => [],
  5114.                         'productIDs' => [],
  5115.                         'priceRange' => [
  5116.                             'min' => false,
  5117.                             'max' => false,
  5118.                         ],
  5119.                         'matchingVendor' => false,
  5120.                         'limit' => 2,
  5121.                     ],
  5122.                     [
  5123.                         // External HDD adapter
  5124.                         'productTypeIDs' => [
  5125.                             124,
  5126.                         ],
  5127.                         'productAttributeOptionIDs' => [],
  5128.                         'productIDs' => [],
  5129.                         'priceRange' => [
  5130.                             'min' => false,
  5131.                             'max' => false,
  5132.                         ],
  5133.                         'matchingVendor' => false,
  5134.                         'limit' => 2,
  5135.                     ],
  5136.                     [
  5137.                         // Furbify mouse pad
  5138.                         'productTypeIDs' => [],
  5139.                         'productAttributeOptionIDs' => [],
  5140.                         'productIDs' => [
  5141.                             14731,
  5142.                         ],
  5143.                         'priceRange' => [
  5144.                             'min' => false,
  5145.                             'max' => false,
  5146.                         ],
  5147.                         'matchingVendor' => false,
  5148.                         'limit' => 0,
  5149.                     ],
  5150.                     [
  5151.                         // USB wifi
  5152.                         'productTypeIDs' => [
  5153.                             102,
  5154.                         ],
  5155.                         'productAttributeOptionIDs' => [],
  5156.                         'productIDs' => [],
  5157.                         'priceRange' => [
  5158.                             'min' => false,
  5159.                             'max' => false,
  5160.                         ],
  5161.                         'matchingVendor' => false,
  5162.                         'limit' => 2,
  5163.                     ],
  5164.                     [
  5165.                         // Compressed AIR
  5166.                         'productTypeIDs' => [],
  5167.                         'productAttributeOptionIDs' => [],
  5168.                         'productIDs' => [
  5169.                             15198,
  5170.                         ],
  5171.                         'priceRange' => [
  5172.                             'min' => false,
  5173.                             'max' => false,
  5174.                         ],
  5175.                         'matchingVendor' => false,
  5176.                         'limit' => 2,
  5177.                     ],
  5178.                 ];
  5179.                 break;
  5180.             case 52: // Notebook
  5181.                 $recommendedProductTypes = [
  5182.                     [
  5183.                         // basic wired mouse
  5184.                         'productTypeIDs' => [
  5185.                             46,
  5186.                         ],
  5187.                         'productAttributeOptionIDs' => [
  5188.                             2020,
  5189.                         ],
  5190.                         'productIDs' => [],
  5191.                         'priceRange' => [
  5192.                             'min' => false,
  5193.                             'max' => false,
  5194.                         ],
  5195.                         'matchingVendor' => false,
  5196.                         'limit' => 4,
  5197.                     ],
  5198.                     [
  5199.                         // basic wireless mouse
  5200.                         'productTypeIDs' => [
  5201.                             46,
  5202.                         ],
  5203.                         'productAttributeOptionIDs' => [
  5204.                             2021,
  5205.                         ],
  5206.                         'productIDs' => [],
  5207.                         'priceRange' => [
  5208.                             'min' => false,
  5209.                             'max' => false,
  5210.                         ],
  5211.                         'matchingVendor' => false,
  5212.                         'limit' => 4,
  5213.                     ],
  5214.                     [
  5215.                         // middle wired mouse
  5216.                         'productTypeIDs' => [
  5217.                             46,
  5218.                         ],
  5219.                         'productAttributeOptionIDs' => [
  5220.                             2020,
  5221.                         ],
  5222.                         'productIDs' => [],
  5223.                         'priceRange' => [
  5224.                             'min' => false,
  5225.                             'max' => false,
  5226.                         ],
  5227.                         'matchingVendor' => false,
  5228.                         'limit' => 4,
  5229.                     ],
  5230.                     [
  5231.                         // middle wireless mouse
  5232.                         'productTypeIDs' => [
  5233.                             46,
  5234.                         ],
  5235.                         'productAttributeOptionIDs' => [
  5236.                             2021,
  5237.                         ],
  5238.                         'productIDs' => [],
  5239.                         'priceRange' => [
  5240.                             'min' => false,
  5241.                             'max' => false,
  5242.                         ],
  5243.                         'matchingVendor' => false,
  5244.                         'limit' => 4,
  5245.                     ],
  5246.                     [
  5247.                         // wireless keyboard
  5248.                         'productTypeIDs' => [
  5249.                             38,
  5250.                         ],
  5251.                         'productAttributeOptionIDs' => [
  5252.                             2021,
  5253.                         ],
  5254.                         'productIDs' => [],
  5255.                         'priceRange' => [
  5256.                             'min' => false,
  5257.                             'max' => false,
  5258.                         ],
  5259.                         'matchingVendor' => false,
  5260.                         'limit' => 4,
  5261.                     ],
  5262.                     [
  5263.                         // wireless headphones
  5264.                         'productTypeIDs' => [
  5265.                             35,
  5266.                         ],
  5267.                         'productAttributeOptionIDs' => [
  5268.                             2021,
  5269.                         ],
  5270.                         'productIDs' => [],
  5271.                         'priceRange' => [
  5272.                             'min' => false,
  5273.                             'max' => false,
  5274.                         ],
  5275.                         'matchingVendor' => false,
  5276.                         'limit' => 4,
  5277.                     ],
  5278.                     [
  5279.                         // wired headphones
  5280.                         'productTypeIDs' => [
  5281.                             35,
  5282.                         ],
  5283.                         'productAttributeOptionIDs' => [
  5284.                             2020,
  5285.                         ],
  5286.                         'productIDs' => [],
  5287.                         'priceRange' => [
  5288.                             'min' => false,
  5289.                             'max' => false,
  5290.                         ],
  5291.                         'matchingVendor' => false,
  5292.                         'limit' => 4,
  5293.                     ],
  5294.                     [
  5295.                         // wireless headphones
  5296.                         'productTypeIDs' => [
  5297.                             35,
  5298.                         ],
  5299.                         'productAttributeOptionIDs' => [
  5300.                             2021,
  5301.                         ],
  5302.                         'productIDs' => [],
  5303.                         'priceRange' => [
  5304.                             'min' => false,
  5305.                             'max' => false,
  5306.                         ],
  5307.                         'matchingVendor' => false,
  5308.                         'limit' => 4,
  5309.                     ],
  5310.                     [
  5311.                         // wired headphones
  5312.                         'productTypeIDs' => [
  5313.                             35,
  5314.                         ],
  5315.                         'productAttributeOptionIDs' => [
  5316.                             2020,
  5317.                         ],
  5318.                         'productIDs' => [],
  5319.                         'priceRange' => [
  5320.                             'min' => false,
  5321.                             'max' => false,
  5322.                         ],
  5323.                         'matchingVendor' => false,
  5324.                         'limit' => 4,
  5325.                     ],
  5326.                     [
  5327.                         // headset combo
  5328.                         'productTypeIDs' => [
  5329.                             35,
  5330.                         ],
  5331.                         'productAttributeOptionIDs' => [
  5332.                             2021,
  5333.                         ],
  5334.                         'productIDs' => [],
  5335.                         'priceRange' => [
  5336.                             'min' => false,
  5337.                             'max' => false,
  5338.                         ],
  5339.                         'matchingVendor' => false,
  5340.                         'limit' => 2,
  5341.                     ],
  5342.                     [
  5343.                         // webcam
  5344.                         'productTypeIDs' => [
  5345.                             104,
  5346.                         ],
  5347.                         'productAttributeOptionIDs' => [],
  5348.                         'productIDs' => [],
  5349.                         'priceRange' => [
  5350.                             'min' => false,
  5351.                             'max' => false,
  5352.                         ],
  5353.                         'matchingVendor' => false,
  5354.                         'limit' => 2,
  5355.                     ],
  5356.                     [
  5357.                         // HDMI cable
  5358.                         'productTypeIDs' => [
  5359.                             7,
  5360.                         ],
  5361.                         'productAttributeOptionIDs' => [],
  5362.                         'productIDs' => [],
  5363.                         'priceRange' => [
  5364.                             'min' => false,
  5365.                             'max' => false,
  5366.                         ],
  5367.                         'matchingVendor' => false,
  5368.                         'limit' => 2,
  5369.                     ],
  5370.                     [
  5371.                         // Notebook cooler
  5372.                         'productTypeIDs' => [
  5373.                             126,
  5374.                         ],
  5375.                         'productAttributeOptionIDs' => [],
  5376.                         'productIDs' => [],
  5377.                         'priceRange' => [
  5378.                             'min' => false,
  5379.                             'max' => false,
  5380.                         ],
  5381.                         'matchingVendor' => false,
  5382.                         'limit' => 2,
  5383.                     ],
  5384.                     [
  5385.                         // Notebook bag
  5386.                         'productTypeIDs' => [
  5387.                             54,
  5388.                         ],
  5389.                         'productAttributeOptionIDs' => [],
  5390.                         'productIDs' => [],
  5391.                         'priceRange' => [
  5392.                             'min' => false,
  5393.                             'max' => false,
  5394.                         ],
  5395.                         'matchingVendor' => false,
  5396.                         'limit' => 2,
  5397.                     ],
  5398.                     [
  5399.                         // External HDD adapter
  5400.                         'productTypeIDs' => [
  5401.                             124,
  5402.                         ],
  5403.                         'productAttributeOptionIDs' => [],
  5404.                         'productIDs' => [],
  5405.                         'priceRange' => [
  5406.                             'min' => false,
  5407.                             'max' => false,
  5408.                         ],
  5409.                         'matchingVendor' => false,
  5410.                         'limit' => 2,
  5411.                     ],
  5412.                     [
  5413.                         // Furbify mouse pad
  5414.                         'productTypeIDs' => [],
  5415.                         'productAttributeOptionIDs' => [],
  5416.                         'productIDs' => [
  5417.                             14731,
  5418.                         ],
  5419.                         'priceRange' => [
  5420.                             'min' => false,
  5421.                             'max' => false,
  5422.                         ],
  5423.                         'matchingVendor' => false,
  5424.                         'limit' => 2,
  5425.                     ],
  5426.                     [
  5427.                         // Compressed AIR
  5428.                         'productTypeIDs' => [],
  5429.                         'productAttributeOptionIDs' => [],
  5430.                         'productIDs' => [
  5431.                             15198,
  5432.                         ],
  5433.                         'priceRange' => [
  5434.                             'min' => false,
  5435.                             'max' => false,
  5436.                         ],
  5437.                         'matchingVendor' => false,
  5438.                         'limit' => 2,
  5439.                     ],
  5440.                 ];
  5441.                 break;
  5442.             case 44: // Monitor
  5443.                 $recommendedProductTypes = [
  5444.                     [
  5445.                         // monitor cleaning set
  5446.                         'productTypeIDs' => [
  5447.                             20,
  5448.                         ],
  5449.                         'productAttributeOptionIDs' => [],
  5450.                         'productIDs' => [],
  5451.                         'priceRange' => [
  5452.                             'min' => false,
  5453.                             'max' => false,
  5454.                         ],
  5455.                         'matchingVendor' => false,
  5456.                         'limit' => 4,
  5457.                     ],
  5458.                     [
  5459.                         // Furbify mouse pad
  5460.                         'productTypeIDs' => [],
  5461.                         'productAttributeOptionIDs' => [],
  5462.                         'productIDs' => [
  5463.                             14731,
  5464.                         ],
  5465.                         'priceRange' => [
  5466.                             'min' => false,
  5467.                             'max' => false,
  5468.                         ],
  5469.                         'matchingVendor' => false,
  5470.                         'limit' => 4,
  5471.                     ],
  5472.                     [
  5473.                         // hdmi cable
  5474.                         'productTypeIDs' => [
  5475.                             7,
  5476.                         ],
  5477.                         'productAttributeOptionIDs' => [],
  5478.                         'productIDs' => [],
  5479.                         'priceRange' => [
  5480.                             'min' => false,
  5481.                             'max' => false,
  5482.                         ],
  5483.                         'matchingVendor' => false,
  5484.                         'limit' => 4,
  5485.                     ],
  5486.                     [
  5487.                         // Speakers
  5488.                         'productTypeIDs' => [
  5489.                             84,
  5490.                         ],
  5491.                         'productAttributeOptionIDs' => [],
  5492.                         'productIDs' => [],
  5493.                         'priceRange' => [
  5494.                             'min' => false,
  5495.                             'max' => false,
  5496.                         ],
  5497.                         'matchingVendor' => false,
  5498.                         'limit' => 8,
  5499.                     ],
  5500.                     [
  5501.                         // headphones
  5502.                         'productTypeIDs' => [
  5503.                             35,
  5504.                         ],
  5505.                         'productAttributeOptionIDs' => [],
  5506.                         'productIDs' => [],
  5507.                         'priceRange' => [
  5508.                             'min' => false,
  5509.                             'max' => false,
  5510.                         ],
  5511.                         'matchingVendor' => false,
  5512.                         'limit' => 8,
  5513.                     ],
  5514.                 ];
  5515.                 break;
  5517.             case 41: // Mobile
  5518.                 $recommendedProductTypes = [
  5519.                     [
  5520.                         // Accessories
  5521.                         'productTypeIDs' => [42],
  5522.                         'productAttributeOptionIDs' => [],
  5523.                         'productIDs' => [],
  5524.                         'priceRange' => [
  5525.                             'min' => false,
  5526.                             'max' => false,
  5527.                         ],
  5528.                         'matchingVendor' => false,
  5529.                         'limit' => 8,
  5530.                     ],
  5531.                 ];
  5532.                 break;
  5533.             default:
  5534.                 $recommendedProductTypes = [];
  5535.         }
  5537.         return $recommendedProductTypes;
  5538.     }
  5540.     public static function getRecommendedProductTypesStructure($domainId, $productTypeId)
  5541.     {
  5542.         $recommendedProductTypes = [];
  5544.         if (in_array($domainId, [1, 2])) { // RT SK, WS SK
  5545.             switch ($productTypeId) {
  5546.                 case 60: // PC
  5547.                 case 107: // PC SET
  5548.                 case 116: // All in one
  5549.                     $recommendedProductTypes = [
  5550.                         30, // Mouse
  5551.                         31, // Keyboard
  5552.                         198, // Headphones
  5553.                         194, // Webcam
  5554.                         201, // Speaker
  5555.                         202, // External HDD adapter
  5556.                         10, // USB wifi
  5557.                         203, // Cleaner
  5558.                     ];
  5559.                     break;
  5560.                 case 52: // Notebook
  5561.                     $recommendedProductTypes = [
  5562.                         30, // Mouse
  5563.                         31, // Keyboard
  5564.                         198, // Headphones
  5565.                         194, // Webcam
  5566.                         9, // Docking station
  5567.                         199, // HDMI cable
  5568.                         200, // Notebook cooler
  5569.                         98, // Notebook bag
  5570.                     ];
  5571.                     break;
  5572.                 case 44: // Monitor
  5573.                     $recommendedProductTypes = [
  5574.                         203, // Cleaner
  5575.                         199, // HDMI cable
  5576.                         201, // Speaker
  5577.                         198, // Headphones
  5578.                     ];
  5579.                     break;
  5580.                 default:
  5581.                     $recommendedProductTypes = [];
  5582.             }
  5583.         } elseif (in_array($domainId, [3, 4])) { // RT HU, WS HU
  5584.             switch ($productTypeId) {
  5585.                 case 60: // PC
  5586.                 case 107: // PC SET
  5587.                 case 116: // All in one
  5588.                     $recommendedProductTypes = [
  5589.                         68, // Mouse
  5590.                         69, // Keyboard
  5591.                         204, // Headphones
  5592.                         195, // Webcam
  5593.                         205, // Speaker
  5594.                         206, // External HDD adapter
  5595.                         47, // USB wifi
  5596.                         207, // Cleaner
  5597.                     ];
  5598.                     break;
  5599.                 case 52: // Notebook
  5600.                     $recommendedProductTypes = [
  5601.                         68, // Mouse
  5602.                         69, // Keyboard
  5603.                         204, // Headphones
  5604.                         195, // Webcam
  5605.                         66, // Docking station
  5606.                         208, // HDMI cable
  5607.                         209, // Notebook cooler
  5608.                         99, // Notebook bag
  5609.                     ];
  5610.                     break;
  5611.                 case 44: // Monitor
  5612.                     $recommendedProductTypes = [
  5613.                         207, // Cleaner
  5614.                         208, // HDMI cable
  5615.                         205, // Speaker
  5616.                         204, // Headphones
  5617.                     ];
  5618.                     break;
  5619.                 default:
  5620.                     $recommendedProductTypes = [];
  5621.             }
  5622.         } elseif (in_array($domainId, [5, 9])) { // RT CZ, WS CZ
  5623.             switch ($productTypeId) {
  5624.                 case 60: // PC
  5625.                 case 107: // PC SET
  5626.                 case 116: // All in one
  5627.                     $recommendedProductTypes = [
  5628.                         142, // Mouse
  5629.                         143, // Keyboard
  5630.                         210, // Headphones
  5631.                         196, // Webcam
  5632.                         211, // Speaker
  5633.                         212, // External HDD adapter
  5634.                         121, // USB wifi
  5635.                         213, // Cleaner
  5636.                     ];
  5637.                     break;
  5638.                 case 52: // Notebook
  5639.                     $recommendedProductTypes = [
  5640.                         142, // Mouse
  5641.                         143, // Keyboard
  5642.                         210, // Headphones
  5643.                         196, // Webcam
  5644.                         120, // Docking station
  5645.                         214, // HDMI cable
  5646.                         215, // Notebook cooler
  5647.                         165, // Notebook bag
  5648.                     ];
  5649.                     break;
  5650.                 case 44: // Monitor
  5651.                     $recommendedProductTypes = [
  5652.                         213, // Cleaner
  5653.                         214, // HDMI cable
  5654.                         211, // Speaker
  5655.                         210, // Headphones
  5656.                     ];
  5657.                     break;
  5658.                 default:
  5659.                     $recommendedProductTypes = [];
  5660.             }
  5661.         }
  5663.         return $recommendedProductTypes;
  5664.     }
  5666.     /**
  5667.      * @param int $categoryId
  5668.      */
  5669.     public function countInCategory(array $filter)
  5670.     {
  5671.         $query = $this->getProductListingQuery($filter);
  5673.         $result = $query->getScalarResult();
  5675.         if (!empty($result)) {
  5676.             return count($result);
  5677.         } else {
  5678.             return 0;
  5679.         }
  5680.     }
  5682.     /**
  5683.      * @param int $domainId
  5684.      * @return array
  5685.      */
  5686.     public static function getFreeShipLimitsForDomain(int $domainId): array
  5687.     {
  5688.         return self::getFreeShipLimits()[$domainId] ?? [
  5689.             'freeShipLimit' => 0,
  5690.         ];
  5691.     }
  5693.     /**
  5694.      * @return int[][]
  5695.      */
  5696.     public static function getFreeShipLimits(): array
  5697.     {
  5698.         return [
  5699.             Domain::DOMAIN_ID_RT_SK => [
  5700.                 'freeShipLimit' => 50,
  5701.             ],
  5702.             Domain::DOMAIN_ID_WS_SK => [
  5703.                 'freeShipLimit' => 50,
  5704.             ],
  5705.             Domain::DOMAIN_ID_RT_HU => [
  5706.                 'freeShipLimit' => 18000,
  5707.             ],
  5708.             Domain::DOMAIN_ID_WS_HU => [
  5709.                 'freeShipLimit' => 200000,
  5710.             ],
  5711.             Domain::DOMAIN_ID_WS_CZ => [
  5712.                 'freeShipLimit' => 0,
  5713.             ],
  5714.             Domain::DOMAIN_ID_WS_EU => [
  5715.                 'freeShipLimit' => 0,
  5716.             ],
  5717.             Domain::DOMAIN_ID_RT_CZ => [
  5718.                 'freeShipLimit' => 1400,
  5719.             ],
  5720.             Domain::DOMAIN_ID_RT_EU => [
  5721.                 // RT EU
  5722.                 'freeShipLimit' => 0,
  5723.             ],
  5724.         ];
  5725.     }
  5727.     /**
  5728.      * @param int $domainId
  5729.      * @param string $locale
  5730.      * @param int $productId
  5731.      * @return string
  5732.      */
  5733.     public static function getProductCacheKey(int $domainId, string $locale, int $productId): string
  5734.     {
  5735.         return 'product.v29.' . $domainId . '.' . $locale . '.' . $productId;
  5736.     }
  5738.     /**
  5739.      * @param int $domainId
  5740.      * @param string $locale
  5741.      * @param int $productId
  5742.      * @return string
  5743.      */
  5744.     public static function getSimiliarProductsCacheKey(int $domainId, string $locale, int $productId): string
  5745.     {
  5746.         return 'product.v3.similiar.' . $productId . '.' . $domainId . '.' . $locale;
  5747.     }
  5749.     /**
  5750.      * @param int $domainId
  5751.      * @param string $locale
  5752.      * @param int $productId
  5753.      * @return string
  5754.      */
  5755.     public static function getRecommendedProductsCacheKey(int $domainId, string $locale, int $productId): string
  5756.     {
  5757.         return 'product.v4.recommended.' . $productId . '.' . $domainId . '.' . $locale;
  5758.     }
  5760.     /**
  5761.      * @param int $productId
  5762.      * @return array
  5763.      */
  5764.     public function getNotifications(int $productId): array
  5765.     {
  5766.         $customerNotifications = $this->entityManager
  5767.             ->createQuery("SELECT cn
  5768.                 FROM AtechNetCoreBundle:CustomerNotification cn 
  5769.                 WHERE cn.product = :product AND cn.domain = :domain")
  5770.             ->setParameters([
  5771.                 'product' => $productId,
  5772.                 'domain' => $this->priceDomainId,
  5773.             ])
  5774.             ->getResult();
  5776.         if ($customerNotifications) {
  5777.             return $customerNotifications;
  5778.         }
  5780.         return [];
  5781.     }
  5783.     /**
  5784.      * @param int $productId
  5785.      * @param Customer|null $customer
  5786.      * @param string|null $visitor
  5787.      * @return bool
  5788.      */
  5789.     public function isPriceMonitorActivated(int $productId, ?Customer $customer, ?string $visitor): bool
  5790.     {
  5791.         $notifications = $this->getNotifications($productId);
  5793.         if (!is_null($customer)) {
  5794.             foreach ($notifications as $notification) {
  5795.                 if (!is_null($notification->getCustomer()) && $notification->getCustomer()->getId() == $customer->getId()) {
  5796.                     return true;
  5797.                 }
  5798.             }
  5799.         } elseif (!is_null($visitor)) {
  5800.             foreach ($notifications as $notification) {
  5801.                 if ($notification->getVisitor() == $visitor) {
  5802.                     return true;
  5803.                 }
  5804.             }
  5805.         }
  5807.         return false;
  5808.     }
  5810.     /**
  5811.      * @param object|string $photo
  5812.      * @param string $directory
  5813.      * @return Image
  5814.      */
  5815.     protected function getImage($photo, string $directory = 'product'): Image
  5816.     {
  5817.         return new Image($this->cloudFlareApiConfig, $photo, $directory);
  5818.     }
  5820.     /**
  5821.      * @param int $albumId
  5822.      * @return bool
  5823.      */
  5824.     public function getAlbumImages(int $albumId): array
  5825.     {
  5826.         $album = $this->entityManager->getRepository(Album::class)->findOneById($albumId);
  5828.         $images = [];
  5830.         if (count($album->getPhotos()) > 0) {
  5831.             foreach ($album->getPhotos() as $image) {
  5832.                 $imgs = [
  5833.                     'original' => $image->getCdnUrl('ProductViewPop'),
  5834.                 ];
  5836.                 $images[] = $imgs;
  5837.             }
  5838.         }
  5840.         return $images;
  5841.     }
  5843.     /**
  5844.      * @param array $productData
  5845.      * @return bool
  5846.      */
  5847.     public function getOSLabel(array $productData): ?array
  5848.     {
  5849.         $operationSystem = array_key_exists(Attribute::ATTRIBUTE_ID_OPERATING_SYSTEM, $productData['attributes']) ? $productData['attributes'][Attribute::ATTRIBUTE_ID_OPERATING_SYSTEM]['options'][array_key_first($productData['attributes'][Attribute::ATTRIBUTE_ID_OPERATING_SYSTEM]['options'])]['title'] : null;
  5851.         $filename = null;
  5853.         $productTypeId = array_key_exists('typeId', $productData) ? $productData['typeId'] : $productData['productTypeId'];
  5855.         if (str_contains(strtolower($operationSystem), 'chrome')) {
  5856.             $filename = 'chrome';
  5857.         } elseif (str_contains(strtolower($operationSystem), 'ios') || (array_key_exists('vendorId', $productData) && $productData['vendorId'] == Vendor::VENDOR_ID_APPLE)) {
  5858.             if (in_array($productTypeId, [
  5859.                 ProductType::PRODUCT_TYPE_ID_NOTEBOOK,
  5860.                 ProductType::PRODUCT_TYPE_ID_PC,
  5861.                 ProductType::PRODUCT_TYPE_ID_PC_SET,
  5862.                 ProductType::PRODUCT_TYPE_ID_ALL_IN_ONE,
  5863.             ])) {
  5864.                 $filename = 'apple';
  5865.             } elseif ($productTypeId == ProductType::PRODUCT_TYPE_ID_SMARTPHONE) {
  5866.                 $filename = 'ios';
  5867.             } elseif ($productTypeId == ProductType::PRODUCT_TYPE_ID_TABLET) {
  5868.                 $filename = 'ipados';
  5869.             }
  5870.         } elseif (str_contains(strtolower($operationSystem), 'android')) {
  5871.             $filename = 'android';
  5872.         } elseif (
  5873.             str_contains(strtolower($operationSystem), 'win') ||
  5874.             (
  5875.                 (
  5876.                     in_array($productTypeId, [
  5877.                         ProductType::PRODUCT_TYPE_ID_NOTEBOOK,
  5878.                         ProductType::PRODUCT_TYPE_ID_PC,
  5879.                         ProductType::PRODUCT_TYPE_ID_PC_SET,
  5880.                         ProductType::PRODUCT_TYPE_ID_ALL_IN_ONE,
  5881.                     ])
  5882.                 ) &&
  5883.                 $productData['vendorId'] != Vendor::VENDOR_ID_APPLE
  5884.             )
  5885.         ) {
  5886.             $labels = isset($productData['badges']) ? $productData['badges'] : $productData['labels'];
  5888.             $filename = 'windows' . (in_array('Windows 11', $labels) ? '_11' : '');
  5889.         }
  5891.         return [
  5892.             'filename' => $filename,
  5893.             'title' => $operationSystem,
  5894.         ];
  5895.     }
  5897.     /**
  5898.      * @param string $locale
  5899.      * @param string $webshopPhoneNumber
  5900.      * @param array $salesManager
  5901.      * @return array
  5902.      */
  5903.     public function getSalesManagerForProductShow(string $locale, string $webshopPhoneNumber, array $salesManager): array
  5904.     {
  5905.         $position = '';
  5906.         $phoneNumber = $webshopPhoneNumber;
  5908.         switch ($locale) {
  5909.             case 'en':
  5910.                 $photoFilename = 'mária-face.png';
  5911.                 $name = 'Mária';
  5912.                 $position = 'sales specialist';
  5913.                 break;
  5914.             case 'cz':
  5915.             case 'sk':
  5916.                 $photoFilename = 'mária-face.png';
  5917.                 $name = 'Mária';
  5918.                 break;
  5919.             default:
  5920.                 $photoFilename = 'mária-face.png';
  5921.                 $name = 'Mária';
  5922.                 break;
  5923.         }
  5925.         $customerTypeId = $this->multiStore->getCustomerTypeId();
  5926.         if (isset($salesManager['id']) && in_array($salesManager['id'], [Customer::SALES_MANAGER_WS_SK1_ID, Customer::SALES_MANAGER_NIKI_ID])) {
  5927.             $photoFilename = 'kati-face.png';
  5928.             $name = 'Kati';
  5929.             $phoneNumber = '+421 220 512 060';
  5930.         } else {
  5931.             if ($customerTypeId == MultiStore::CUSTOMER_TYPE_WHOLESALE && !is_null($salesManager) && isset($salesManager['username']) && isset($salesManager['name'])) {
  5933.                 if (in_array($salesManager['id'], [Customer::SALES_MANAGER_DENISA_ID, 296])) {
  5934.                     $photoFilename = "";
  5935.                 } else {
  5936.                     $photoFilename = strtolower($salesManager['name']) . '-face.png';
  5937.                 }
  5939.                 $name = $salesManager['name'];
  5940.                 $position = 'sales manager';
  5942.                 if ($salesManager['phone'] != '' && $salesManager['phone'] != null && $locale != 'hu') {
  5943.                     $phoneNumber = $salesManager['phone'];
  5944.                 } elseif ($locale == 'hu') {
  5945.                     $phoneNumber = '+36 17 65 46 57';
  5946.                 } elseif ($locale == 'sk') {
  5947.                     $phoneNumber = '+421 220 512 060';
  5948.                 }
  5949.             }
  5950.         }
  5952.         return [
  5953.             'photoFilename' => $photoFilename,
  5954.             'name' => $name,
  5955.             'position' => $position,
  5956.             'phoneNumber' => $phoneNumber,
  5957.         ];
  5958.     }
  5960.     public function getFullSpecificationList(array $data, $translator, $reviewUrl): array
  5961.     {
  5962.         $specificationList = [
  5963.             [
  5964.                 'title' => 'Brand',
  5965.                 'content' => $data['categoryLinkWithBrandFilter'] ? "<a href=\"{$data['categoryLinkWithBrandFilter']}\" class=\"link-bold\" target=\"_blank\">{$data['brand']}</a>" : $data['brand'],
  5966.             ],
  5967.             [
  5968.                 'title' => 'Model',
  5969.                 'content' => $data['productName'],
  5970.             ],
  5971.             [
  5972.                 'title' => 'Product code',
  5973.                 'content' => $data['model'] . ($data['partNumber'] && $data['partNumber'] != '' ? "<small class=\"text-secondary\">({$data['partNumber']})</small>" : ''),
  5974.             ],
  5975.             [
  5976.                 'title' => 'Availability',
  5977.                 'content' => $this->getStockStatus($data, $translator),
  5978.             ],
  5979.             [
  5980.                 'title' => 'Quality grading',
  5981.                 'content' => $data['domainId'] == Domain::DOMAIN_ID_WS_EU ? "<strong>{$translator->trans($data['quality'])}</strong>" : $this->getQualityGradingContent($data, $translator, $reviewUrl),
  5982.             ],
  5983.         ];
  5985.         if (count($data['containerParts']) > 0) {
  5986.             return $specificationList;
  5987.         }
  5989.         foreach ($data['attributes'] as $attribute) {
  5990.             if ($attribute == null || !array_key_exists('title', $attribute)) {
  5991.                 continue;
  5992.             }
  5994.             if (in_array($attribute['id'], [Attribute::ATTRIBUTE_ID_RAM_PC_TYPE, Attribute::ATTRIBUTE_ID_RAM_NB_TYPE, Attribute::ATTRIBUTE_ID_RAM_SIZE])) {
  5995.                 continue;
  5996.             }
  5998.             $isAttributeTypeEqualsStorage = in_array($attribute['id'], $data['storageAttributeIds']);
  6000.             $title = $isAttributeTypeEqualsStorage ? 'Storage' : $attribute['title'];
  6001.             $content = '';
  6003.             if ($attribute['options']) {
  6004.                 foreach ($attribute['options'] as $option) {
  6005.                     $content .= '<span class="fw-bold">';
  6007.                     $content .= ($option['multiplier'] > 0 ? "{$option['multiplier']} x " : '') . $option['title'];
  6009.                     if ($isAttributeTypeEqualsStorage) {
  6010.                         $content .= " {$attribute['title']}";
  6011.                     }
  6013.                     $content .= '</span><br>';
  6014.                 }
  6015.             }
  6017.             $specificationList[] = [
  6018.                 'title' => $title,
  6019.                 'content' => $content,
  6020.             ];
  6021.         }
  6023.         if ($data['weight']) {
  6024.             $specificationList[] = [
  6025.                 'title' => 'Weight',
  6026.                 'content' => $data['weight'],
  6027.             ];
  6028.         }
  6030.         if ($data['dimensions']) {
  6031.             $specificationList[] = [
  6032.                 'title' => 'Dimensions',
  6033.                 'content' => $data['dimensions'],
  6034.             ];
  6035.         }
  6037.         if (
  6038.             in_array($data['typeId'], [
  6039.                 ProductType::PRODUCT_TYPE_ID_NOTEBOOK,
  6040.                 ProductType::PRODUCT_TYPE_ID_PC,
  6041.                 ProductType::PRODUCT_TYPE_ID_MONITOR,
  6042.                 ProductType::PRODUCT_TYPE_ID_SMARTPHONE,
  6043.                 ProductType::PRODUCT_TYPE_ID_TABLET,
  6044.                 ProductType::PRODUCT_TYPE_ID_ALL_IN_ONE,
  6045.                 ProductType::PRODUCT_TYPE_ID_PROJECTOR,
  6046.             ])) {
  6047.             $specificationList[] = [
  6048.                 'title'   => 'Disclaimer',
  6049.                 'content' => $this->getDisclaimer($translator, $data['typeId']),
  6050.             ];
  6051.         }
  6053.         return $specificationList;
  6054.     }
  6056.     public function getSSDSize(array $data): ?string
  6057.     {
  6058.         $ssdSize = null;
  6060.         foreach ($data as $attribute) {
  6061.             if ($attribute && $attribute['title'] === 'SSD' && !empty($attribute['options'])) {
  6062.                 foreach ($attribute['options'] as $option) {
  6063.                     // Example: "1TB (M.2)" or "512GB"
  6064.                     if (preg_match('/(\d+(?:\.\d+)?)\s*(TB|GB)/i', $option['title'], $matches)) {
  6065.                         $ssdSize = $matches[1] . strtoupper($matches[2]);
  6066.                         break 2;
  6067.                     }
  6068.                 }
  6069.             }
  6070.         }
  6071.         return $ssdSize;
  6072.     }
  6074.     private function getQualityGradingContent($data, $translator, $reviewUrl)
  6075.     {
  6076.         $quality = match ($data['quality']) {
  6077.             'Gold'   => 'A',
  6078.             'Silver' => 'B',
  6079.             'Bronze' => 'C',
  6080.             default  => $data['quality'],
  6081.         };
  6083.         $quality_description = $data['quality_description'];
  6085.         $elements = "<strong>{$translator->trans("grades.$quality")}";
  6087.         if ($quality && $quality_description) {
  6088.             $elements .= ": ";
  6089.         }
  6091.         $elements .= "</strong>";
  6093.         if ($quality && $quality_description) {
  6094.             $elements .= "<span>{$quality_description} ";
  6095.         }
  6097.         $elements .= str_replace(
  6098.             ['{qualityTitle}', '{hrefValue}'],
  6099.             [
  6100.                 $translator->trans($quality),
  6101.                 "$reviewUrl?category={$data['product_type_id']}&quality={$data['qualityStatusId']}",
  6102.             ],
  6103.             $translator->trans('Customer reviews and photos of our {qualityTitle} rated products')
  6104.         );
  6106.         return $elements;
  6107.     }
  6109.     private function getStockStatus(array $data, $translator): string
  6110.     {
  6111.         $active = $data['active'];
  6112.         $available = $data['available'];
  6113.         $orderWaitingDays = $data['orderWaitingDays'];
  6115.         if (!$active) {
  6116.             return "<span class=\"in-stock text-grey\"><span class=\"dot\"></span>{$translator->trans('Out of stock')}</span>";
  6117.         }
  6119.         $classList = 'in-stock text-grey';
  6120.         $textContent = 'Out of stock';
  6122.         if ($orderWaitingDays > 0 && $available < 1) {
  6123.             $textContent = str_replace('%d', $orderWaitingDays, $translator->trans('On order within %d working days'));
  6125.             return "<span class=\"$classList\"><span class=\"dot\"></span>{$textContent}</span>";
  6126.         }
  6128.         if ($available > 1) {
  6129.             $classList = "in-stock text-success";
  6130.         }
  6132.         if ($available == 1) {
  6133.             return "<span class=\"in-stock text-danger\"><span class=\"dot\"></span>{$translator->trans('Only one left')}</span>";
  6134.         }
  6136.         if ($available > 10) {
  6137.             $textContent = '10+ in stock';
  6138.         } elseif ($available >= 5) {
  6139.             $textContent = '5-10 in stock';
  6140.         } elseif ($available > 1) {
  6141.             $textContent = '2-4 in stock';
  6142.         }
  6144.         return "<span class=\"$classList\"><span class=\"dot\"></span>{$translator->trans($textContent)}</span>";
  6145.     }
  6147.     private function getDisclaimer($translator, int $productType)
  6148.     {
  6149.         return $translator->trans("Disclaimer_note.$productType");
  6150.     }
  6152.     private function getTnDisplayAttributeOptionIds(): string
  6153.     {
  6154.         $attribute = $this->entityManager->find(Attribute::class, Attribute::ATTRIBUTE_ID_DISPLAY_TECHNOLOGY);
  6155.         if ($attribute) {
  6156.             $panelIds = '';
  6157.             foreach ($attribute->getOptions() as $option) {
  6158.                 if (!in_array($option->getId(), [
  6159.                     AttributeOption::ATTRIBUTE_OPTION_IPS_PANEL,
  6160.                     AttributeOption::ATTRIBUTE_OPTION_OLED_PANEL,
  6161.                     AttributeOption::ATTRIBUTE_OPTION_QLED_PANEL,
  6162.                 ])) {
  6163.                     $panelIds .= $option->getId() . ',';
  6164.                 }
  6165.             }
  6166.             return trim($panelIds, ',');
  6167.         }
  6168.         return '';
  6169.     }
  6171.     private function getAttributeOptionIdsBasedOnTheAge(int $age): string
  6172.     {
  6173.         $dateTime = new \DateTime();
  6174.         $currentYear = $dateTime->format('Y');
  6176.         $yearFrom = 0;
  6177.         $yearTo = 0;
  6179.         switch ($age) {
  6180.             case self::AGE_0_to_2_YEARS:
  6181.                 $yearFrom = $currentYear - 0; // to convert int
  6182.                 $yearTo = $currentYear - 2;
  6183.                 break;
  6184.             case self::AGE_3_to_5_YEARS:
  6185.                 $yearFrom = $currentYear - 3;
  6186.                 $yearTo = $currentYear - 5;
  6187.                 break;
  6188.             case self::AGE_6_PLUS_YEARS:
  6189.                 $yearFrom = $currentYear - 6;
  6190.                 $yearTo = 2005;
  6191.                 break;
  6192.         }
  6194.         if ($yearFrom == 0 && $yearTo == 0) {
  6195.             return '';
  6196.         }
  6198.         $yearOptionIds = '';
  6199.         for ($i = $yearFrom; $i >= $yearTo; $i--) {
  6200.             $yearOptionIds .= AttributeOption::getYearAttributeOptionIds()[$i] . ',';
  6201.         }
  6203.         return trim($yearOptionIds, ',');
  6204.     }
  6206.     private function getPriorityProductsForCategoryPages(array $filter, CategoryPage $categoryPage): array
  6207.     {
  6208.         /**
  6209.          * CHECK IF ANY FILTER IS APPLIED BY THE USER IF YES THEN DON`T SHOW THE PRIORITY PRODUCTS
  6210.          */
  6211.         if (!$this->isUserApplyingFilters($filter, $categoryPage)) {
  6212.             $priorityProducts = [];
  6214.             if ($categoryPage->getPriorityProducts()->count() > 0) {
  6215.                 $priorityProducts = [];
  6216.                 foreach ($categoryPage->getPriorityProducts() as $priorityProduct) {
  6217.                     if ($priorityProduct->getProduct()->isAvailable()) {
  6218.                         $priorityProducts[$priorityProduct->getSortIndex()] = $priorityProduct->getProduct();
  6219.                     }
  6220.                 }
  6222.                 ksort($priorityProducts);
  6224.                 $priorityProducts = array_slice($priorityProducts, 0, 12);
  6225.             }
  6227.             return $priorityProducts;
  6228.         }
  6230.         return [];
  6231.     }
  6233.     private function isUserApplyingFilters(array $filter, CategoryPage $categoryPage): bool
  6234.     {
  6235.         $sideFilters = true;
  6236.         $sortFilter = true;
  6238.         if ((array_key_exists('filterVendor', $filter) && is_null($filter['filterVendor']))
  6239.             && (is_null($filter['filterAttribute']) || count($filter['filterAttribute']) == 0)
  6240.             && is_null($filter['filterPriceMin'])
  6241.             && is_null($filter['filterPriceMax'])
  6242.             && is_null($filter['filterLastPieces'])
  6243.             && (is_null($filter['filterDiscounted']) || $categoryPage->isShowOnlyDiscounted() == $filter['filterDiscounted'])
  6244.             && is_null($filter['filterCpuMarkMin'])
  6245.             && is_null($filter['filterCpuMarkMax'])
  6246.             && is_null($filter['filterProductType'])
  6247.             && (array_key_exists('start', $filter) && $filter['start'] == 0)
  6248.         ) {
  6249.             $sideFilters = false;
  6250.         }
  6252.         if ($filter['sort'] == 'popular') {
  6253.             $sortFilter = false;
  6254.         }
  6256.         return $sideFilters || $sortFilter;
  6257.     }
  6259.     private function getProductMetaText(?string $rawText, array $attributes): ?string
  6260.     {
  6261.         if (!$rawText) {
  6262.             return null;
  6263.         }
  6265.         preg_match_all('/\[\[(.*?)\]\]/', $rawText, $matches);
  6267.         foreach ($matches[1] as $i => $match) {
  6268.             $translatedTitle = $this->translator->trans($match);
  6270.             $result = array_filter($attributes, function ($item) use ($translatedTitle) {
  6271.                 return isset($item['title']) && $item['title'] === $translatedTitle;
  6272.             });
  6274.             $shortTitle = "";
  6275.             foreach ($result as $item) {
  6276.                 if (isset($item['options']) && is_array($item['options'])) {
  6277.                     foreach ($item['options'] as $option) {
  6278.                         if (isset($option['title'])) {
  6279.                             $shortTitle .= $option['title'] . ", ";
  6280.                         }
  6281.                     }
  6282.                 }
  6283.             }
  6285.             $rawText = str_replace($matches[0][$i], rtrim($shortTitle, ', '), $rawText);
  6286.         }
  6288.         return $rawText;
  6289.     }
  6290. }