src/WebBundle/Repository/FilterRepository.php line 824

Open in your IDE?
  1. <?php
  3. namespace WebBundle\Repository;
  5. use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository;
  6. use Doctrine\DBAL\Types\Types;
  7. use Doctrine\ORM\NonUniqueResultException;
  8. use Doctrine\ORM\NoResultException;
  9. use Doctrine\ORM\QueryBuilder;
  10. use Doctrine\Persistence\ManagerRegistry;
  11. use Exception;
  12. use FlexApp\Constant\TimeConstant;
  13. use FlexApp\DTO\BrandResponseDTO;
  14. use FlexApp\DTO\FilterCountryResponseDTO;
  15. use FlexApp\DTO\FilterResponseDTO;
  16. use FlexApp\Service\CacheService;
  17. use FlexApp\Service\RedisCachePool;
  18. use FlexApp\ValueObject\LocaleVo;
  19. use Import1CBundle\Helper\v3\BiConst;
  20. use Symfony\Contracts\Translation\TranslatorInterface;
  21. use Throwable;
  22. use WebBundle\Entity\FilterEntity;
  23. use WebBundle\Enum\FilterGroupEnum;
  24. use WebBundle\Helper\App;
  25. use WebBundle\Helper\ArrHelper;
  26. use WebBundle\Helper\HideFactoryCountriesHelper;
  27. use WebBundle\Helper\LocaleHelper;
  28. use WebBundle\Helper\PathHelper;
  29. use WebBundle\Helper\StrHelper;
  30. use WebBundle\Traits\RepoTrait;
  32. class FilterRepository extends ServiceEntityRepository
  33. {
  34.     use RepoTrait;
  36.     private const QUERY_CACHE_LIFETIME = 600;
  38.     private CacheService $cacheService;
  40.     public function __construct(ManagerRegistry $registry, CacheService $cacheService)
  41.     {
  42.         parent::__construct($registry, FilterEntity::class);
  43.         $this->cacheService = $cacheService;
  44.     }
  46.     public function joinQuery($alias = 'f'): QueryBuilder
  47.     {
  48.         return $this->createQueryBuilder($alias)
  49.             ->SELECT(
  50.                 "$alias, url, page, param, brand, groups, articles, htmlShow, country, nameForMetaTitle, nameForMetaDescr"
  51.             )
  52.             ->leftJoin("$alias.url", 'url')
  53.             ->leftJoin("$alias.page", 'page')
  54.             ->leftJoin("$alias.param", 'param')
  55.             ->leftJoin("$alias.brand", 'brand')
  56.             ->leftJoin("brand.user", 'user')
  57.             ->leftJoin("$alias.groups", 'groups')
  58.             ->leftJoin("$alias.articles", 'articles')
  59.             ->leftJoin("$alias.htmlShow", 'htmlShow')
  60.             ->leftJoin("$alias.country", 'country')
  61.             ->leftJoin("$alias.nameForMetaTitle", 'nameForMetaTitle')
  62.             ->leftJoin("$alias.nameForMetaDescr", 'nameForMetaDescr');
  63.     }
  66.     /**
  67.      * @param string $filterUrl
  68.      * @param string $locale
  69.      * @return FilterResponseDTO|null
  70.      * @throws \Doctrine\DBAL\Driver\Exception
  71.      * @throws \Doctrine\DBAL\Exception
  72.      */
  73.     public function getByKeyUrlIsLike(string $filterUrl, string $locale): ?FilterResponseDTO
  74.     {
  75.         return $this->getByUrl($filterUrl, $locale, true);
  76.     }
  78.     /**
  79.      * @param string $filterUrl
  80.      * @param string $locale
  81.      * @return FilterResponseDTO|null
  82.      * @throws \Doctrine\DBAL\Driver\Exception
  83.      * @throws \Doctrine\DBAL\Exception
  84.      */
  85.     public function getByKeyUrl(string $filterUrl, string $locale): ?FilterResponseDTO
  86.     {
  87.         return $this->getByUrl($filterUrl, $locale);
  88.     }
  90.     /**
  91.      * @param int|null $filterId
  92.      * @return array
  93.      * @throws \Doctrine\DBAL\Exception
  94.      */
  95.     public function getIDsForSynchCountFiltersOnlyParent(?int $filterId = null): array
  96.     {
  97.         $filterId = $filterId ? "AND (f.parent_id = '$filterId' OR f.id = '$filterId')" : '';
  99.         $sql = "SELECT DISTINCT f.parent_id
  100.                 FROM filters f
  101.                 WHERE f.parent_id IS NOT NULL $filterId
  102.                 ";
  104.         $conn = $this->getEntityManager()->getConnection();
  105.         $ids = $conn->fetchAllAssociative($sql);
  107.         if ($ids) {
  108.             $ids = array_column($ids, 'parent_id');
  109.         }
  111.         return $ids;
  112.     }
  114.     /**
  115.      * Получаем subFilter
  116.      * @param bool $new
  117.      * @return array
  118.      * @throws \Doctrine\DBAL\Exception
  119.      */
  120.     public function getFiltersSubRelation(bool $new = false): array
  121.     {
  122.         $where = $new ? ' AND p.show_menu != 0 ' : ' AND p.show_menu_advanced != 0';
  123.         $sql = "SELECT
  124.     f2.id,
  125.     f2.name,
  126.     f2.old_command,
  127.     f2.old_id,
  128.     GROUP_CONCAT(f.id) AS ids,
  129.     GROUP_CONCAT(f.old_id) AS old_ids
  130. FROM
  131.     `filters` f
  132. LEFT JOIN filters f2 ON
  133.     f.parent_id = f2.id
  134. LEFT JOIN filter_params p ON
  135.     f.param_id = p.id
  136. WHERE
  137.     f.parent_id IS NOT NULL AND p.is_enable = 1 $where
  138. GROUP BY
  139.     f.parent_id;";
  141.         $conn = $this->getEntityManager()->getConnection();
  142.         $filterData = $conn->fetchAllAssociative($sql);
  143.         $parentMap = [];
  144.         if ($new) {
  145.             foreach ($filterData as $row) {
  146.                 $ids = explode(',', $row['ids']);
  147.                 $parentMap[$row['id']] = $ids;
  148.             }
  149.         } else {
  150.             foreach ($filterData as $row) {
  151.                 $ids = explode(',', $row['old_ids']);
  152.                 $parentMap[$row['old_command']][$row['old_id']] = $ids;
  153.             }
  154.         }
  155.         return $parentMap;
  156.     }
  158.     /**
  159.      * Получение списка фильтров для синхронизации количества
  160.      * @param int $filterParentId
  161.      * @return array
  162.      */
  163.     public function getListForSynchCountFiltersOnlyChildren(int $filterParentId): array
  164.     {
  165.         $q = $this->createQueryBuilder('f')
  166.             ->select(
  167.                 'f.id id, f.name name, f.oldId oldId, f.oldCommand oldCommand, parent.id pid, param.id fpId, param.count fpCount'
  168.             )
  169.             ->leftJoin('f.param', 'param')
  170.             ->leftJoin('f.parent', 'parent')
  171.             ->andWhere('parent.id = :pid')->setParameter('pid', $filterParentId)
  172.             ->andWhere('f.oldCommand != :bm')->setParameter('bm', 'bm') // исключаем из проверок фильтр БМом
  173.         ;
  175.         $q = $q->getQuery();
  177.         return $q->getArrayResult();
  178.     }
  180.     /**setCollections
  181.      * Получение списка фильтров для синхронизации количества
  182.      * WebBundle/Command/SynchronizeCommand::runSynchCountFilters()
  183.      * @param array|null $filterIds
  184.      * @param array|null $fidsExclude
  185.      * @return array|null
  186.      */
  187.     public function getListForSynchCountFilters(?array $filterIds = [], ?array $fidsExclude = []): ?array
  188.     {
  189.         $q = $this->createQueryBuilder('f')
  190.             ->select(
  191.                 'f.id id, f.name name, f.oldId oldId, f.oldCommand oldCommand, parent.id pid, param.id fpId, param.count fpCount'
  192.             )
  193.             ->leftJoin('f.param', 'param')
  194.             ->leftJoin('f.parent', 'parent')
  195.             ->andWhere('f.oldCommand != :bm')->setParameter('bm', 'bm') // исключаем из проверок фильтр БМом
  196.         ;
  199.         if ($filterIds) {
  200.             $q->andWhere('f.id IN (:filterId)')->setParameter('filterId', $filterIds);
  201.         }
  203.         if ($fidsExclude) {
  204.             $q->andWhere('f.id NOT IN (:filterIdExclude)')->setParameter('filterIdExclude', $fidsExclude);
  205.         }
  207.         $q = $q->getQuery();
  209.         return $q->getArrayResult();
  210.     }
  212.     public function getListForOneC(): array
  213.     {
  214.         $q = $this->joinQuery('f');
  215.         $r = $q->getQuery();
  217.         $cacheName = $this->buildCacheName('filter', ['getListForOneC']);
  218.         $r->useQueryCache(true)->enableResultCache((int)TimeConstant::DAY, $cacheName);
  220.         return $r->getArrayResult();
  221.     }
  223.     /**
  224.      * @param array $oldIds
  225.      * @param string $oldCommand
  226.      * @param string $locale
  227.      * @return array|FilterResponseDTO[]
  228.      * @throws \Doctrine\DBAL\Driver\Exception
  229.      * @throws \Doctrine\DBAL\Exception
  230.      */
  231.     public function getByOldCommand(array $oldIds, string $oldCommand, string $locale): array
  232.     {
  233.         $oldIds = array_map('intval', $oldIds);
  234.         $oldIds = array_unique($oldIds);
  235.         $oldIds = array_filter($oldIds);
  237.         if ($oldIds) {
  238.             $fidsStr = implode(',', $oldIds);
  239.             $fidsStr = "f.old_id IN ($fidsStr) AND";
  240.         } else {
  241.             $fidsStr = '';
  242.         }
  243.         $sql = "SELECT f.id AS `id` FROM filters f WHERE $fidsStr f.old_command = '$oldCommand'";
  245.         return $this->getKeysBySql($sql, $locale);
  246.     }
  248.     /**
  249.      * @param string $filterAltName
  250.      * @param string $locale
  251.      * @return FilterResponseDTO[]
  252.      * @throws \Doctrine\DBAL\Driver\Exception
  253.      * @throws \Doctrine\DBAL\Exception
  254.      */
  255.     public function getFilterDTOByAltName(string $filterAltName, string $locale): array
  256.     {
  257.         $sql = "SELECT f.id AS `id` FROM filters f WHERE f.alt_name = '$filterAltName'";
  259.         return $this->getKeysBySql($sql, $locale);
  260.     }
  262.     /**
  263.      * Получаем key для URL для дизайнерского стиля
  264.      * @param null $lc
  265.      * @return mixed|null
  266.      */
  267.     public function getKeyDesignerStyle($lc = null)
  268.     {
  269.         $lc = $lc ?: LocaleHelper::getCurLocale();
  270.         $q = $this->createQueryBuilder('f');
  271.         $q->select("url.$lc")
  272.             ->leftJoin('f.url', 'url')
  273.             ->andWhere("f.altName = :filterAltName")
  274.             ->setParameter('filterAltName', 'designer')
  275.             ->setMaxResults(1);
  277.         $cacheName = $this->buildCacheName('filter_designer_style', [$lc]);
  278.         $r = $q->getQuery()->useQueryCache(true)->enableResultCache(TimeConstant::WEEK, $cacheName);
  280.         try {
  281.             $item = $r->getSingleResult();
  282.             $item = $item[$lc];
  283.         } catch (Exception $e) {
  284.             return null;
  285.         }
  287.         return $item;
  288.     }
  290.     /**
  291.      * @param null $filterAltName
  292.      * @param null $groupAltName
  293.      * @param bool $isLike
  294.      * @return mixed
  295.      */
  296.     public function getByAltName($filterAltName = null, $groupAltName = null, bool $isLike = false)
  297.     {
  298.         $aParams = [];
  299.         $operate = $isLike ? 'LIKE' : '=';
  301.         $q = $this->createQueryBuilder('f');
  303.         $q->select('f, groups, page, url, nameForMetaTitle, nameForMetaDescr')
  304.             ->leftJoin('f.groups', 'groups')
  305.             ->leftJoin('f.page', 'page')
  306.             ->leftJoin('f.url', 'url')
  307.             ->leftJoin('f.nameForMetaTitle', 'nameForMetaTitle')
  308.             ->leftJoin('f.nameForMetaDescr', 'nameForMetaDescr');
  310.         if ($filterAltName) {
  311.             $q->andWhere("f.altName $operate :filterAltName");
  312.             if ($isLike) {
  313.                 $filterAltName = '%' . $filterAltName . '%';
  314.             }
  315.             $aParams['filterAltName'] = $filterAltName;
  316.         }
  318.         if ($groupAltName) {
  319.             $q->andWhere("groups.altName $operate :groupAltName");
  320.             if ($isLike) {
  321.                 $groupAltName = '%' . $groupAltName . '%';
  322.             }
  323.             $aParams['groupAltName'] = $groupAltName;
  324.         }
  326.         $q->setParameters($aParams);
  327.         $r = $q->getQuery();
  329.         $cacheName = $this->buildCacheName('filter_getByAltName', [$filterAltName, $groupAltName]);
  330.         $r->useQueryCache(true)->enableResultCache(TimeConstant::DAY, $cacheName);
  332.         return $r->getResult();
  333.     }
  335.     /**
  336.      * @param int $oldId
  337.      * @return array
  338.      * @throws \Doctrine\DBAL\Exception
  339.      */
  340.     public function getFilterIdsByOldId(int $oldId): array
  341.     {
  342.         $sql = "SELECT f.id
  343.                 FROM filters f
  344.                 WHERE f.old_id = $oldId
  345.                 ";
  347.         $memcache = $this->cacheService->getMemcache();
  348.         $memcacheKey = md5($sql);
  349.         $ids = $memcache->get($memcacheKey);
  351.         if ($ids) {
  352.             return $ids;
  353.         }
  355.         $conn = $this->getEntityManager()->getConnection();
  356.         $ids = $conn->fetchAllAssociative($sql);
  358.         $memcache->set($memcacheKey, $ids);
  360.         return $ids;
  361.     }
  363.     /**
  364.      * Получение одного ID по OldID
  365.      * @param int $oldId
  366.      * @param string $oldCommand
  367.      * @return int|null
  368.      */
  369.     public function getFilterIdByOldId(int $oldId, string $oldCommand): ?int
  370.     {
  371.         $sql = "SELECT f.id FROM filters f WHERE f.old_id = '$oldId' AND f.old_command = '$oldCommand' LIMIT 1";
  373.         $memcache = $this->cacheService->getMemcache();
  374.         $memcacheKey = md5($sql);
  375.         $id = $memcache->get($memcacheKey);
  377.         if ($id) {
  378.             return $id;
  379.         }
  381.         try {
  382.             $conn = $this->getEntityManager()->getConnection();
  383.             $id = $conn->executeQuery($sql)->fetchOne();
  384.         } catch (Throwable $e) {
  385.             return null;
  386.         }
  388.         if ($id) {
  389.             $id = (int)$id;
  390.             $memcache->set($memcacheKey, $id);
  391.         }
  393.         return $id ?: null;
  394.     }
  396.     /**
  397.      * Получение массива ID по массиву OldID
  398.      * @param array $oldIds
  399.      * @param string $oldCommand
  400.      * @return array
  401.      * @throws \Doctrine\DBAL\Exception
  402.      */
  403.     public function getFilterIdsByOldIds(array $oldIds, string $oldCommand): array
  404.     {
  405.         $conn = $this->getEntityManager()->getConnection();
  406.         $isDesigner = $oldCommand == 'getDesigner';
  407.         $oldCommand = $conn->quote($oldCommand);
  409.         $oldIds = array_map('intval', array_filter($oldIds, 'is_numeric'));
  410.         $oldIds = implode("', '", $oldIds);
  411.         $oldIds = "'$oldIds'";
  413.         $sql = "SELECT f.id FROM filters f WHERE f.old_id IN ($oldIds) AND f.old_command = $oldCommand;";
  415.         // для дизайнеров дополнительно ищем по f.id
  416.         if ($isDesigner) {
  417.             $sql = "SELECT f.id FROM filters f WHERE (f.old_id IN ($oldIds) OR f.id IN ($oldIds)) AND f.old_command = $oldCommand;";
  418.         }
  420.         $memcache = $this->cacheService->getMemcache();
  421.         $memcacheKey = md5($sql);
  422.         $ids = $memcache->get($memcacheKey);
  424.         if ($ids) {
  425.             return $ids;
  426.         }
  428.         $ids = $conn->fetchAllAssociative($sql);
  429.         if ($ids) {
  430.             $ids = array_column($ids, 'id');
  431.         } else {
  432.             $ids = [];
  433.         }
  435.         $memcache->set($memcacheKey, $ids);
  437.         return $ids;
  438.     }
  440.     /**
  441.      * Поиск фильтра по url значению
  442.      * @code (
  443.      *     $oRepoFilters->getByKeyUrl('bathroom');
  444.      *     $oRepoFilters->getByKeyUrl('bathroom', 'en');
  445.      * )
  446.      * @param string $filterSlug URL имя фильтра
  447.      * @param string $lc Локаль
  448.      * @param bool $isLike
  449.      * @return FilterResponseDTO|null
  450.      * @throws \Doctrine\DBAL\Driver\Exception
  451.      * @throws \Doctrine\DBAL\Exception
  452.      */
  453.     private function getByUrl(string $filterSlug, string $lc, bool $isLike = false): ?FilterResponseDTO
  454.     {
  455.         $aLocales = LocaleHelper::getListAvailable();
  456.         $aLocales = array_column($aLocales, 'code');
  458.         $andWhere = '';
  459.         if ($isLike) {
  460.             $filterSlug = '%' . $filterSlug . '%';
  461.         }
  462.         foreach ($aLocales as $loc) {
  463.             if ($isLike) {
  464.                 $andWhere .= "url.$loc LIKE :slug OR ";
  465.             } else {
  466.                 $andWhere .= "url.$loc = :slug OR ";
  467.             }
  468.         }
  469.         $andWhere = trim(trim($andWhere), 'OR');
  471.         $sql = $this->buildSQLSelectForFilterResponseDTO($lc);
  472.         $sql = "$sql WHERE $andWhere";
  474.         $sql = preg_replace('/[\s\n\r]+/', ' ', $sql);
  476.         $memcache = $this->cacheService->getMemcache();
  477.         $memcacheKey = $filterSlug . md5($sql);
  478.         $dtoArray = $memcache->get($memcacheKey);
  480.         if ($dtoArray) {
  481.             return $this->buildFilterResponseDTO($dtoArray);
  482.         }
  484.         $conn = $this->getEntityManager()->getConnection();
  485.         $stmt = $conn->prepare($sql);
  486.         $stmt->bindValue("slug", $filterSlug, Types::STRING);
  487.         $item = $stmt->executeQuery()->fetchAllAssociative();
  488.         if ($lc == 'zh') {
  489.             $sql = $this->buildSQLSelectForFilterResponseDTO('en');
  490.             $sql = "$sql WHERE $andWhere";
  492.             $sql = preg_replace('/[\s\n\r]+/', ' ', $sql);
  494.             $conn = $this->getEntityManager()->getConnection();
  495.             $stmt = $conn->prepare($sql);
  496.             $stmt->bindValue("slug", $filterSlug, Types::STRING);
  497.             $itemEn = $stmt->executeQuery()->fetchAllAssociative();
  498.             $item = $this->fillEmptyFields($item, $itemEn);
  499.         }
  501.         if (!$item) {
  502.             return null;
  503.         }
  505.         // если значений несколько, значит не корректный запрос по каким-то причинам
  506.         if (count($item) > 1) {
  507.             return null;
  508.         }
  510.         $memcache->set($memcacheKey, $item[0]);
  512.         return $this->buildFilterResponseDTO($item[0]);
  513.     }
  515.     /**
  516.      * @param $altNames
  517.      * @return float|int|mixed|string
  518.      */
  519.     public function getByAltNames($altNames)
  520.     {
  521.         $q = $this->joinQuery('f');
  523.         $altNames = is_string($altNames) ? explode(',', $altNames) : $altNames;
  524.         $q->andWhere('f.altName IN (:altNames)');
  525.         $q->addOrderBy('groups.sort', 'ASC');
  526.         $q->addOrderBy('f.sort', 'ASC');
  527.         $q->setParameter('altNames', $altNames);
  528.         $r = $q->getQuery();
  530.         $cacheName = $this->buildCacheName('filter_getByAltNames', $altNames);
  531.         $r->useQueryCache(true)->enableResultCache((int)TimeConstant::DAY, $cacheName);
  533.         return $r->getResult();
  534.     }
  537. // Вспомогательная функция для рекурсивного заполнения
  538.     public function fillEmptyFields($zhArray, $enArray)
  539.     {
  540.         $result = $zhArray;
  542.         foreach ($enArray as $key => $value) {
  543.             // Если ключа нет в китайском массиве или значение пустое
  544.             if (!isset($result[$key]) || (is_string($result[$key]) && empty(trim($result[$key])))) {
  545.                 $result[$key] = $value;
  546.             } elseif (is_array($value) && isset($zhArray[$key]) && is_array($zhArray[$key])) {
  547.                 // Рекурсивно обрабатываем вложенные массивы
  548.                 $result[$key] = $this->fillEmptyFields($zhArray[$key], $value);
  549.             }
  550.         }
  552.         return $result;
  553.     }
  555.     /**
  556.      * @param array $ids
  557.      * @param string $lc
  558.      * @return array|FilterResponseDTO[]
  559.      * @throws \Doctrine\DBAL\Driver\Exception
  560.      * @throws \Doctrine\DBAL\Exception
  561.      */
  562.     public function getSortedByIds(array $ids, string $lc)
  563.     {
  564.         if (!$ids) {
  565.             return [];
  566.         }
  568.         $conn = $this->getEntityManager()->getConnection();
  569.         $inQuery = implode(',', array_fill(0, count($ids), '?'));
  571.         $sql = $this->buildSQLSelectForFilterResponseDTO($lc);
  572.         $sql = "$sql WHERE f.id IN ($inQuery) ORDER BY gr.sort, f.sort";
  574.         $sql = preg_replace('/[\s\n\r]+/', ' ', $sql);
  576.         $memcache = $this->cacheService->getMemcache();
  577.         $memcacheKey = md5($sql) . implode('.', $ids);
  578.         $rows = $memcache->get($memcacheKey);
  580.         if ($rows) {
  581.             return $rows;
  582.         }
  584.         $stmt = $conn->prepare($sql);
  585.         foreach ($ids as $i => $id) {
  586.             $stmt->bindValue(($i + 1), $id);
  587.         }
  588.         $items = $stmt->executeQuery()->fetchAllAssociative();
  590.         if ($lc == 'zh') {
  591.             $sql = $this->buildSQLSelectForFilterResponseDTO('en');
  592.             $sql = "$sql WHERE f.id IN ($inQuery) ORDER BY gr.sort, f.sort";
  594.             $sql = preg_replace('/[\s\n\r]+/', ' ', $sql);
  595.             $stmt = $conn->prepare($sql);
  596.             foreach ($ids as $i => $id) {
  597.                 $stmt->bindValue(($i + 1), $id);
  598.             }
  599.             $itemsEn = $stmt->executeQuery()->fetchAllAssociative();
  600.             $items = $this->fillEmptyFields($items, $itemsEn);
  601.         }
  602.         $rows = [];
  603.         foreach ($items as $item) {
  604.             $row = $this->buildFilterResponseDTO($item);
  605.             if ($row) {
  606.                 $rows[] = $row;
  607.             }
  608.         }
  610.         $memcache->set($memcacheKey, $rows);
  612.         return $rows;
  613.     }
  615.     /**
  616.      * Осноной запрос получения фильтров из базы по ID с сортировкой по Filter SORT и FilterGroup SORT
  617.      * @param      $id
  618.      * @param bool $toArray
  619.      * @return array|null
  620.      */
  621.     public function getByIds($id, bool $toArray = false)
  622.     {
  623.         $q = $this->joinQuery('f');
  625.         $ids = is_string($id) ? explode(',', $id) : $id;
  627.         if (count($ids) == 1) {
  628.             $q->andWhere('f.id = :ids');
  629.         } else {
  630.             $q->andWhere('f.id IN (:ids)');
  631.         }
  632.         $q->andWhere('f.id IN (:ids)');
  633.         $q->addOrderBy('groups.sort', 'ASC');
  634.         $q->addOrderBy('f.sort', 'ASC');
  635.         $q->setParameter('ids', $ids);
  636.         $r = $q->getQuery();
  638.         $cacheName = $this->buildCacheName('filter_getByIds', $id);
  639.         $r->useQueryCache(true)->enableResultCache((int)TimeConstant::DAY, $cacheName);
  641.         if ($toArray) {
  642.             $items = $r->getArrayResult();
  643.         } else {
  644.             $items = $r->getResult();
  645.         }
  647.         return $items;
  648.     }
  650.     /**
  651.      * Осноной запрос получения фильтров из базы по ID с сортировкой по Filter SORT и FilterGroup SORT
  652.      * @param $altName
  653.      * @return array|null
  654.      */
  655.     public function getByGroupAlias($altName)
  656.     {
  657.         $q = $this->joinQuery('f');
  659.         $q->andWhere('groups.altName = :altName');
  660.         $q->addOrderBy('groups.sort', 'ASC');
  661.         $q->setParameter('altName', $altName);
  662.         $r = $q->getQuery();
  664.         $cacheName = $this->buildCacheName('filter_getByGroupAlias', $altName);
  665.         $r->useQueryCache(true)->enableResultCache((int)TimeConstant::DAY, $cacheName);
  667.         $items = $r->getResult();
  669.         return (count($items) == 1) ? $items[0] : $items;
  670.     }
  672.     public function getListDesignersByGroupAlias($altName)
  673.     {
  674.         $q = $this->joinQuery('f');
  676.         $q->andWhere('groups.altName = :altName');
  677.         $q->andWhere('param.count > 0');
  678.         $q->addOrderBy('f.name', 'ASC');
  679.         $q->addOrderBy('groups.sort', 'ASC');
  680.         $q->setParameter('altName', $altName);
  681.         $r = $q->getQuery();
  683.         $cacheName = $this->buildCacheName('filter_getListDesignersByGroupAlias', $altName);
  684.         $r->useQueryCache(true)->enableResultCache((int)TimeConstant::DAY, $cacheName);
  686.         return $r->getResult();
  687.     }
  689.     /**
  690.      * Формирование массива ссылок на фильтры в футере
  691.      * @return array
  692.      * @throws Exception
  693.      */
  694.     public function getForFooterByGroupAlias(): array
  695.     {
  696.         $memcache = $this->cacheService->getMemcache();
  697.         $lcFull = App::getCurLocale(true);
  698.         $list = $memcache->get('footer.links.filter.' . App::isDev() . $lcFull);
  700.         if (!$list) {
  701.             $ids = [10040, 10136, 10132, 10111, 10147, 10617, 10646, 10146];
  702.             $idsStr = '10040,10136,10132,10111,10147,10617,10646,10146';
  703.             $locales = LocaleHelper::getListAvailable();
  704.             $router = App::getContainer()->get('router');
  705.             $translator = App::getTranslator();
  707.             $urlStrSql = [];
  708.             foreach ($locales as $item) {
  709.                 $urlStrSql[] = "url.{$item['code']} AS `url.{$item['code']}`";
  710.             }
  711.             $urlStrSql = implode(', ', $urlStrSql);
  713.             $sql = "SELECT
  714.                 f.id,
  715.                 f.left_menu AS leftMenu, $urlStrSql
  716.                 FROM filters f
  717.                 LEFT JOIN `locale_url` `url` ON `url`.filter_id = f.id
  718.                 WHERE f.id IN ($idsStr)
  719.                 ";
  721.             $sql = preg_replace('/[\s\n\r]+/', ' ', $sql);
  722.             $items = $this->getEntityManager()->getConnection()->fetchAllAssociative($sql);
  724.             // в многомерные массивы переводим
  725.             foreach ($items as $i => $item) {
  726.                 foreach ($item as $k => $v) {
  727.                     if (preg_match("~(.*)\.(.*)~ui", $k, $out)) {
  728.                         $k1 = $out[1];
  729.                         $k2 = $out[2];
  730.                         if (empty($item[$k1])) {
  731.                             $item[$k1] = [];
  732.                         }
  733.                         $item[$k1][$k2] = $v;
  735.                         unset($item[$k]);
  736.                     }
  737.                 }
  738.                 $items[$i] = $item;
  739.             }
  741.             $ids = array_flip($ids);
  743.             $lc_ = App::getCurLocale();
  745.             // выставляем порядок и сразу формируем имя и урл
  746.             foreach ($items as $i => $item) {
  747.                 $key = $item['leftMenu'] . '_footer';
  748.                 //$key = $item['leftMenu'];
  749.                 $name = $translator->trans($key, [], null, $lc_);
  752.                 $ids[$item['id']] = [
  753.                     'name' => $name,
  754.                     'url' => urldecode(
  755.                         $router->generate(
  756.                             'app_catalog',
  757.                             [
  758.                                 'key' => $item['url'][$lc_],
  759.                                 '_locale' => $lcFull,
  760.                             ]
  761.                         )
  762.                     ),
  763.                 ];
  764.             }
  765.             $list = $ids;
  766.             $memcache->add('footer.links.filter.' . App::isDev() . $lcFull, $list, false, 3600 * 24 * 30);
  767.         }
  769.         return $list;
  770.     }
  772.     /**
  773.      * Получение фабрики через фильтры.
  774.      * @param array $param
  775.      * @return array|null
  776.      * @throws NonUniqueResultException
  777.      * @throws Exception
  778.      * @see WebBundle/Repository/FactoryRepository::getFactory()
  779.      */
  780.     public function getBrand(array $param = [])
  781.     {
  782.         if (!empty($param['count'])) {
  783.             $q = $this->createQueryBuilder('f')
  784.                 ->select('COUNT(f.id)')
  785.                 ->leftJoin('f.brand', 'brand')
  786.                 ->leftJoin('f.param', 'param');
  787.         } else {
  788.             $q = $this->joinQuery('f');
  789.         }
  791.         $q
  792.             ->andWhere('f.brand IS NOT NULL')
  793.             ->andWhere('f.id != 10639')// 10639 это тестовая фабрика, выкидываем ее
  794.             ->andWhere('brand.status = :status')
  795.             ->andWhere('param.isEnabled = true')
  796.             ->andWhere('param.count >= 0')
  797.             ->andWhere('brand.unid IS NOT NULL')
  798.             ->setParameter('status', BiConst::STATE_PUBLISHED)
  799.             ->orderBy('f.name');
  801.         if (!empty($param['url'])) {
  802.             $q->andWhere('f.url = :url')
  803.                 ->setParameter('url', $param['url']);
  804.         }
  806.         if (!empty($param['name'])) {
  807.             $q->andWhere('f.name = :name')
  808.                 ->setParameter('name', $param['name']);
  809.         }
  811.         if (!empty($param['id'])) {
  812.             $q->andWhere('f.id = :filterId');
  813.             $q->setParameter('filterId', $param['id']);
  814.         }
  816.         if (!App::isRole('ROLE_TEST')) {
  817.             $q->andWhere('brand.testAccess IS NULL');
  818.         }
  820.         $r = $q->getQuery();
  821.         $r->useQueryCache(true)->enableResultCache((int)TimeConstant::HOUR); // час
  823.         if (!empty($param['count'])) {
  824.             $items = $r->getSingleScalarResult();
  825.         } else {
  826.             if (empty($param['asArray'])) {
  827.                 $items = $r->getResult();
  828.             } else {
  829.                 $items = $r->getArrayResult();
  830.             }
  831.         }
  833.         return $items;
  834.     }
  836.     /**
  837.      * Хелпер по получению записей брендов
  838.      * @param array $param
  839.      * @return array|null
  840.      */
  841.     public function getBrands(array $param = [])
  842.     {
  843.         $parameters = [];
  844.         $q = $this->joinQuery('f');
  845.         $q
  846.             ->andWhere("groups.altName = 'brand'")
  847.             //->andWhere('f.brand IS NOT NULL')
  848.             //->addSelect('country')
  849.             //->leftJoin('brand.country', 'country')
  850.         ;
  853.         if (!is_array($param)) {
  854.             $paramId = intval($param);
  855.             if ($paramId) {
  856.                 $param = ['id' => $paramId];
  857.             }
  858.         }
  860.         if (!empty($param['id'])) {
  861.             $q->andWhere('f.id = :brandId');
  862.             $parameters['brandId'] = $param['id'];
  863.         }
  865.         if (isset($param['noBrand'])) {
  866.             $q->andWhere('f.brand IS NULL');
  867.         }
  869.         if (!empty($param['factoryId'])) {
  870.             $q->andWhere('f.brand = :factoryId');
  871.             $parameters['factoryId'] = $param['factoryId'];
  872.         }
  874.         if (!empty($param['name'])) {
  875.             $q->andWhere('f.name = :name');
  876.             $parameters['name'] = $param['name'];
  877.         }
  879.         if (count($parameters) > 0) {
  880.             $q->setParameters($parameters);
  881.         }
  883.         $r = $q->getQuery();
  884.         $r->useQueryCache(true)->enableResultCache((int)TimeConstant::HOUR); // час
  886.         if (empty($param['asArray'])) {
  887.             $items = $r->getResult();
  888.         } else {
  889.             $items = $r->getArrayResult();
  890.         }
  892.         return $items;
  893.     }
  895.     /**
  896.      * Получение списка фильтров для меню фильтрации
  897.      * @return array|null
  898.      */
  899.     public function getArrListForFilterMenu()
  900.     {
  901.         $q = $this->joinQuery('f');
  902.         $q
  903.             ->andWhere('param.isEnabled = 1')
  904.             //->andWhere('param.showMenuAdvanced = 1')
  905.             //->andWhere('param.count > 0')
  906.             //->andWhere("(param.showMenuAdvanced = 1 AND f.oldCommand != 'factory')")
  907.             ->orderBy('f.sort ASC, f.name');
  908.         $r = $q->getQuery();
  909.         $r->useQueryCache(true)->enableResultCache((int)TimeConstant::HOUR); // час
  911.         return $r->getResult();
  912.     }
  914.     /**
  915.      * Выборка для расширенного меню фильтров
  916.      * @param $lc
  917.      * @return array
  918.      * @throws \Doctrine\DBAL\Exception
  919.      */
  920.     public function getArrListForFilterMenuNew($lc): array
  921.     {
  922.         $sql = "SELECT
  923.                 f.id,
  924.                 f.alt_name AS `altName`,
  925.                 f.sort AS `sort`,
  926.                 f.parent_id AS `pid`,
  927.                 f.old_command AS `oldCommand`,
  928.                 fp.name_menu_$lc AS `name`,
  929.                    u.$lc AS `url`,
  930.                 p.count AS `count`,
  931.                 p.hex_code AS `hexCode`,
  932.                 p.show_menu_advanced AS `showMenuAdvanced`,
  933.                 g.id AS `group.id`,
  934.                 g.alt_name AS `group.altName`,
  935.                 gname.$lc AS `group.name`,
  936.                 tooltip.$lc AS `tooltip`,
  937.                 c.id AS `country.id`,
  938.                 c.old_id AS `country.code`,
  939.                    c.alt_name AS `country.altName`,
  940.                 cp.name_menu_$lc AS `country.name`,
  941.                 b.id AS `brand.id`,
  942.                 b.name AS `brand.name`
  943.             FROM
  944.                 filters f
  945.             LEFT JOIN filter_pages fp ON fp.id = f.page_id
  946.             LEFT JOIN filter_params p ON p.id = f.param_id
  947.             LEFT JOIN filter_groups g ON g.id = f.group_id
  948.             LEFT JOIN locale_text gname ON gname.filter_group_name = g.id
  949.             LEFT JOIN locale_text tooltip ON tooltip.filter_tooltip = f.id
  950.             LEFT JOIN filters c ON c.id = f.country_id
  951.             LEFT JOIN filter_pages cp ON cp.id = c.page_id
  952.             LEFT JOIN locale_url u ON u.filter_id = f.id
  953.             LEFT JOIN factory b ON b.id = f.brand
  954.             WHERE (g.alt_name <> 'brand' AND p.show_menu_advanced = 1 OR g.alt_name = 'brand' AND b.status = 1) AND
  955.             (p.count > 0 OR g.alt_name = 'brand' OR g.alt_name = 'reviews') AND
  956.             p.is_enable = 1 AND p.hide != 1 AND p.hide_all != 1 AND f.id != '10639'
  957.             ORDER BY f.sort, f.name";
  959.         $memcache = $this->cacheService->getMemcache();
  960.         $memcacheKey = md5($sql);
  961.         $rows = $memcache->get($memcacheKey);
  963.         if ($rows) {
  964.             return $rows;
  965.         }
  967.         $items = $this->getEntityManager()->getConnection()->fetchAllAssociative($sql);
  969.         $rows = [];
  970.         foreach ($items as $item) {
  971.             $name = $item['name'];
  973.             $group = [
  974.                 'id' => intval($item['group.id']),
  975.                 'name' => $item['group.name'],
  976.                 'altName' => $item['group.altName'],
  977.             ];
  979.             // выносим в отдельную категорию крупный размер плитки
  980.             if ($item['oldCommand'] == 'size_big') {
  981.                 $group = [
  982.                     'id' => 0,
  983.                     'name' => 'Other',
  984.                     'altName' => 'other',
  985.                 ];
  986.             }
  988.             $country = null;
  989.             if (!empty($item['country.id'])) {
  990.                 $country = [
  991.                     'id' => intval($item['country.id']),
  992.                     'code' => intval($item['country.code']),
  993.                     'name' => $item['country.name'],
  994.                     'altName' => $item['country.altName'],
  995.                 ];
  996.             }
  998.             $brand = null;
  999.             if (!empty($item['brand.id'])) {
  1000.                 $brand = [
  1001.                     'id' => intval($item['brand.id']),
  1002.                     'name' => $item['brand.name'],
  1003.                 ];
  1004.                 // меняем основное имя на имя фабрики, на всякий случай
  1005.                 $name = $item['brand.name'];
  1006.             }
  1008.             // ID родительского фильтра
  1009.             $pid = intval($item['pid']);
  1010.             $pid = $pid ?: null;
  1012.             // исключил все случайно попадающие награды в список фильтров
  1013.             if ($group['altName'] == 'rewards') {
  1014.                 if ($item['id'] != '10546') {
  1015.                     continue;
  1016.                 }
  1017.             }
  1019.             $row = [
  1020.                 'id' => intval($item['id']),
  1021.                 'pid' => $pid,
  1022.                 'name' => $name,
  1023.                 'altName' => $item['altName'],
  1024.                 'tooltip' => $item['tooltip'],
  1025.                 'oldCommand' => $item['oldCommand'],
  1026.                 'key' => $item['url'],
  1027.                 'hexCode' => $item['hexCode'],
  1028.                 'count' => intval($item['count']),
  1029.                 'sort' => intval($item['sort']),
  1030.                 'showMenuAdvanced' => boolval($item['showMenuAdvanced']),
  1031.                 'group' => $group,
  1032.                 'brand' => $brand,
  1033.                 'country' => $country,
  1034.                 'collection' => [],
  1035.                 'selected' => [],
  1036.                 'sub' => [],
  1037.                 'groupList' => [],
  1038.             ];
  1040.             $rows[$row['id']] = $row;
  1041.         }
  1043.         $memcache->set($memcacheKey, $rows);
  1045.         return $rows;
  1046.     }
  1048.     /**
  1049.      * Выборка для истории фильтров
  1050.      *
  1051.      * @param $lc
  1052.      *
  1053.      * @return array
  1054.      * @throws \Doctrine\DBAL\Exception
  1055.      */
  1056.     public function getNamePerFilter($lc): array
  1057.     {
  1058.         $sql = "SELECT filters.id, filter_pages.name_many_$lc as name FROM `filters` left join filter_pages on `filters`.page_id=filter_pages.id where filter_pages.name_many_$lc is not null;";
  1060.         $memcache = $this->cacheService->getMemcache();
  1061.         $memcacheKey = md5($sql);
  1062.         $rows = $memcache->get($memcacheKey);
  1064.         if ($rows) {
  1065.             return $rows;
  1066.         }
  1068.         $items = $this->getEntityManager()
  1069.             ->getConnection()
  1070.             ->fetchAllAssociative($sql);
  1073.         $memcache->set($memcacheKey, $items);
  1075.         return $items;
  1076.     }
  1077.     /**
  1078.      * Получаем массив всех фильтров для меню
  1079.      * @param null $groups
  1080.      * @param      $lc
  1081.      * @param bool $ignoreEnabled
  1082.      * @return array|null
  1083.      * @throws Exception
  1084.      */
  1085.     public function getArrListForMenu($groups, $lc, bool $ignoreEnabled = false): ?array
  1086.     {
  1087.         $lcUc = ucfirst($lc);
  1089.         $selectByLc = "url.$lc url$lcUc, page.nameMenu$lcUc pageNameMenu$lcUc,";
  1091.         // костыль для фильтра цен, что бы показывать верно для разных стран
  1092.         $lcPrice = LocaleHelper::getLocaleForPriceFilter($lc);
  1093.         if ($lc != $lcPrice) {
  1094.             $lcUcPrice = ucfirst($lcPrice);
  1095.             $selectByLc .= "url.$lcPrice url$lcUcPrice, page.nameMenu$lcUcPrice pageNameMenu$lcUcPrice,";
  1096.         }
  1098.         $q = $this->createQueryBuilder('f')
  1099.             ->select(
  1100.                 "
  1101.             f,
  1102.             f.id,
  1103.             f.oldCommand,
  1104.             f.oldId,
  1105.             f.leftMenu,
  1106.             parent.id pid,
  1107.             f.important,
  1108.             $selectByLc
  1109.             groups.altName groupsAltName,
  1110.             param.count paramCount,
  1111.             country
  1112.             "
  1113.             )
  1114.             ->leftJoin('f.url', 'url')
  1115.             ->leftJoin('f.page', 'page')
  1116.             ->leftJoin('f.param', 'param')
  1117.             ->leftJoin('f.groups', 'groups')
  1118.             ->leftJoin('f.country', 'country')
  1119.             ->leftJoin('f.parent', 'parent');
  1121.         if (!$ignoreEnabled) {
  1122.             $q
  1123.                 ->andWhere('param.isEnabled = 1')
  1124.                 ->andWhere('param.showMenu = 1 OR param.showMenuAdvanced = 1')
  1125.                 ->andWhere('url.' . $lc . '  is not null')
  1126.                 ->andWhere('param.count > 0');
  1127.         }
  1128.         $q->orderBy('f.sort ASC, f.name');
  1130.         if ($groups) {
  1131.             $groups = is_array($groups) ? $groups : [$groups];
  1132.             $q->andWhere('groups.altName IN (:groups)')
  1133.                 ->setParameter('groups', $groups);
  1134.         }
  1135.         $r = $q->getQuery();
  1137.         $cacheName = $this->buildCacheName('filter_getArrListForMenu3_' . $lc . $lcPrice, $groups);
  1138.         $r->useQueryCache(true);
  1140.         if (!App::isDev() or !$ignoreEnabled) {
  1141.             $r->enableResultCache(TimeConstant::DAY, $cacheName);
  1142.         }
  1144.         $res = [];
  1145.         $items = $r->getArrayResult();
  1147.         /** @var FilterEntity $item */
  1148.         foreach ($items as $item) {
  1149.             $f = $item[0];
  1150.             unset($item[0]);
  1151.             $item['country'] = $f['country'];
  1152.             $res[$item['groupsAltName']][] = $item;
  1153.         }
  1155.         return $res;
  1156.     }
  1158.     /**
  1159.      * Получаем массив всех детей по рабителю для фейк тегов
  1160.      * @param null $groups
  1161.      * @param      $lc
  1162.      * @param bool $ignoreEnabled
  1163.      * @return array|null
  1164.      * @throws Exception
  1165.      */
  1166.     public function getArrListSubForMenu($pid, $lc, bool $ignoreEnabled = false): ?array
  1167.     {
  1168.         $lcUc = ucfirst($lc);
  1170.         $selectByLc = "url.$lc url$lcUc, page.nameMenu$lcUc pageNameMenu$lcUc,";
  1172.         // костыль для фильтра цен, что бы показывать верно для разных стран
  1173.         $lcPrice = LocaleHelper::getLocaleForPriceFilter($lc);
  1174.         if ($lc != $lcPrice) {
  1175.             $lcUcPrice = ucfirst($lcPrice);
  1176.             $selectByLc .= "url.$lcPrice url$lcUcPrice, page.nameMenu$lcUcPrice pageNameMenu$lcUcPrice,";
  1177.         }
  1179.         $q = $this->createQueryBuilder('f')
  1180.             ->select(
  1181.                 "
  1182.             $selectByLc
  1183.             f
  1184.             "
  1185.             )
  1186.             ->leftJoin('f.url', 'url')
  1187.             ->leftJoin('f.page', 'page')
  1188.             ->leftJoin('f.param', 'param')
  1189.             ->leftJoin('f.groups', 'groups')
  1190.             ->leftJoin('f.country', 'country')
  1191.             ->leftJoin('f.parent', 'parent');
  1193.         if (!$ignoreEnabled) {
  1194.             $q
  1195.                 ->andWhere('param.isEnabled = 1')
  1196.                 ->andWhere('parent.id = ' . $pid)
  1197.                 ->andWhere('param.showMenu = 1 OR param.showMenuAdvanced = 1')
  1198.                 ->andWhere('url.' . $lc . '  is not null')
  1199.                 ->andWhere('param.count > 0');
  1200.         }
  1201.         $q->orderBy('f.sort ASC, f.name');
  1203.         $r = $q->getQuery();
  1205.         $cacheName = $this->buildCacheName('filter_getArrListSubMenu_' . $lc . $lcPrice, $pid);
  1206.         // $r->useQueryCache(true);
  1208.         if (!App::isDev() or !$ignoreEnabled) {
  1209.             $r->enableResultCache(TimeConstant::DAY, $cacheName);
  1210.         }
  1212.         $res = [];
  1213.         $items = $r->getArrayResult();
  1215.         /** @var FilterEntity $item */
  1216.         foreach ($items as $item) {
  1217.             $f = $item[0];
  1218.             unset($item[0]);
  1219.             $item['url'] = $item["url$lcUc"];
  1220.             $item['pageNameMenu'] = $item["pageNameMenu$lcUc"];
  1222.             $res[] = $item;
  1223.         }
  1225.         return $res;
  1226.     }
  1228.     public function getFilterIdForSettingsCollectionByLeft($leftMenu)
  1229.     {
  1230.         $q = $this->createQueryBuilder('f')
  1231.             ->select('f.id, f.name')
  1232.             ->leftJoin('f.url', 'url')
  1233.             ->leftJoin('f.page', 'page')
  1234.             ->andWhere('f.leftMenu = :leftMenu')
  1235.             ->setParameter('leftMenu', $leftMenu)
  1236.             ->getQuery()
  1237.             ->enableResultCache(TimeConstant::DAY);
  1239.         $id = $q->getArrayResult();
  1241.         return $id ? $id[0] : null;
  1242.     }
  1244.     public function getFilterIdForSettingsColletionByIdDesigner(int $id)
  1245.     {
  1246.         $q = $this->createQueryBuilder('f')
  1247.             ->select('f.id, f.name')
  1248.             ->leftJoin('f.url', 'url')
  1249.             ->leftJoin('f.page', 'page')
  1250.             ->andWhere('f.id = :id')->setParameter('id', $id)
  1251.             ->andWhere('f.oldCommand != :oldCommand')->setParameter('oldCommand', 'factory');
  1253.         $q = $q->getQuery()->enableResultCache(TimeConstant::DAY);
  1255.         $id = $q->getArrayResult();
  1257.         return $id ? $id[0] : null;
  1258.     }
  1260.     /**
  1261.      * Получаем массив данных фильтра для свойств коллекции
  1262.      * URL и имя формируется сразу по локали
  1263.      * @param      $oldId
  1264.      * @param      $oldCommand
  1265.      * @param null $locale
  1266.      * @return mixed|null
  1267.      * @throws Exception
  1268.      */
  1269.     public function findFilterForSettingsColletion($oldId, $oldCommand, $locale = null)
  1270.     {
  1271.         $locale = $locale ?: App::getCurLocale();
  1272.         $localeUc = ucfirst($locale);
  1273.         $key = 'filter_' . $oldId . '_' . $oldCommand . '_' . $locale;
  1274.         $res = App::getMemcache()->get($key);
  1276.         if (!$res) {
  1277.             $q = $this->createQueryBuilder('f');
  1278.             $q->select('f, f.id, f.oldId, f.oldCommand, f.altName, f.rank, url, page');
  1279.             $q
  1280.                 ->leftJoin('f.url', 'url')
  1281.                 ->leftJoin('f.page', 'page');
  1282.             $q
  1283.                 ->andWhere("f.oldId = :old_id")
  1284.                 ->setParameter('old_id', $oldId)
  1285.                 ->andWhere("f.oldCommand = :old_command")
  1286.                 ->setParameter('old_command', $oldCommand);
  1287.             $q->setMaxResults(1);
  1289.             $r = $q->getQuery()->enableResultCache(TimeConstant::DAY);
  1291.             $item = ArrHelper::get($r->getArrayResult(), '0');
  1292.             if (!$item) {
  1293.                 return null;
  1294.             }
  1295.             $item['url'] = ArrHelper::get($item, "0.url.$locale");
  1296.             $item['name'] = ArrHelper::get($item, "0.page.nameMany$localeUc");
  1297.             unset($item[0]);
  1299.             if (!defined('DB_NOT_CASHED')) {
  1300.                 App::getMemcache()->set($key, $item, false, (int)TimeConstant::WEEK); // неделя
  1301.             }
  1303.             $res = $item;
  1304.         }
  1306.         return $res;
  1307.     }
  1309.     /**
  1310.      * Получаем список активных фильтров для просчета ранга
  1311.      * @return array|null
  1312.      */
  1313.     public function getForCalcRank()
  1314.     {
  1315.         $q = $this->createQueryBuilder('f');
  1316.         $q->select('f.id, f.name, f.rank, param.count, groups.id gid')
  1317.             ->leftJoin('f.groups', 'groups')
  1318.             ->leftJoin('f.param', 'param')
  1319.             ->andWhere("groups.id != 406")// исключаем бренды
  1320.             //->andWhere("groups.id != 411")// исключаем дизайнеров
  1321.             ->andWhere("groups.id != 408")// исключаем Размер
  1322.             ->andWhere("groups.id != 412")// исключаем top
  1323.             ->andWhere("groups.id != 415")// исключаем page
  1324.             ->andWhere("groups.id != 416")// исключаем БМ
  1325.             ->andWhere("groups.id != 407")// исключаем Сортировка
  1326.             ->andWhere("groups.id != 399")// исключаем распродажа
  1327.             ->andWhere("param.isEnabled = 1")//->andWhere("param.showMenu = 1")
  1328.         ;
  1330.         $result = $q->getQuery()->enableResultCache(TimeConstant::DAY);
  1332.         $res = [];
  1333.         foreach ($result->getArrayResult() as $i => $item) {
  1334.             $res[$item['id']] = $item;
  1335.         }
  1337.         return $res;
  1338.     }
  1341.     /**
  1342.      * @param string $key
  1343.      * @return FilterEntity|null
  1344.      */
  1345.     public function admGetExhibitionByKeyForConsole(string $key)
  1346.     {
  1347.         $q = $this->createQueryBuilder('f');
  1348.         $q->select('f, groups, param, page')
  1349.             ->leftJoin('f.groups', 'groups')
  1350.             ->leftJoin('f.param', 'param')
  1351.             ->leftJoin('f.page', 'page')
  1352.             ->andWhere("f.name LIKE '$key%'")
  1353.             ->andWhere('param.isEnabled = 1')
  1354.             ->andWhere('groups.id = 420 OR groups.id = 417')
  1355.             ->orderBy('f.id', 'DESC')
  1356.             ->setMaxResults(1);
  1358.         try {
  1359.             return $q->getQuery()->getSingleResult();
  1360.         } catch (NoResultException | NonUniqueResultException $e) {
  1361.             return null;
  1362.         }
  1363.     }
  1365.     /**
  1366.      * Получаем последний ID для сфинкса из группы
  1367.      * @param int $groupId
  1368.      * @return int
  1369.      * @throws Throwable
  1370.      */
  1371.     public function admGetExhibitionLastOldIdForConsole(int $groupId): int
  1372.     {
  1373.         $sql = "SELECT  f.old_id AS `oldId`
  1374.                 FROM filters f
  1375.                 WHERE f.group_id = $groupId
  1376.                 ORDER BY f.old_id DESC LIMIT 1";
  1378.         $oldId = $this->getEntityManager()
  1379.             ->getConnection()
  1380.             ->executeQuery($sql)
  1381.             ->fetchOne();
  1383.         return intval($oldId);
  1384.     }
  1387.     /**
  1388.      * Получение последнего дизайнера, для использования в качестве шаблона для создания нового
  1389.      * @return FilterEntity|null
  1390.      */
  1391.     public function admLastDesigner(): ?FilterEntity
  1392.     {
  1393.         $q = $this->createQueryBuilder('f');
  1394.         $q->select('f, groups, param, page')
  1395.             ->leftJoin('f.groups', 'groups')
  1396.             ->leftJoin('f.param', 'param')
  1397.             ->leftJoin('f.page', 'page')
  1398.             ->andWhere("f.parentKey = 'designer'")
  1399.             ->andWhere('param.isEnabled = 1')
  1400.             ->orderBy('f.id', 'DESC')
  1401.             ->setMaxResults(1);
  1403.         try {
  1404.             return $q->getQuery()->getSingleResult();
  1405.         } catch (NoResultException | NonUniqueResultException $e) {
  1406.             return null;
  1407.         }
  1408.     }
  1410.     /**
  1411.      * Поиск последней заполненной переводами записи награды.
  1412.      */
  1413.     public function getLastRewards(): ?FilterEntity
  1414.     {
  1415.         $q = $this->createQueryBuilder('f');
  1417.         $q->select('f, groups, param, page')
  1418.             ->innerJoin('f.groups', 'groups')
  1419.             ->leftJoin('f.param', 'param')
  1420.             ->innerJoin('f.page', 'page')
  1421.             ->where('groups.id = :groupId')
  1422.             ->andWhere('param.isEnabled = 1')
  1423.             ->andWhere('page.nameSingleEn IS NOT NULL AND page.nameSingleEn != :empty')
  1424.             ->andWhere('page.descriptionEn IS NOT NULL AND page.descriptionEn != :empty')
  1425.             ->orderBy('f.id', 'DESC')
  1426.             ->setMaxResults(1)
  1427.             ->setParameters([
  1428.                 'groupId' => FilterGroupEnum::REWARD,
  1429.                 'empty' => ''
  1430.             ]);
  1432.         $query = $q->getQuery();
  1434.         $query->useQueryCache(true);
  1435.         $query->setQueryCacheLifetime(self::QUERY_CACHE_LIFETIME);
  1437.         try {
  1438.             return $query->getSingleResult();
  1439.         } catch (NoResultException | NonUniqueResultException $e) {
  1440.             return null;
  1441.         }
  1442.     }
  1444.     /**
  1445.      * Получение списка наград для выпадающего списка
  1446.      * @return array
  1447.      */
  1448.     public function admGetAwardsForSelectMenu(): array
  1449.     {
  1450.         $q = $this->createQueryBuilder('f');
  1451.         $q->select('f.id, f.name')
  1452.             ->leftJoin('f.groups', 'groups')
  1453.             ->andWhere("groups.altName = 'rewards'")
  1454.             ->andWhere("f.oldId != 1") // исключаем фильтр общий Премированные
  1455.         ;
  1457.         $res = [];
  1458.         $out = $q->getQuery()->getArrayResult();
  1459.         foreach ($out as $i => $item) {
  1460.             $res[(string)$item['id']] = $item['name'];
  1461.         }
  1463.         return $res;
  1464.     }
  1466.     /**
  1467.      * Список выставок для БИ и админки
  1468.      * @return array
  1469.      */
  1470.     public function admGetExhibitionForSelectMenu(): array
  1471.     {
  1472.         $q = $this->createQueryBuilder('f');
  1473.         $q->select('f.oldId id, f.name')
  1474.             ->leftJoin('f.groups', 'groups')
  1475.             ->andWhere("groups.altName = 'exhibition'");
  1477.         $res = [];
  1478.         $out = $q->getQuery()->getArrayResult();
  1479.         foreach ($out as $i => $item) {
  1480.             $res[(string)$item['id']] = $item['name'];
  1481.         }
  1483.         return $res;
  1484.     }
  1486.     /**
  1487.      * @param $exhibition
  1488.      * @return array
  1489.      */
  1490.     public function admGetExhibitionForBI($exhibition): array
  1491.     {
  1492.         $q = $this->createQueryBuilder('f');
  1493.         $q->select('f.id, f.name, f.iconUrl')
  1494.             ->leftJoin('f.groups', 'groups')
  1495.             ->leftJoin('f.param', 'param')
  1496.             ->andWhere("groups.altName = 'exhibition'")
  1497.             ->andWhere("f.oldId in (:exhibition)")
  1498.             ->setParameter('exhibition', $exhibition);
  1500.         $res = [];
  1501.         $out = $q->getQuery()->getArrayResult();
  1502.         foreach ($out as $i => $item) {
  1503.             $link = $item['iconUrl'];
  1504.             $res[(string)$item['id']] = (!empty($link)) ? $item['name'] . '(<a href="' . $link . '" target="_blank" rel="noopener noreferrer">' . $link . '</a>)' : $item['name'];
  1505.         }
  1507.         return $res;
  1508.     }
  1510.     public function admGetAwardsForBi($awards): array
  1511.     {
  1512.         $q = $this->createQueryBuilder('f');
  1513.         $q->select('f.id, f.name, f.iconUrl')
  1514.             ->leftJoin('f.groups', 'groups')
  1515.             ->andWhere("groups.altName = 'rewards'")
  1516.             ->andWhere("f.oldId != 1") // исключаем фильтр общий Премированные
  1517.             ->andWhere("f.id in (:awards)")
  1518.             ->setParameter('awards', $awards);
  1519.         $res = [];
  1520.         $out = $q->getQuery()->getArrayResult();
  1521.         foreach ($out as $i => $item) {
  1522.             $link = $item['iconUrl'];
  1523.             $res[(string)$item['id']] = (!empty($link)) ? $item['name'] . '(<a href="' . $link . '" target="_blank" rel="noopener noreferrer">' . $link . '</a>)' : $item['name'];
  1524.         }
  1526.         return $res;
  1527.     }
  1529.     public function admGetForJsTree(): array
  1530.     {
  1531.         $q = $this->createQueryBuilder('f');
  1532.         $q->select('f.id, f.name, groups.id gr_id, groups.altName gr_name')
  1533.             ->leftJoin('f.groups', 'groups')
  1534.             ->leftJoin('f.param', 'param')
  1535.             ->andWhere("groups.id != 411")// исключаем дизайнеров
  1536.             ->andWhere("groups.id != 408")// исключаем Размер
  1537.             //->andWhere("groups.id != 412")// исключаем top
  1538.             ->andWhere("groups.id != 415")// исключаем page
  1539.             ->andWhere("groups.id != 416")// исключаем БМ
  1540.             ->andWhere("groups.id != 407")// исключаем Сортировка
  1541.             ->andWhere("groups.id != 399")// исключаем распродажа
  1542.             ->andWhere("param.isEnabled = true")
  1543.             ->andWhere("param.showMenuAdvanced = true")
  1544.             ->orderBy('gr_name', 'ASC')
  1545.             ->addOrderBy('f.name', 'ASC')
  1546.             ->andWhere("groups.id != 406") // исключаем бренды
  1547.             //->andWhere("groups.id = 397") // временно, что бы был один
  1548.         ;
  1550.         $items = $q->getQuery()->getArrayResult();
  1552.         $res = [];
  1553.         foreach ($items as $item) {
  1554.             $res[$item['gr_id']][] = $item;
  1555.         }
  1557.         return $res;
  1558.     }
  1560.     public function getSortListCataloge($locale = null)
  1561.     {
  1562.         $locale = $locale ?: App::getCurLocale();
  1563.         $localeUc = ucfirst($locale);
  1565.         $q = $this->createQueryBuilder('f')
  1566.             ->select("f.oldId as id, page.nameSingle$localeUc as nameSingle, page.nameMenu$localeUc as nameMenu")
  1567.             ->leftJoin('f.page', 'page')
  1568.             ->leftJoin('f.groups', 'gr')
  1569.             ->andWhere('gr.id = 407')
  1570.             ->orderBy('f.sort', 'ASC');
  1572.         $r = $q->getQuery()
  1573.             ->useQueryCache(true);
  1575.         $items = $r->getArrayResult();
  1576.         $res = [];
  1578.         foreach ($items as $item) {
  1579.             $res[$item['id']] = $item;
  1580.         }
  1582.         return $res;
  1583.     }
  1585.     public function getSameSingleByLeft($locale = null, $alias = '')
  1586.     {
  1587.         $locale = $locale ?: App::getCurLocale();
  1588.         $localeUc = ucfirst($locale);
  1590.         $q = $this->createQueryBuilder('f')
  1591.             ->select(" page.nameSingle$localeUc as nameSingle")
  1592.             ->leftJoin('f.page', 'page')
  1593.             ->leftJoin('f.groups', 'gr')
  1594.             ->andWhere('f.leftMenu = :alias')
  1595.             ->setParameter('alias', $alias)
  1596.             ->orderBy('f.sort', 'ASC');
  1598.         $r = $q->getQuery()
  1599.             ->useQueryCache(true);
  1601.         $items = $r->getSingleScalarResult();
  1604.         return $items;
  1605.     }
  1606.     public function getAwards(array $id)
  1607.     {
  1608.         $localeUc = ucfirst(App::getCurLocale());
  1610.         if (count($id) == 0) {
  1611.             return [];
  1612.         }
  1614.         if (is_array($id)) {
  1615.             $id = implode(', ', $id);
  1616.             $id = "($id)";
  1617.         }
  1619.         $q = $this->createQueryBuilder('f')
  1620.             ->select("f.id, f.icon, f.iconUrl, page.nameSingle$localeUc")
  1621.             ->leftJoin('f.page', 'page')
  1622.             //            ->andWhere('f.icon IS NOT NULL') решили выводить данные https://te.remote.team/#/discus/649252D6-AAD4-D219-FD67-BBF3CDCA1062/
  1623.             ->andWhere("f.id IN $id");
  1625.         $r = $q->getQuery()->useQueryCache(true);
  1627.         $items = $r->getArrayResult();
  1629.         $res = [];
  1630.         foreach ($items as $item) {
  1631.             $res[$item['id']] = [
  1632.                 'id' => $item['id'],
  1633.                 'icon' => PathHelper::pathGenerate('filter', $item),
  1634.                 'title' => $item["nameSingle$localeUc"],
  1635.                 'url' => $item['iconUrl'],
  1636.             ];
  1637.         }
  1639.         return $res;
  1640.     }
  1642.     /**
  1643.      * Получаем выставки по oldId
  1644.      * @param array $id
  1645.      * @return array
  1646.      * @throws Exception
  1647.      */
  1648.     public function getExhibitions(array $id): array
  1649.     {
  1650.         $lcVo = new LocaleVo();
  1651.         $lc = $lcVo->getCode();
  1652.         $lcUc = ucfirst($lc);
  1653.         $lcFull = $lcVo->getCodeFull();
  1655.         $id = array_filter($id);
  1656.         if (count($id) == 0) {
  1657.             return [];
  1658.         }
  1660.         $id = implode(', ', $id);
  1661.         $id = "($id)";
  1663.         $q = $this->createQueryBuilder('f')
  1664.             ->select(
  1665.                 "f.id, f.oldId, f.iconUrl, tooltip.$lc as tooltipLc , page.nameMenu$lcUc, url.$lc as urlLocal"
  1666.             )
  1667.             ->leftJoin('f.page', 'page')
  1668.             ->leftJoin('f.url', 'url')
  1669.             ->leftJoin('f.param', 'param')
  1670.             ->leftJoin('f.tooltip', 'tooltip')
  1671.             ->andWhere('param.isEnabled = 1')
  1672.             ->andWhere('param.count > 0')
  1673.             ->andWhere("f.oldCommand = 'exhibition'")
  1674.             ->andWhere("f.oldId IN $id");
  1676.         $r = $q->getQuery()->enableResultCache(TimeConstant::DAY);
  1678.         $router = App::getRouter();
  1679.         $items = $r->getArrayResult();
  1680.         $res = [];
  1681.         foreach ($items as $item) {
  1682.             $name = $item["nameMenu$lcUc"];
  1684.             // показываем бирки только с возрастом не более 2-х лет
  1685.             $year = intval(preg_replace('/\D/', '', $name));
  1686.             $yearLimit = intval(date("Y")) - 2;
  1687.             if ($year <= $yearLimit) {
  1688.                 continue;
  1689.             }
  1691.             $res[$item['id']] = [
  1692.                 'id' => $item['id'],
  1693.                 'sphinxId' => $item['oldId'],
  1694.                 'name' => $name,
  1695.                 'tooltip' => $item['tooltipLc'],
  1696.                 'urlRemote' => $item['iconUrl'],
  1697.                 'urlLocal' => $router->generate('app_catalog', ['key' => $item['urlLocal'], '_locale' => $lcFull]),
  1698.             ];
  1699.         }
  1701.         return $res;
  1702.     }
  1704.     /**
  1705.      * Получаем список url фильтров по языку для sitemap
  1706.      * @param $lang
  1707.      * @return array|null
  1708.      */
  1709.     public function getListUrlFiltersByLang($lang): ?array
  1710.     {
  1711.         $q = $this->createQueryBuilder('f')
  1712.             ->select("u.$lang url, f.leftMenu, f.oldCommand, f.id")
  1713.             ->leftJoin('f.url', 'u')
  1714.             ->leftJoin('f.groups', 'g')
  1715.             ->leftJoin('f.param', 'p')
  1716.             ->andWhere('p.hide = 0')
  1717.             ->andWhere('p.count > 0')
  1718.             ->andWhere('g.id NOT IN (:groups)')
  1719.             ->setParameter('groups', [407, 416, 417])
  1720.             ->getQuery();
  1722.         $cacheName = $this->buildCacheName('filter_getListUrlFiltersByLang', $lang);
  1723.         $q->useQueryCache(true)->enableResultCache((int)TimeConstant::DAY, $cacheName);
  1725.         return $q->getArrayResult();
  1726.     }
  1728.     /**
  1729.      * Получение списка для проверки на наличие кириллических символов
  1730.      * @return array
  1731.      */
  1732.     public function getCollectionsAdmForCheckCyrillic(): array
  1733.     {
  1734.         $q = $this->createQueryBuilder('f')
  1735.             ->select('f, page')
  1736.             ->leftJoin('f.page', 'page')
  1737.             ->leftJoin('f.param', 'param')
  1738.             ->andWhere("param.isEnabled = true");
  1740.         return $q->getQuery()->getArrayResult();
  1741.     }
  1743.     /**
  1744.      * Получение ID фильтра по ID бренда
  1745.      * @param $idBrand
  1746.      * @return mixed|null
  1747.      * @throws NonUniqueResultException
  1748.      */
  1749.     public function getIdFilterByIdBrand($idBrand)
  1750.     {
  1751.         $q = $this
  1752.             ->createQueryBuilder('f')
  1753.             ->select('f.id')
  1754.             ->leftJoin('f.brand', 'brand')
  1755.             ->andWhere('brand.id = :idBrand')
  1756.             ->setParameter('idBrand', $idBrand)
  1757.             ->setMaxResults(1)
  1758.             ->getQuery();
  1760.         try {
  1761.             $id = $q->getSingleResult();
  1762.             $id = $id['id'];
  1763.         } catch (NoResultException $e) {
  1764.             return null;
  1765.         }
  1767.         return $id;
  1768.     }
  1771.     /**
  1772.      * Проставляем связи фильтра с коллекциями
  1773.      * @param int $fID
  1774.      * @param     $cIDs
  1775.      * @return bool
  1776.      * @throws Throwable
  1777.      */
  1778.     public function setCollections(int $fID, $cIDs)
  1779.     {
  1780.         if (!$cIDs) {
  1781.             return false;
  1782.         }
  1784.         $conn = $this->getEntityManager()->getConnection();
  1785.         $cIDs = is_array($cIDs) ? $cIDs : [$cIDs];
  1787.         // находим коллекции, которых нет больше и удаляем их
  1788.         $cIDstr = implode(',', $cIDs);
  1789.         $conn->executeStatement(
  1790.             "DELETE FROM `collection_filters` WHERE `collection_id` NOT IN ($cIDstr) AND `filter_id` = '$fID';"
  1791.         );
  1794.         // проставляем связи для всех остальных записей
  1795.         // делаем порциями по почке запросов за раз
  1796.         $maxPortion = 100;
  1797.         $sqlUpdate = '';
  1798.         $cnt = 0;
  1799.         foreach ($cIDs as $cID) {
  1800.             $sqlUpdate .= "INSERT INTO `collection_filters` (`collection_id`,`filter_id`)  VALUES  ('$cID', '$fID') ON DUPLICATE KEY UPDATE collection_id='$cID', filter_id='$fID';";
  1802.             $cnt++;
  1804.             if ($cnt == $maxPortion) {
  1805.                 $sth = $conn->prepare($sqlUpdate);
  1806.                 $sth->execute();
  1807.                 $sth->closeCursor();
  1809.                 $cnt = 0;
  1810.                 $sqlUpdate = '';
  1811.             }
  1812.         }
  1814.         if ($sqlUpdate != '') {
  1815.             $sth = $conn->prepare($sqlUpdate);
  1816.             $sth->execute();
  1817.             $sth->closeCursor();
  1818.         }
  1820.         return true;
  1821.     }
  1823.     /**
  1824.      * Получение фильтра для DTO выставки
  1825.      * @param $fids
  1826.      * @param $lc
  1827.      * @return array
  1828.      * @throws \Doctrine\DBAL\Exception
  1829.      */
  1830.     public function getForExhDTO($fids, $lc)
  1831.     {
  1832.         if (!$fids) {
  1833.             return [];
  1834.         }
  1835.         $fidsStr = implode(',', $fids);
  1837.         $sql = "SELECT
  1838.                 f.id,
  1839.                 f.alt_name AS `altName`,
  1840.                 f.old_command AS `nameSphinx`,
  1841.                 fp.name_menu_$lc AS `name`,
  1842.                 fp.name_many_$lc AS `nameMany`,
  1843.                 fp.name_single_$lc AS `nameFull`,
  1844.                 p.count AS `count`,
  1845.                 p.hex_code AS `hexCode`,
  1846.                 p.show_menu_advanced AS `showMenuAdvanced`,
  1847.                 p.show_menu AS `showMenu`,
  1848.                 g.alt_name AS `groupAltName`,
  1849.                 gname.$lc AS `groupName`,
  1850.                 c.id AS `countryId`,
  1851.                 c.old_id AS `countryOldId`,
  1852.                 cfp.name_menu_$lc AS `countryName`,
  1853.                 u.$lc AS `slug`
  1854.             FROM
  1855.                 filters f
  1856.             LEFT JOIN filter_pages fp ON fp.id = f.page_id
  1857.             LEFT JOIN filter_params p ON p.id = f.param_id
  1858.             LEFT JOIN filter_groups g ON g.id = f.group_id
  1859.             LEFT JOIN locale_text gname ON gname.filter_group_name = g.id
  1860.             LEFT JOIN filters c ON c.id = f.country_id
  1861.             LEFT JOIN filter_pages cfp ON cfp.id = c.page_id
  1862.             LEFT JOIN locale_url u ON u.filter_id = f.id
  1863.             WHERE f.id IN ($fidsStr) AND
  1864.             p.count > 0 AND
  1865.             g.alt_name != 'top' AND
  1866.             g.alt_name != 'release_year_collection' AND
  1867.             g.alt_name != 'price' AND
  1868.             g.alt_name != 'brand' AND
  1869.             f.alt_name != 'cataloge' AND
  1870.             g.alt_name != 'using' AND
  1871.             p.is_enable = 1
  1872.             ORDER BY f.sort, f.name";
  1874.         $memcache = $this->cacheService->getMemcache();
  1875.         $memcacheKey = md5($sql);
  1876.         $items = $memcache->get($memcacheKey);
  1878.         if ($items) {
  1879.             return $items;
  1880.         }
  1882.         $items = $this->getEntityManager()->getConnection()->fetchAllAssociative($sql);
  1884.         $memcache->set($memcacheKey, $items);
  1886.         return $items;
  1887.     }
  1889.     /**
  1890.      * Получение имени для графика статистик в админке
  1891.      * @param array $fids
  1892.      * @param bool $isBrand
  1893.      * @return array
  1894.      */
  1895.     public function getNamesForStatChartAdmin(array $fids, bool $isBrand = false)
  1896.     {
  1897.         $fidsStr = implode(',', $fids);
  1899.         if ($isBrand) {
  1900.             $where = "WHERE f.brand IN ($fidsStr)";
  1901.         } else {
  1902.             $where = "WHERE f.id IN ($fidsStr)";
  1903.         }
  1905.         $sql = "SELECT
  1906.                 f.id,
  1907.                 f.brand,
  1908.                 fp.name_menu_ru AS `name`
  1909.             FROM
  1910.                 filters f
  1911.             LEFT JOIN filter_pages fp ON fp.id = f.page_id
  1912.             $where
  1913.             ORDER BY fp.name_menu_ru ASC";
  1915.         $sql = preg_replace('/[\s\n\r]+/', ' ', $sql);
  1916.         $items = $this->getEntityManager()->getConnection()->fetchAll($sql);
  1918.         $r = [];
  1920.         foreach ($items as $item) {
  1921.             $id = $isBrand ? $item['brand'] : $item['id'];
  1922.             $r[$id] = [
  1923.                 'name' => $item['name'],
  1924.                 'data' => [],
  1925.             ];
  1926.         }
  1928.         return $r;
  1929.     }
  1931.     /**
  1932.      * @return array
  1933.      */
  1934.     public function admGetDesigners()
  1935.     {
  1936.         $q = $this->createQueryBuilder('f');
  1937.         $q->select('f.id, f.name')
  1938.             ->leftJoin('f.groups', 'groups')
  1939.             ->andWhere("groups.altName = 'designer'")
  1940.             ->andWhere("f.oldId != 1")
  1941.             ->orderBy('f.name');
  1943.         $res = [];
  1944.         $out = $q->getQuery()->getArrayResult();
  1945.         foreach ($out as $i => $item) {
  1946.             $res[$item['name']] = StrHelper::toLower($item['name']);
  1947.         }
  1949.         return $res;
  1950.     }
  1952.     public function admGetDesignersId()
  1953.     {
  1954.         $q = $this->createQueryBuilder('f');
  1955.         $q->select('f.id, f.name')
  1956.             ->leftJoin('f.groups', 'groups')
  1957.             ->andWhere("groups.altName = 'designer'")
  1958.             ->andWhere("f.oldId != 1")
  1959.             ->orderBy('f.name');
  1961.         return $q->getQuery()->getArrayResult();
  1962.     }
  1964.     /**
  1965.      * Выборка фильтров для формирования свойств коллекции
  1966.      * @param $fids
  1967.      * @param null $lc
  1968.      * @return array
  1969.      */
  1970.     public function getForCollSettings($fids, $lc = null): array
  1971.     {
  1972.         $lc = $lc ?: App::getCurLocale();
  1973.         $fidsStr = implode(',', $fids);
  1975.         $sql = "SELECT
  1976.                 f.id,
  1977.                 f.rank AS `rank`,
  1978.                 f.alt_name AS `altName`,
  1979.                 f.old_command AS `sphinxName`,
  1980.                 f.old_id AS `sphinxId`,
  1981.                 fp.name_menu_$lc AS `name`,
  1982.                 fp.name_many_$lc AS `nameMany`,
  1983.                 fp.name_single_$lc AS `nameFull`,
  1984.                 p.count AS `count`,
  1985.                 g.id AS `group.id`,
  1986.                 g.alt_name AS `group.altName`,
  1987.                 gname.$lc AS `group.name`,
  1988.                 url.$lc AS `slug`
  1989.             FROM
  1990.                 filters f
  1991.             LEFT JOIN filter_pages fp ON fp.id = f.page_id
  1992.             LEFT JOIN filter_params p ON p.id = f.param_id
  1993.             LEFT JOIN filter_groups g ON g.id = f.group_id
  1994.             LEFT JOIN locale_text gname ON gname.filter_group_name = g.id
  1995.             LEFT JOIN locale_url url ON url.filter_id = f.id
  1996.             WHERE
  1997.                 f.id IN ($fidsStr) AND
  1998.                 p.is_enable = 1
  1999.             ORDER BY f.sort, f.name";
  2001.         $sql = preg_replace('/[\s\n\r]+/', ' ', $sql);
  2003.         $memcache = $this->cacheService->getMemcache();
  2004.         $memcacheKey = md5($sql);
  2005.         $items = $memcache->get($memcacheKey);
  2007.         if ($items) {
  2008.             return $items;
  2009.         }
  2011.         $items = $this->getEntityManager()->getConnection()->fetchAll($sql);
  2013.         $memcache->set($memcacheKey, $items);
  2015.         return $items;
  2016.     }
  2018.     /**
  2019.      * Получение данных для формирования имени фильтра в хистри расширенного поиска
  2020.      * @param array $fids
  2021.      * @return array
  2022.      */
  2023.     public function getForFilterNameHistorySearch(array $fids): array
  2024.     {
  2025.         $lc = App::getCurLocale();
  2026.         $fids = array_unique(array_map('intval', array_filter($fids, 'is_numeric')));
  2027.         if (empty($fids)) {
  2028.             return [];
  2029.         }
  2030.         $fidsStr = implode(',', $fids);
  2032.         $sql = "SELECT
  2033.                 f.id AS `id`,
  2034.                 f.alt_name AS `altName`,
  2035.                 fpg.name_many_$lc AS `name`,
  2036.                 fpr.code AS `code`,
  2037.                 fg.alt_name AS `groupAltName`,
  2038.                 fg.left_menu AS `groupLeftMenu`
  2039.             FROM
  2040.                 filters f
  2041.             LEFT JOIN filter_groups fg ON fg.id = f.group_id
  2042.             LEFT JOIN filter_pages fpg ON fpg.id = f.page_id
  2043.             LEFT JOIN filter_params fpr ON fpr.id = f.param_id
  2044.             WHERE
  2045.                 f.id IN ($fidsStr)";
  2047.         $memcache = $this->cacheService->getMemcache();
  2048.         $memcacheKey = md5($sql);
  2049.         $items = $memcache->get($memcacheKey);
  2051.         if ($items) {
  2052.             return $items;
  2053.         }
  2055.         $items = $this->getEntityManager()->getConnection()->fetchAll($sql);
  2057.         $memcache->set($memcacheKey, $items);
  2059.         return $items;
  2060.     }
  2062.     /**
  2063.      * Список для назначения родителя в админке
  2064.      * @param $gid
  2065.      * @param $fid
  2066.      * @return array
  2067.      * @throws \Doctrine\DBAL\Exception
  2068.      */
  2069.     public function admGetListForParent($gid, $fid): array
  2070.     {
  2071.         $sql = "SELECT
  2072.                 f.id as `id`,
  2073.                    f.name AS `name.ru`,
  2074.                    fp.name_menu_en AS `name.en`
  2075.             FROM
  2076.                 filters f
  2077.             LEFT JOIN filter_pages fp ON fp.id = f.page_id
  2078.             LEFT JOIN filter_params p ON p.id = f.param_id
  2079.             WHERE f.id != $fid AND f.group_id = $gid AND p.is_enable = 1
  2080.             ORDER BY `name.ru`";
  2082.         $items = $this->getEntityManager()->getConnection()->fetchAllAssociative($sql);
  2084.         $rows = [];
  2085.         foreach ($items as $item) {
  2086.             $rows[$item['id']] = "{$item['name.ru']} ({$item['name.en']}) #{$item['id']}";
  2087.         }
  2089.         return $rows;
  2090.     }
  2092.     /**
  2093.      * @param string $leftMenu
  2094.      * @return string|null
  2095.      */
  2096.     public function getKeyByLeftMenu(string $leftMenu): ?string
  2097.     {
  2098.         $lc = App::getCurLocale();
  2099.         $sql = "SELECT
  2100.                    lurl.$lc AS `url`
  2101.             FROM
  2102.                 filters f
  2103.             LEFT JOIN locale_url lurl ON f.id = lurl.filter_id
  2104.             WHERE f.left_menu = '$leftMenu'
  2105.             LIMIT 1";
  2107.         $memcache = $this->cacheService->getMemcache();
  2108.         $memcacheKey = md5($sql);
  2109.         $items = $memcache->get($memcacheKey);
  2111.         if ($items) {
  2112.             return $items;
  2113.         }
  2115.         try {
  2116.             $items = $this->getEntityManager()
  2117.                 ->getConnection()
  2118.                 ->executeQuery($sql)
  2119.                 ->fetchOne() ?: null;
  2121.             $memcache->set($memcacheKey, $items);
  2123.             return $items;
  2124.         } catch (Throwable $e) {
  2125.             return null;
  2126.         }
  2127.     }
  2129.     public function getListForTestCountTranslate()
  2130.     {
  2131.         $q = $this->createQueryBuilder('f')
  2132.             ->select('f, g, p, descr, htmlShow')
  2133.             ->leftJoin('f.groups', 'g')
  2134.             ->leftJoin('f.page', 'p')
  2135.             ->leftJoin('f.htmlShow', 'htmlShow')
  2136.             ->leftJoin('f.nameForMetaDescr', 'descr')
  2137.             ->andWhere('g.id != 406')// фабрики
  2138.             ->andWhere('g.id != 411')// дизайнеры
  2139.             ->getQuery();
  2141.         return $q->getArrayResult();
  2142.     }
  2144.     /**
  2145.      * Получение списка ТОП фильтров, для формирования меню карусели на главной
  2146.      * @return array
  2147.      * @throws Exception
  2148.      * @see src/WebBundle/Resources/views/Home/_top-carousel.html.twig
  2149.      */
  2150.     public function getItemsForTopCollectionCarouselMenu(): array
  2151.     {
  2152.         $lc = App::getCurLocale();
  2153.         $cacheKey = "ItemsForTopCollectionCarouselMenu1.$lc";
  2154.         $redisCachePool = App::getContainer()->get(RedisCachePool::class)->getPool();
  2155.         $cacheItem = $redisCachePool->getItem($cacheKey);
  2157.         if ($cacheItem->isHit()) {
  2158.             return $cacheItem->get();
  2159.         }
  2160.         $translator = App::getTranslator();
  2162.         $sql = "SELECT
  2163.                lurl.$lc AS `url`,
  2164.                lurl.en AS `key`,
  2165.                f.alt_name AS `alt`,
  2166.                f.id AS `id`
  2167.         FROM
  2168.             filters f
  2169.         LEFT JOIN locale_url lurl ON f.id = lurl.filter_id
  2170.         WHERE f.id in (10592,10591)";
  2172.         $rows = $this->getEntityManager()
  2173.             ->getConnection()
  2174.             ->executeQuery($sql)
  2175.             ->fetchAll();
  2177.         $items = [
  2178.             'top-all' => [
  2179.                 'title' => $translator->trans('main_top_all'),
  2180.                 'link' => App::generateUrl('app_catalog'),
  2181.                 'url-json' => App::generateUrl('app_last_collection', ['type' => 'top-all']),
  2182.                 'key' => 'top-all',
  2183.             ],
  2184.         ];
  2186.         if ($rows) {
  2187.             foreach ($rows as $row) {
  2188.                 $items[$row['key']] = [
  2189.                     'title' => $translator->trans("main_{$row['alt']}"),
  2190.                     'link' => App::generateUrl('app_catalog', ['key' => $row['url']]),
  2191.                     'url-json' => App::generateUrl('app_last_collection', ['type' => $row['key']]),
  2192.                     'key' => $row['key'],
  2193.                 ];
  2194.             }
  2196.             $cacheItem->set($items);
  2198.             $redisCachePool->save($cacheItem);
  2199.         }
  2201.         return $items;
  2202.     }
  2204.     /**
  2205.      * Выборка для отдачи списка дизайнеров в меню в каталоге
  2206.      * @param array $onlyIds
  2207.      * @return array
  2208.      * @throws \Doctrine\DBAL\Exception
  2209.      */
  2210.     public function getListDesignersForCataloge(array $onlyIds = []): array
  2211.     {
  2212.         if ($onlyIds) {
  2213.             $onlyIds = implode("','", $onlyIds);
  2214.             $onlyIds = " AND f.id IN ('$onlyIds')";
  2215.         } else {
  2216.             $onlyIds = '';
  2217.         }
  2218.         $sql = "SELECT
  2219.                 f.id,
  2220.                 f.rank AS `rank`,
  2221.                 f.old_command AS `oldCommand`,
  2222.                 f.old_id AS `oldId`,
  2223.                 fp.name_menu_en AS `name`,
  2224.                 p.count AS `cnt`,
  2225.                 url.en AS `slug`
  2226.             FROM
  2227.                 filters f
  2228.             LEFT JOIN filter_pages fp ON fp.id = f.page_id
  2229.             LEFT JOIN filter_params p ON p.id = f.param_id
  2230.             LEFT JOIN locale_url url ON url.filter_id = f.id
  2231.             WHERE p.count > 0 AND p.is_enable = 1 AND f.group_id = 411 $onlyIds
  2232.             ORDER BY f.name";
  2234.         $sql = preg_replace('/[\s\n\r]+/', ' ', $sql);
  2236.         $memcache = $this->cacheService->getMemcache();
  2237.         $memcacheKey = md5($sql);
  2238.         $items = $memcache->get($memcacheKey);
  2240.         if ($items) {
  2241.             return $items;
  2242.         }
  2244.         $items = $this
  2245.             ->getEntityManager()
  2246.             ->getConnection()
  2247.             ->fetchAllAssociative($sql);
  2249.         $memcache->set($memcacheKey, $items);
  2251.         return $items;
  2252.     }
  2254.     /**
  2255.      * @param string $lc
  2256.      * @param TranslatorInterface $translator
  2257.      * @return array
  2258.      */
  2259.     public function getListBrandsForMenu(string $lc, TranslatorInterface $translator): array
  2260.     {
  2261.         $status = BiConst::STATE_PUBLISHED . ', ' . BiConst::STATE_WORK_CONTINUED;
  2262.         $hideFactories = HideFactoryCountriesHelper::length() > 0
  2263.             ? join(', ', HideFactoryCountriesHelper::codes())
  2264.             : 0;
  2266.         $sql = "SELECT
  2267.                 b.id AS `id`,
  2268.                 url.$lc AS `slug`,
  2269.                 fp.name_menu_en AS `name`,
  2270.                 f.name AS `name2`,
  2271.                 f.id AS `filter_id`,
  2272.                 c.old_id AS `country.id`,
  2273.                 c.left_menu AS `country.alias`,
  2274.                 count(iia.idea_id) AS `totalIdeas`,
  2275.                 b.votes_submit AS `votesSubmit`,
  2276.                 b.votes_stars AS `votesStars`
  2277.             FROM
  2278.                 filters f
  2279.             LEFT JOIN filter_pages fp ON fp.id = f.page_id
  2280.             LEFT JOIN filter_params p ON p.id = f.param_id
  2281.             LEFT JOIN locale_url url ON url.filter_id = f.id
  2282.             LEFT JOIN factory b ON b.id = f.brand
  2283.             LEFT JOIN filters c ON c.id = f.country_id
  2284.             LEFT JOIN collection coll on b.id = coll.factory and coll.status = 1
  2285.             LEFT JOIN interior inte on coll.id = inte.collection
  2286.             LEFT JOIN idea_interior iia on inte.id = iia.interior_id
  2287.             WHERE f.brand IS NOT NULL
  2288.               AND f.id != '10639'
  2289.               AND p.is_enable = 1
  2290.               AND p.count >= 0
  2291.               AND b.status IN ($status)
  2292.               AND b.unid  IS NOT NULL
  2293.               AND b.id NOT IN ($hideFactories)
  2294.             group by f.id
  2295.             ORDER BY fp.name_menu_en";
  2297.         $memcache = $this->cacheService->getMemcache();
  2298.         $memcacheKey = md5($sql);
  2299.         $rows = $memcache->get($memcacheKey);
  2301.         if ($rows) {
  2302.             return $rows;
  2303.         }
  2305.         $rows = $this
  2306.             ->getEntityManager()
  2307.             ->getConnection()
  2308.             ->fetchAll($sql);
  2310.         foreach ($rows as $i => $row) {
  2311.             $row['id'] = intval($row['id']);
  2312.             $row['totalIdeas'] = intval($row['totalIdeas']);
  2313.             $row['votesSubmit'] = intval($row['votesSubmit']);
  2314.             $row['votesStars'] = intval($row['votesStars']);
  2316.             $row['country'] = [
  2317.                 'id' => intval($row['country.id']),
  2318.                 'alias' => trim($translator->trans($row['country.alias'])),
  2319.             ];
  2320.             unset($row['country.id']);
  2321.             unset($row['country.alias']);
  2322.             $rows[$i] = $row;
  2323.         }
  2325.         $memcache->set($memcacheKey, $rows);
  2327.         return $rows;
  2328.     }
  2330.     /**
  2331.      * @param int $filterParamId
  2332.      * @param int $count
  2333.      * @return bool
  2334.      * @throws \Doctrine\DBAL\Exception
  2335.      */
  2336.     public function updateCountAndShow(int $filterParamId, int $count)
  2337.     {
  2338.         // исключил из обновы фильтр коммерческая плитка и размеры
  2339.         if (in_array($filterParamId, [10171, 10405, 10406, 10407, 10408])) {
  2340.             return true;
  2341.         }
  2343.         $isEnabled = $count > 0 ? 1 : 0;
  2345.         $sql = "UPDATE `filter_params` SET `count` = '$count', `is_enable` = '$isEnabled' WHERE `id` = '$filterParamId';";
  2347.         $this->getEntityManager()->getConnection()->executeStatement($sql);
  2349.         return true;
  2350.     }
  2352.     /**
  2353.      * Выборка для простановки данных из шаблона переводов
  2354.      * @return FilterEntity[]
  2355.      */
  2356.     public function consoleGetListDesigners(): array
  2357.     {
  2358.         $q = $this->createQueryBuilder('f');
  2359.         $q->select('f, groups, param, page')
  2360.             ->leftJoin('f.groups', 'groups')
  2361.             ->leftJoin('f.param', 'param')
  2362.             ->leftJoin('f.page', 'page')
  2363.             ->andWhere("f.parentKey = 'designer'");
  2365.         return $q->getQuery()->getResult();
  2366.     }
  2368.     /**
  2369.      * @deprecated todo на удаление - не используется
  2370.      */
  2371.     public function getDesigners()
  2372.     {
  2373.         $q = $this->createQueryBuilder('f');
  2374.         $q
  2375.             ->andWhere("f.oldCommand =getDesigner")
  2376.             ->setParameter('getDesigner', 'getDesigner')
  2377.             ->orderBy('f.name');
  2379.         return $q->getQuery()->getArrayResult();
  2380.     }
  2382.     /**
  2383.      * Выборка для слайдера
  2384.      * @param string $lc
  2385.      * @param array $filters
  2386.      * @return array
  2387.      * @throws \Doctrine\DBAL\Exception
  2388.      */
  2389.     public function getArrListForSlider(string $lc, array $filters): array
  2390.     {
  2391.         $where = [];
  2392.         foreach ($filters as $group => $ides) {
  2393.             if ($ides[0] != null) {
  2394.                 if (is_int($ides[0])) {
  2395.                     $where[] = 'g.id = ' . $group . ' AND f.old_id = ' . $ides[0] . ' AND f.old_command = "' . $ides[1] . '"';
  2396.                 } elseif (is_array($ides[0])) {
  2397.                     $where[] = 'g.id = ' . $group . ' AND f.old_id IN (' . join(
  2398.                         ',',
  2399.                         $ides[0]
  2400.                     ) . ') AND f.old_command = "' . $ides[1] . '"';
  2401.                 }
  2402.             }
  2403.         }
  2405.         if (count($where) == 0) {
  2406.             return [];
  2407.         }
  2409.         $sql = "SELECT
  2410.                 f.id,
  2411.                 f.alt_name AS `altName`,
  2412.                 fp.name_menu_$lc AS `name`,
  2413.                    u.$lc AS `url`,
  2414.                 p.count AS `count`,
  2415.                 g.id AS `group.id`,
  2416.                 f.old_command as `oldCommand`,
  2417.                 g.alt_name AS `group.altName`,
  2418.                 gname.$lc AS `group.name`
  2419.             FROM
  2420.                 filters f
  2421.             LEFT JOIN filter_pages fp ON fp.id = f.page_id
  2422.             LEFT JOIN filter_params p ON p.id = f.param_id
  2423.             LEFT JOIN filter_groups g ON g.id = f.group_id
  2424.             LEFT JOIN locale_text gname ON gname.filter_group_name = g.id
  2425.             LEFT JOIN locale_url u ON u.filter_id = f.id
  2426.             LEFT JOIN factory b ON b.id = f.brand
  2427.             WHERE (g.alt_name <> 'brand' AND p.show_menu_advanced = 1 OR g.alt_name = 'brand' AND b.status = 1) AND
  2428.             (p.count > 0 OR g.alt_name = 'brand' OR g.alt_name = 'reviews') AND
  2429.             p.is_enable = 1 AND p.hide != 1 AND p.hide_all != 1 AND f.id != '10639'
  2430.             ";
  2432.         if ($where != null) {
  2433.             $sql .= ' AND (' . join(' OR ', $where) . ')';
  2434.         }
  2436.         $memcache = $this->cacheService->getMemcache();
  2437.         $memcacheKey = md5($sql);
  2438.         $rows = $memcache->get($memcacheKey);
  2440.         if ($rows) {
  2441.             return $rows;
  2442.         }
  2444.         $rows = $this->getEntityManager()->getConnection()->fetchAllAssociative($sql);
  2446.         $memcache->set($memcacheKey, $rows);
  2448.         return $rows;
  2449.     }
  2451.     public function getFiltersForSearchSphinx(array $keys, $lc = null)
  2452.     {
  2453.         $keys = implode("','", $keys);
  2455.         $sql = "SELECT
  2456.                 f.id,
  2457.                 f.old_command AS `oldCommand`,
  2458.                 f.old_id AS `oldId`
  2459.             FROM
  2460.                 filters f
  2461.             LEFT JOIN filter_params p ON p.id = f.param_id
  2462.             LEFT JOIN locale_url url ON url.filter_id = f.id
  2463.             WHERE p.count > 0 AND p.is_enable = 1 AND $lc IN ('$keys')
  2464.             ORDER BY f.name";
  2466.         $sql = preg_replace('/[\s\n\r]+/', ' ', $sql);
  2468.         $memcache = $this->cacheService->getMemcache();
  2469.         $memcacheKey = md5($sql);
  2470.         $items = $memcache->get($memcacheKey);
  2472.         if ($items) {
  2473.             return $items;
  2474.         }
  2476.         try {
  2477.             $items = $this->getEntityManager()->getConnection()->fetchAllAssociative($sql);
  2478.         } catch (\Doctrine\DBAL\Exception $e) {
  2479.             return [];
  2480.         }
  2482.         $res = [];
  2483.         foreach ($items as $item) {
  2484.             if (empty($res[$item['oldCommand']])) {
  2485.                 $res[$item['oldCommand']] = [];
  2486.             }
  2487.             $res[$item['oldCommand']][] = $item['oldId'];
  2488.         }
  2490.         $memcache->set($memcacheKey, $res);
  2492.         return $res;
  2493.     }
  2495.     /**
  2496.      * Получение списка фильтров для формирования ссылок под рекламу в гугле
  2497.      * @return array
  2498.      * @throws \Doctrine\DBAL\Exception
  2499.      */
  2500.     public function getListForGoogleAds()
  2501.     {
  2502.         //  -- группы ------------
  2503.         // Фактура 402
  2504.         // Стиль 400
  2505.         // Мотив рисунка 421
  2506.         // Цвет 395
  2507.         // Применение 394
  2508.         // Форма 413 (кроме прямоугольник 10507, квадрат 10845, неправильная форма 10510, Многоугольник 10509 )
  2509.         // Коэффициент антискольжения 422
  2510.         // Производство 396
  2511.         //  -- фильтры ------------
  2512.         // мозаика на сетке/бумаге 10114
  2513.         // фоновая плитка 10167
  2514.         // имитация мозаики 10677
  2515.         // раковина 10162
  2516.         // Виниловая плитка 10757
  2517.         // Назначение напольное 10170
  2518.         // Назначение настенное 10169
  2519.         // Поверхность 3D 10526
  2520.         // Поверхность состаренная 10613
  2521.         // Крупноформатная плитка 10617
  2522.         // Керамогранит утолщенный 10512
  2523.         // Керамогранит тонкий 10411
  2525.         $urlStrSql = [];
  2526.         $nameSingleStrSql = [];
  2527.         $nameManyStrSql = [];
  2528.         $nameGroupStrSql = [];
  2529.         $keyAdwords = $titleAdwords = $keyAdwCombiFirst = $titleAdwCombiFirst = $keyAdwCombiOther = $titleAdwCombiOther = [];
  2531.         $locales = LocaleHelper::getListAvailable();
  2532.         foreach ($locales as $lc) {
  2533.             $urlStrSql[] = "url.{$lc['code']} AS `url.{$lc['code']}`";
  2534.             $nameSingleStrSql[] = "page.name_single_{$lc['code']} AS `nameSingle.{$lc['code']}`";
  2535.             $nameManyStrSql[] = "page.name_many_{$lc['code']} AS `nameMany.{$lc['code']}`";
  2536.             $nameGroupStrSql[] = "fgname.{$lc['code']} AS `groupName.{$lc['code']}`";
  2538.             $keyAdwords[] = "keyAdw.{$lc['code']} AS `keyAdwords.{$lc['code']}`";
  2539.             $titleAdwords[] = "titleAdw.{$lc['code']} AS `titleAdwords.{$lc['code']}`";
  2540.             $keyAdwCombiFirst[] = "keyAdwCombiFirst.{$lc['code']} AS `keyAdwCombiFirst.{$lc['code']}`";
  2541.             $titleAdwCombiFirst[] = "titleAdwCombiFirst.{$lc['code']} AS `titleAdwCombiFirst.{$lc['code']}`";
  2542.             $keyAdwCombiOther[] = "keyAdwCombiOther.{$lc['code']} AS `keyAdwCombiOther.{$lc['code']}`";
  2543.             $titleAdwCombiOther[] = "titleAdwCombiOther.{$lc['code']} AS `titleAdwCombiOther.{$lc['code']}`";
  2544.         }
  2546.         $urlStrSql = implode(', ', $urlStrSql);
  2547.         $nameSingleStrSql = implode(', ', $nameSingleStrSql);
  2548.         $nameManyStrSql = implode(', ', $nameManyStrSql);
  2549.         $nameGroupStrSql = implode(', ', $nameGroupStrSql);
  2550.         $keyAdwords = implode(', ', $keyAdwords);
  2551.         $titleAdwords = implode(', ', $titleAdwords);
  2552.         $keyAdwCombiFirst = implode(', ', $keyAdwCombiFirst);
  2553.         $titleAdwCombiFirst = implode(', ', $titleAdwCombiFirst);
  2554.         $keyAdwCombiOther = implode(', ', $keyAdwCombiOther);
  2555.         $titleAdwCombiOther = implode(', ', $titleAdwCombiOther);
  2557.         $sql = "SELECT
  2558.                 f.id,
  2559.                 fg.alt_name AS `groupAltName`,
  2560.                 page.name_single_ru AS `name.single.ru`,
  2561.                 page.name_many_ru AS `name.many.ru`,
  2562.                 f.group_id AS `groupId`,
  2563.                 f.old_command AS `oldCommand`,
  2564.                 f.old_id AS `oldId`,
  2565.                 $urlStrSql, $nameSingleStrSql, $nameManyStrSql, $nameGroupStrSql, $keyAdwords, $titleAdwords, $keyAdwCombiFirst, $titleAdwCombiFirst, $keyAdwCombiOther, {$titleAdwCombiOther}
  2566.             FROM
  2567.                 filters f
  2568.             LEFT JOIN filter_params par ON par.id = f.param_id
  2569.             LEFT JOIN filter_pages page ON page.id = f.param_id
  2570.             LEFT JOIN locale_url url ON url.filter_id = f.id
  2571.             LEFT JOIN filter_groups fg ON fg.id = f.group_id
  2572.             LEFT JOIN locale_text fgname ON fg.id = fgname.filter_group_name
  2573.             LEFT JOIN locale_text keyAdw ON f.id = keyAdw.filter_key_adwords
  2574.             LEFT JOIN locale_text titleAdw ON f.id = titleAdw.filter_title_adwords
  2575.             LEFT JOIN locale_text keyAdwCombiFirst ON f.id = keyAdwCombiFirst.filter_key_adwords_combi_first
  2576.             LEFT JOIN locale_text titleAdwCombiFirst ON f.id = titleAdwCombiFirst.filter_title_adwords_combi_first
  2577.             LEFT JOIN locale_text keyAdwCombiOther ON f.id = keyAdwCombiOther.filter_key_adwords_combi_other
  2578.             LEFT JOIN locale_text titleAdwCombiOther ON f.id = titleAdwCombiOther.filter_title_adwords_combi_other
  2579.             WHERE par.is_enable = 1 AND par.count > 3
  2580.                 AND (
  2581.                     f.group_id IN (402,400,421,395,394,413,422,396) OR
  2582.                     f.id IN (10114,10677,10162,10757,10170,10169,10526,10613,10617,10512,10411)
  2583.                     )
  2584.                 AND (f.id NOT IN (10507,10845,10510,10509) )
  2585.             ";
  2587.         $sql = preg_replace('/[\s\n\r]+/', ' ', $sql);
  2588.         $items = $this->getEntityManager()->getConnection()->fetchAllAssociative($sql);
  2590.         $rows = [];
  2591.         foreach ($items as $item) {
  2592.             $fId = $item['id'];
  2594.             $url = [];
  2595.             $nameSingle = [];
  2596.             $nameMany = [];
  2597.             $groupName = [];
  2598.             $keyAdwords = $titleAdwords = $keyAdwCombiFirst = $titleAdwCombiFirst = $keyAdwCombiOther = $titleAdwCombiOther = [];
  2600.             foreach ($locales as $lc) {
  2601.                 $lcCode = $lc['code'];
  2602.                 $url[$lcCode] = $item["url.$lcCode"];
  2603.                 $nameSingle[$lcCode] = $item["nameSingle.$lcCode"];
  2604.                 $nameMany[$lcCode] = $item["nameMany.$lcCode"];
  2605.                 $groupName[$lcCode] = $item["groupName.$lcCode"];
  2608.                 $keyAdwords[$lcCode] = trim($item["keyAdwords.$lcCode"]);
  2609.                 $titleAdwords[$lcCode] = trim($item["titleAdwords.$lcCode"]);
  2611.                 $keyAdwCombiFirst[$lcCode] = trim($item["keyAdwCombiFirst.$lcCode"]);
  2612.                 $titleAdwCombiFirst[$lcCode] = trim($item["titleAdwCombiFirst.$lcCode"]);
  2613.                 $keyAdwCombiOther[$lcCode] = trim($item["keyAdwCombiOther.$lcCode"]);
  2614.                 $titleAdwCombiOther[$lcCode] = trim($item["titleAdwCombiOther.$lcCode"]);
  2615.             }
  2617.             $adwCombiMulti = $this->getAdwordsMulti($fId, $locales);
  2618.             // Если специальных заголовков для первой комбинации нет, используем базовые Adwords
  2619.             if (!array_filter($titleAdwCombiFirst)) {
  2620.                 $titleAdwCombiFirst = $titleAdwords;
  2621.             }
  2623.             $rows[$fId] = [
  2624.                 'id' => $fId,
  2625.                 'groupId' => $item['groupId'],
  2626.                 'groupAltName' => $item['groupAltName'],
  2627.                 'name.single.ru' => $item['name.single.ru'],
  2628.                 'oldCommand' => $item['oldCommand'],
  2629.                 'oldId' => $item['oldId'],
  2630.                 'url' => $url,
  2631.                 'nameSingle' => $nameSingle,
  2632.                 'nameMany' => $nameMany,
  2633.                 'groupName' => $groupName,
  2634.                 'adwords' => [
  2635.                     'keysOne' => $keyAdwords,
  2636.                     'titleOne' => $titleAdwords,
  2637.                     'keysCombiFirst' => $keyAdwCombiFirst,
  2638.                     'titleCombiFirst' => $titleAdwCombiFirst,
  2639.                     'keysCombiOther' => $keyAdwCombiOther,
  2640.                     'titleCombiOther' => $titleAdwCombiOther,
  2641.                     'keysCombiOtherMulti' => $adwCombiMulti['keysCombiOther'],
  2642.                     'titleCombiOtherMulti' => $adwCombiMulti['titleCombiOther'],
  2643.                     'keysOneMulti' => $adwCombiMulti['keysOne'],
  2644.                     'titleOneMulti' => $adwCombiMulti['titleOne'],
  2645.                 ],
  2647.             ];
  2648.         }
  2650.         return $rows;
  2651.     }
  2653.     /**
  2654.      * Возвращает набор ключевых слов и заголовков (CombiOther и обычные Adwords) для фильтра,
  2655.      * поддерживая множественные значения из locale_text.*_multi_id.
  2656.      */
  2657.     private function getAdwordsMulti(int $filterId, array $locales): array
  2658.     {
  2659.         $keys = $titles = $keysAdwords = $titlesAdwords = [];
  2661.         foreach ($locales as $lc) {
  2662.             $keys[$lc['code']] = [];
  2663.             $titles[$lc['code']] = [];
  2664.             $keysAdwords[$lc['code']] = [];
  2665.             $titlesAdwords[$lc['code']] = [];
  2666.         }
  2668.         $conn = $this->getEntityManager()->getConnection();
  2670.         $keysRows = $conn->fetchAllAssociative(
  2671.             'SELECT * FROM locale_text WHERE filter_key_adwords_combi_multi_id = :id ORDER BY id ASC',
  2672.             ['id' => $filterId]
  2673.         );
  2675.         $titlesRows = $conn->fetchAllAssociative(
  2676.             'SELECT * FROM locale_text WHERE filter_title_adwords_combi_multi_id = :id ORDER BY id ASC',
  2677.             ['id' => $filterId]
  2678.         );
  2679.         $keysAdwordsRows = $conn->fetchAllAssociative(
  2680.             'SELECT * FROM locale_text WHERE filter_key_adwords_multi_id = :id ORDER BY id ASC',
  2681.             ['id' => $filterId]
  2682.         );
  2684.         $titlesAdwordsRows = $conn->fetchAllAssociative(
  2685.             'SELECT * FROM locale_text WHERE filter_title_adwords_multi_id = :id ORDER BY id ASC',
  2686.             ['id' => $filterId]
  2687.         );
  2689.         foreach ($keysRows as $row) {
  2690.             foreach ($locales as $lc) {
  2691.                 $lcCode = $lc['code'];
  2692.                 if (!empty($row[$lcCode])) {
  2693.                     $keys[$lcCode][] = trim($row[$lcCode]);
  2694.                 }
  2695.             }
  2696.         }
  2698.         foreach ($titlesRows as $row) {
  2699.             foreach ($locales as $lc) {
  2700.                 $lcCode = $lc['code'];
  2701.                 if (!empty($row[$lcCode])) {
  2702.                     $titles[$lcCode][] = trim($row[$lcCode]);
  2703.                 }
  2704.             }
  2705.         }
  2707.         foreach ($keysAdwordsRows as $row) {
  2708.             foreach ($locales as $lc) {
  2709.                 $lcCode = $lc['code'];
  2710.                 if (!empty($row[$lcCode])) {
  2711.                     $keysAdwords[$lcCode][] = trim($row[$lcCode]);
  2712.                 }
  2713.             }
  2714.         }
  2716.         foreach ($titlesAdwordsRows as $row) {
  2717.             foreach ($locales as $lc) {
  2718.                 $lcCode = $lc['code'];
  2719.                 if (!empty($row[$lcCode])) {
  2720.                     $titlesAdwords[$lcCode][] = trim($row[$lcCode]);
  2721.                 }
  2722.             }
  2723.         }
  2725.         return [
  2726.             'keysCombiOther' => $keys,
  2727.             'titleCombiOther' => $titles,
  2728.             'keysOne' => $keysAdwords,
  2729.             'titleOne' => $titlesAdwords,
  2730.         ];
  2731.     }
  2733.     private function buildSQLSelectForFilterResponseDTO(string $lc): string
  2734.     {
  2735.         $lcs = LocaleHelper::getListAvailable();
  2736.         $lcs = array_column($lcs, 'code');
  2738.         $urlSelect = [];
  2739.         foreach ($lcs as $lc_) {
  2740.             $urlSelect[] = "url.$lc_ AS `slug.$lc_`";
  2741.         }
  2742.         $urlSelect = implode(', ', $urlSelect);
  2744.         return "SELECT
  2745.                 f.id,
  2746.                 f.rank AS `rank`,
  2747.                 f.alt_name AS `altName`,
  2748.                 f.old_command AS `sphinxName`,
  2749.                 f.old_id AS `sphinxId`,
  2750.                 htmlshow.$lc AS `isHtmlShow`,
  2751.                 fp.name_menu_$lc AS `nameMenu`,
  2752.                 fp.name_many_$lc AS `nameMany`,
  2753.                 fp.name_single_$lc AS `nameSingle`,
  2754.                 fp.html_$lc AS `html`,
  2755.                 fp.description_$lc AS `description`,
  2756.                 metadesc.$lc AS `metaDescriptionName`,
  2757.                 par.count AS `count`,
  2758.                 par.code AS `code`,
  2759.                 par.is_enable AS `isEnable`,
  2760.                 gr.id AS `groupId`,
  2761.                 gr.alt_name AS `groupAltName`,
  2762.                 gpname.$lc AS `groupName`,
  2763.                 url.$lc AS `slug`, $urlSelect,
  2764.                 b.id AS `brandId`,
  2765.                 b.status AS `brandStatus`,
  2766.                 b.stated_at AS `brandStatedAt`,
  2767.                 b.type AS `brandType`,
  2768.                 b.name AS `brandName`,
  2769.                 f.logo AS `brandLogo`,
  2770.                 f.logo_url AS `brandLogoUrl`,
  2771.                 b.sound AS `brandSound`,
  2772.                 b.video AS `brandVideo`,
  2773.                 cn.id AS `countryId`,
  2774.                 cnfp.name_single_$lc AS `countryName`,
  2775.                 cnurl.$lc AS `countrySlug`,
  2776.                 cnpar.code AS `countryCode`
  2777.             FROM
  2778.                 filters f
  2779.             LEFT JOIN filter_pages fp ON fp.id = f.page_id
  2780.             LEFT JOIN filter_params par ON par.id = f.param_id
  2781.             LEFT JOIN filter_groups gr ON gr.id = f.group_id
  2782.             LEFT JOIN locale_text gpname ON gpname.filter_group_name = gr.id
  2783.             LEFT JOIN locale_text metadesc ON metadesc.filter_name_for_meta_descr_id = f.id
  2784.             LEFT JOIN locale_url url ON url.filter_id = f.id
  2785.             LEFT JOIN locale_bool htmlshow ON htmlshow.filter_html_show_id = f.id
  2786.             LEFT JOIN factory b ON b.id = f.brand
  2787.             LEFT JOIN filters cn ON cn.id = f.country_id
  2788.             LEFT JOIN filter_pages cnfp ON cnfp.id = cn.page_id
  2789.             LEFT JOIN locale_url cnurl ON cnurl.filter_id = cn.id
  2790.             LEFT JOIN filter_params cnpar ON cnpar.id = cn.param_id
  2791.             ";
  2792.     }
  2794.     /**
  2795.      * $this->buildFilterResponseDTO($item);
  2796.      * @param array $data
  2797.      * @return FilterResponseDTO|null
  2798.      */
  2799.     private function buildFilterResponseDTO(array $data): ?FilterResponseDTO
  2800.     {
  2801.         if (!$data['slug']) {
  2802.             return null;
  2803.         }
  2805.         $lcs = LocaleHelper::getListAvailable();
  2806.         $lcs = array_column($lcs, 'code');
  2808.         $slugs = [];
  2809.         foreach ($lcs as $lc_) {
  2810.             $slugs[$lc_] = $data["slug.$lc_"];
  2811.         }
  2813.         $country = !$data['countryId']
  2814.             ? null
  2815.             : new FilterCountryResponseDTO(
  2816.                 (int)$data['countryId'],
  2817.                 $data['countryName'],
  2818.                 $data['countrySlug'],
  2819.                 $data['countryCode'],
  2820.             );
  2822.         $brand = !$data['brandId']
  2823.             ? null
  2824.             : new BrandResponseDTO(
  2825.                 (int)$data['brandId'],
  2826.                 (int)$data['brandStatus'],
  2827.                 $data['brandName'],
  2828.                 $data['nameSingle'],
  2829.                 $data['slug'],
  2830.                 $data['brandLogo'],
  2831.                 $data['brandLogoUrl'],
  2832.                 (int)$data['brandType'],
  2833.                 $data['brandStatedAt'],
  2834.                 $data['brandSound'],
  2835.                 $data['brandVideo'] ? json_decode($data['brandVideo']) : null,
  2836.                 $data['description'],
  2837.                 $country,
  2838.             );
  2840.         return new FilterResponseDTO(
  2841.             (int)$data['id'],
  2842.             $data['altName'],
  2843.             (int)$data['sphinxId'],
  2844.             $data['sphinxName'],
  2845.             $data['nameMenu'],
  2846.             $data['nameMany'],
  2847.             $data['nameSingle'],
  2848.             (bool)$data['isHtmlShow'],
  2849.             $data['metaDescriptionName'],
  2850.             $data['html'],
  2851.             $data['count'],
  2852.             $data['code'],
  2853.             (bool)$data['isEnable'],
  2854.             (int)$data['groupId'],
  2855.             $data['groupName'],
  2856.             $data['groupAltName'],
  2857.             $data['slug'],
  2858.             $slugs,
  2859.             $data['description'],
  2860.             $brand
  2861.         );
  2862.     }
  2864.     /**
  2865.      * @param string $sql
  2866.      * @param string $locale
  2867.      * @return FilterResponseDTO[]
  2868.      * @throws \Doctrine\DBAL\Driver\Exception
  2869.      * @throws \Doctrine\DBAL\Exception
  2870.      */
  2871.     private function getKeysBySql(string $sql, string $locale): array
  2872.     {
  2873.         $memcache = $this->cacheService->getMemcache();
  2874.         $memcacheKey = md5($sql) . $locale;
  2875.         $rows = $memcache->get($memcacheKey);
  2877.         if ($rows) {
  2878.             return $rows;
  2879.         }
  2881.         $items = $this->getEntityManager()->getConnection()->fetchAllAssociative($sql);
  2883.         $ids = array_column($items, 'id');
  2885.         $rows = $this->getSortedByIds($ids, $locale);
  2887.         $memcache->set($memcacheKey, $rows);
  2889.         return $rows;
  2890.     }
  2892.     /**
  2893.      * Получает фильтры и соответствующие группы по идентификатору группы.
  2894.      *
  2895.      * @param int $groupId Идентификатор группы.
  2896.      * @return array Массив с данными фильтров и групп.
  2897.      */
  2898.     public function getFiltersByGroupId(int $groupId): array
  2899.     {
  2900.         $urlStrSql = [];
  2901.         $keyAdwords = $titleAdwords = $keyAdwCombiFirst = $titleAdwCombiFirst = $keyAdwCombiOther = $titleAdwCombiOther = [];
  2903.         $locales = LocaleHelper::getListAvailable();
  2904.         foreach ($locales as $lc) {
  2905.             $urlStrSql[] = "url.{$lc['code']} AS `url.{$lc['code']}`";
  2906.             $keyAdwords[] = "keyAdw.{$lc['code']} AS `keyAdwords.{$lc['code']}`";
  2907.             $titleAdwords[] = "titleAdw.{$lc['code']} AS `titleAdwords.{$lc['code']}`";
  2908.             $keyAdwCombiFirst[] = "keyAdwCombiFirst.{$lc['code']} AS `keyAdwCombiFirst.{$lc['code']}`";
  2909.             $titleAdwCombiFirst[] = "titleAdwCombiFirst.{$lc['code']} AS `titleAdwCombiFirst.{$lc['code']}`";
  2910.             $keyAdwCombiOther[] = "keyAdwCombiOther.{$lc['code']} AS `keyAdwCombiOther.{$lc['code']}`";
  2911.             $titleAdwCombiOther[] = "titleAdwCombiOther.{$lc['code']} AS `titleAdwCombiOther.{$lc['code']}`";
  2912.         }
  2914.         $urlStrSql = implode(', ', $urlStrSql);
  2915.         $keyAdwords = implode(', ', $keyAdwords);
  2916.         $titleAdwords = implode(', ', $titleAdwords);
  2917.         $keyAdwCombiFirst = implode(', ', $keyAdwCombiFirst);
  2918.         $titleAdwCombiFirst = implode(', ', $titleAdwCombiFirst);
  2919.         $keyAdwCombiOther = implode(', ', $keyAdwCombiOther);
  2920.         $titleAdwCombiOther = implode(', ', $titleAdwCombiOther);
  2922.         $sql = "SELECT
  2923.                 f.id,
  2924.                 f.name AS name,
  2925.                 f.alt_name AS altName,
  2926.                 g.id AS groupId,
  2927.                 p.count AS count,
  2928.                 $urlStrSql,
  2929.                 $keyAdwords,
  2930.                 $titleAdwords,
  2931.                 $keyAdwCombiFirst,
  2932.                 $titleAdwCombiFirst,
  2933.                 $keyAdwCombiOther,
  2934.                 $titleAdwCombiOther
  2935.             FROM
  2936.                 filters f
  2937.             LEFT JOIN filter_groups g ON g.id = f.group_id
  2938.             LEFT JOIN filter_params p ON p.id = f.param_id
  2939.             LEFT JOIN locale_url url ON url.filter_id = f.id
  2940.             LEFT JOIN locale_text keyAdw ON keyAdw.filter_key_adwords = f.id
  2941.             LEFT JOIN locale_text titleAdw ON titleAdw.filter_title_adwords = f.id
  2942.             LEFT JOIN locale_text keyAdwCombiFirst ON keyAdwCombiFirst.filter_key_adwords_combi_first = f.id
  2943.             LEFT JOIN locale_text titleAdwCombiFirst ON titleAdwCombiFirst.filter_title_adwords_combi_first = f.id
  2944.             LEFT JOIN locale_text keyAdwCombiOther ON keyAdwCombiOther.filter_key_adwords_combi_other = f.id
  2945.             LEFT JOIN locale_text titleAdwCombiOther ON titleAdwCombiOther.filter_title_adwords_combi_other = f.id
  2946.             WHERE
  2947.                 g.id = :groupId
  2948.             ORDER BY
  2949.                 p.count DESC
  2950.                ";
  2952.         $items = $this->getEntityManager()->getConnection()->fetchAllAssociative($sql, [
  2953.             'groupId' => $groupId
  2954.         ]);
  2956.         return $items;
  2957.     }
  2959.     /**
  2960.      * Retrieves old command search filters based on the provided IDs.
  2961.      *
  2962.      * @param array $ids List of filter IDs to search for.
  2963.      * @return array List of filters with oldCommand and oldId.
  2964.      */
  2965.     public function getOldCommandSearchFilters(array $ids): array
  2966.     {
  2967.         $qb = $this->getEntityManager()->createQueryBuilder();
  2968.         $qb->select('filters.oldCommand as filter', 'filters.oldId as id')
  2969.             ->from(FilterEntity::class, 'filters')
  2970.             ->where($qb->expr()->in('filters.id', ':ids'))
  2971.             ->setParameter('ids', $ids);
  2973.         return $qb->getQuery()->getResult();
  2974.     }
  2975. }