src/WebBundle/Repository/FilterRepository.php line 506

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.     }
  157.     /**
  158.      * Получение списка фильтров для синхронизации количества
  159.      * @param int $filterParentId
  160.      * @return array
  161.      */
  162.     public function getListForSynchCountFiltersOnlyChildren(int $filterParentId): array
  163.     {
  164.         $q = $this->createQueryBuilder('f')
  165.             ->select(
  166.                 'f.id id, f.name name, f.oldId oldId, f.oldCommand oldCommand, parent.id pid, param.id fpId, param.count fpCount'
  167.             )
  168.             ->leftJoin('f.param', 'param')
  169.             ->leftJoin('f.parent', 'parent')
  170.             ->andWhere('parent.id = :pid')->setParameter('pid', $filterParentId)
  171.             ->andWhere('f.oldCommand != :bm')->setParameter('bm', 'bm') // исключаем из проверок фильтр БМом
  172.         ;
  174.         $q = $q->getQuery();
  176.         return $q->getArrayResult();
  177.     }
  179.     /**setCollections
  180.      * Получение списка фильтров для синхронизации количества
  181.      * WebBundle/Command/SynchronizeCommand::runSynchCountFilters()
  182.      * @param array|null $filterIds
  183.      * @param array|null $fidsExclude
  184.      * @return array|null
  185.      */
  186.     public function getListForSynchCountFilters(?array $filterIds = [], ?array $fidsExclude = []): ?array
  187.     {
  188.         $q = $this->createQueryBuilder('f')
  189.             ->select(
  190.                 'f.id id, f.name name, f.oldId oldId, f.oldCommand oldCommand, parent.id pid, param.id fpId, param.count fpCount'
  191.             )
  192.             ->leftJoin('f.param', 'param')
  193.             ->leftJoin('f.parent', 'parent')
  194.             ->andWhere('f.oldCommand != :bm')->setParameter('bm', 'bm') // исключаем из проверок фильтр БМом
  195.         ;
  198.         if ($filterIds) {
  199.             $q->andWhere('f.id IN (:filterId)')->setParameter('filterId', $filterIds);
  200.         }
  202.         if ($fidsExclude) {
  203.             $q->andWhere('f.id NOT IN (:filterIdExclude)')->setParameter('filterIdExclude', $fidsExclude);
  204.         }
  206.         $q = $q->getQuery();
  208.         return $q->getArrayResult();
  209.     }
  211.     public function getListForOneC(): array
  212.     {
  213.         $q = $this->joinQuery('f');
  214.         $r = $q->getQuery();
  216.         $cacheName = $this->buildCacheName('filter', ['getListForOneC']);
  217.         $r->useQueryCache(true)->enableResultCache((int) TimeConstant::DAY, $cacheName);
  219.         return $r->getArrayResult();
  220.     }
  222.     /**
  223.      * @param array $oldIds
  224.      * @param string $oldCommand
  225.      * @param string $locale
  226.      * @return array|FilterResponseDTO[]
  227.      * @throws \Doctrine\DBAL\Driver\Exception
  228.      * @throws \Doctrine\DBAL\Exception
  229.      */
  230.     public function getByOldCommand(array $oldIds, string $oldCommand, string $locale): array
  231.     {
  232.         $oldIds = array_map('intval', $oldIds);
  233.         $oldIds = array_unique($oldIds);
  234.         $oldIds = array_filter($oldIds);
  236.         if ($oldIds) {
  237.             $fidsStr = implode(',', $oldIds);
  238.             $fidsStr = "f.old_id IN ($fidsStr) AND";
  239.         } else {
  240.             $fidsStr = '';
  241.         }
  242.         $sql = "SELECT f.id AS `id` FROM filters f WHERE $fidsStr f.old_command = '$oldCommand'";
  244.         return $this->getKeysBySql($sql, $locale);
  245.     }
  247.     /**
  248.      * @param string $filterAltName
  249.      * @param string $locale
  250.      * @return FilterResponseDTO[]
  251.      * @throws \Doctrine\DBAL\Driver\Exception
  252.      * @throws \Doctrine\DBAL\Exception
  253.      */
  254.     public function getFilterDTOByAltName(string $filterAltName, string $locale): array
  255.     {
  256.         $sql = "SELECT f.id AS `id` FROM filters f WHERE f.alt_name = '$filterAltName'";
  258.         return $this->getKeysBySql($sql, $locale);
  259.     }
  261.     /**
  262.      * Получаем key для URL для дизайнерского стиля
  263.      * @param null $lc
  264.      * @return mixed|null
  265.      */
  266.     public function getKeyDesignerStyle($lc = null)
  267.     {
  268.         $lc = $lc ?: LocaleHelper::getCurLocale();
  269.         $q = $this->createQueryBuilder('f');
  270.         $q->select("url.$lc")
  271.             ->leftJoin('f.url', 'url')
  272.             ->andWhere("f.altName = :filterAltName")
  273.             ->setParameter('filterAltName', 'designer')
  274.             ->setMaxResults(1);
  276.         $cacheName = $this->buildCacheName('filter_designer_style', [$lc]);
  277.         $r = $q->getQuery()->useQueryCache(true)->enableResultCache(TimeConstant::WEEK, $cacheName);
  279.         try {
  280.             $item = $r->getSingleResult();
  281.             $item = $item[$lc];
  282.         } catch (Exception $e) {
  283.             return null;
  284.         }
  286.         return $item;
  287.     }
  289.     /**
  290.      * @param null $filterAltName
  291.      * @param null $groupAltName
  292.      * @param bool $isLike
  293.      * @return mixed
  294.      */
  295.     public function getByAltName($filterAltName = null, $groupAltName = null, bool $isLike = false)
  296.     {
  297.         $aParams = [];
  298.         $operate = $isLike ? 'LIKE' : '=';
  300.         $q = $this->createQueryBuilder('f');
  302.         $q->select('f, groups, page, url, nameForMetaTitle, nameForMetaDescr')
  303.             ->leftJoin('f.groups', 'groups')
  304.             ->leftJoin('f.page', 'page')
  305.             ->leftJoin('f.url', 'url')
  306.             ->leftJoin('f.nameForMetaTitle', 'nameForMetaTitle')
  307.             ->leftJoin('f.nameForMetaDescr', 'nameForMetaDescr');
  309.         if ($filterAltName) {
  310.             $q->andWhere("f.altName $operate :filterAltName");
  311.             if ($isLike) {
  312.                 $filterAltName = '%' . $filterAltName . '%';
  313.             }
  314.             $aParams['filterAltName'] = $filterAltName;
  315.         }
  317.         if ($groupAltName) {
  318.             $q->andWhere("groups.altName $operate :groupAltName");
  319.             if ($isLike) {
  320.                 $groupAltName = '%' . $groupAltName . '%';
  321.             }
  322.             $aParams['groupAltName'] = $groupAltName;
  323.         }
  325.         $q->setParameters($aParams);
  326.         $r = $q->getQuery();
  328.         $cacheName = $this->buildCacheName('filter_getByAltName', [$filterAltName, $groupAltName]);
  329.         $r->useQueryCache(true)->enableResultCache(TimeConstant::DAY, $cacheName);
  331.         return $r->getResult();
  332.     }
  334.     /**
  335.      * @param int $oldId
  336.      * @return array
  337.      * @throws \Doctrine\DBAL\Exception
  338.      */
  339.     public function getFilterIdsByOldId(int $oldId): array
  340.     {
  341.         $sql = "SELECT f.id
  342.                 FROM filters f
  343.                 WHERE f.old_id = $oldId
  344.                 ";
  346.         $memcache = $this->cacheService->getMemcache();
  347.         $memcacheKey = md5($sql);
  348.         $ids = $memcache->get($memcacheKey);
  350.         if ($ids) {
  351.             return $ids;
  352.         }
  354.         $conn = $this->getEntityManager()->getConnection();
  355.         $ids = $conn->fetchAllAssociative($sql);
  357.         $memcache->set($memcacheKey, $ids);
  359.         return $ids;
  360.     }
  362.     /**
  363.      * Получение одного ID по OldID
  364.      * @param int $oldId
  365.      * @param string $oldCommand
  366.      * @return int|null
  367.      */
  368.     public function getFilterIdByOldId(int $oldId, string $oldCommand): ?int
  369.     {
  370.         $sql = "SELECT f.id FROM filters f WHERE f.old_id = '$oldId' AND f.old_command = '$oldCommand' LIMIT 1";
  372.         $memcache = $this->cacheService->getMemcache();
  373.         $memcacheKey = md5($sql);
  374.         $id = $memcache->get($memcacheKey);
  376.         if ($id) {
  377.             return $id;
  378.         }
  380.         try {
  381.             $conn = $this->getEntityManager()->getConnection();
  382.             $id = $conn->executeQuery($sql)->fetchOne();
  383.         } catch (Throwable $e) {
  384.             return null;
  385.         }
  387.         if ($id) {
  388.             $id = (int) $id;
  389.             $memcache->set($memcacheKey, $id);
  390.         }
  392.         return $id ?: null;
  393.     }
  395.     /**
  396.      * Получение массива ID по массиву OldID
  397.      * @param array $oldIds
  398.      * @param string $oldCommand
  399.      * @return array
  400.      * @throws \Doctrine\DBAL\Exception
  401.      */
  402.     public function getFilterIdsByOldIds(array $oldIds, string $oldCommand): array
  403.     {
  404.         $conn = $this->getEntityManager()->getConnection();
  405.         $isDesigner = $oldCommand == 'getDesigner';
  406.         $oldCommand = $conn->quote($oldCommand);
  408.         $oldIds = array_map('intval', array_filter($oldIds, 'is_numeric'));
  409.         $oldIds = implode("', '", $oldIds);
  410.         $oldIds = "'$oldIds'";
  412.         $sql = "SELECT f.id FROM filters f WHERE f.old_id IN ($oldIds) AND f.old_command = $oldCommand;";
  414.         // для дизайнеров дополнительно ищем по f.id
  415.         if ($isDesigner) {
  416.             $sql = "SELECT f.id FROM filters f WHERE (f.old_id IN ($oldIds) OR f.id IN ($oldIds)) AND f.old_command = $oldCommand;";
  417.         }
  419.         $memcache = $this->cacheService->getMemcache();
  420.         $memcacheKey = md5($sql);
  421.         $ids = $memcache->get($memcacheKey);
  423.         if ($ids) {
  424.             return $ids;
  425.         }
  427.         $ids = $conn->fetchAllAssociative($sql);
  428.         if ($ids) {
  429.             $ids = array_column($ids, 'id');
  430.         } else {
  431.             $ids = [];
  432.         }
  434.         $memcache->set($memcacheKey, $ids);
  436.         return $ids;
  437.     }
  439.     /**
  440.      * Поиск фильтра по url значению
  441.      * @code (
  442.      *     $oRepoFilters->getByKeyUrl('bathroom');
  443.      *     $oRepoFilters->getByKeyUrl('bathroom', 'en');
  444.      * )
  445.      * @param string $filterSlug URL имя фильтра
  446.      * @param string $lc Локаль
  447.      * @param bool $isLike
  448.      * @return FilterResponseDTO|null
  449.      * @throws \Doctrine\DBAL\Driver\Exception
  450.      * @throws \Doctrine\DBAL\Exception
  451.      */
  452.     private function getByUrl(string $filterSlug, string $lc, bool $isLike = false): ?FilterResponseDTO
  453.     {
  454.         $aLocales = LocaleHelper::getListAvailable();
  455.         $aLocales = array_column($aLocales, 'code');
  457.         $andWhere = '';
  458.         if ($isLike) {
  459.             $filterSlug = '%' . $filterSlug . '%';
  460.         }
  461.         foreach ($aLocales as $loc) {
  462.             if ($isLike) {
  463.                 $andWhere .= "url.$loc LIKE :slug OR ";
  464.             } else {
  465.                 $andWhere .= "url.$loc = :slug OR ";
  466.             }
  467.         }
  468.         $andWhere = trim(trim($andWhere), 'OR');
  470.         $sql = $this->buildSQLSelectForFilterResponseDTO($lc);
  471.         $sql = "$sql WHERE $andWhere";
  473.         $sql = preg_replace('/[\s\n\r]+/', ' ', $sql);
  475.         $memcache = $this->cacheService->getMemcache();
  476.         $memcacheKey = $filterSlug . md5($sql);
  477.         $dtoArray = $memcache->get($memcacheKey);
  479.         if ($dtoArray) {
  480.             return $this->buildFilterResponseDTO($dtoArray);
  481.         }
  483.         $conn = $this->getEntityManager()->getConnection();
  484.         $stmt = $conn->prepare($sql);
  485.         $stmt->bindValue("slug", $filterSlug, Types::STRING);
  486.         $item = $stmt->executeQuery()->fetchAllAssociative();
  488.         if (!$item) {
  489.             return null;
  490.         }
  492.         // если значений несколько, значит не корректный запрос по каким-то причинам
  493.         if (count($item) > 1) {
  494.             return null;
  495.         }
  497.         $memcache->set($memcacheKey, $item[0]);
  499.         return $this->buildFilterResponseDTO($item[0]);
  500.     }
  502.     /**
  503.      * @param $altNames
  504.      * @return float|int|mixed|string
  505.      */
  506.     public function getByAltNames($altNames)
  507.     {
  508.         $q = $this->joinQuery('f');
  510.         $altNames = is_string($altNames) ? explode(',', $altNames) : $altNames;
  511.         $q->andWhere('f.altName IN (:altNames)');
  512.         $q->addOrderBy('groups.sort', 'ASC');
  513.         $q->addOrderBy('f.sort', 'ASC');
  514.         $q->setParameter('altNames', $altNames);
  515.         $r = $q->getQuery();
  517.         $cacheName = $this->buildCacheName('filter_getByAltNames', $altNames);
  518.         $r->useQueryCache(true)->enableResultCache((int) TimeConstant::DAY, $cacheName);
  520.         return $r->getResult();
  521.     }
  523.     /**
  524.      * @param array $ids
  525.      * @param string $lc
  526.      * @return array|FilterResponseDTO[]
  527.      * @throws \Doctrine\DBAL\Driver\Exception
  528.      * @throws \Doctrine\DBAL\Exception
  529.      */
  530.     public function getSortedByIds(array $ids, string $lc)
  531.     {
  532.         if (!$ids) {
  533.             return [];
  534.         }
  536.         $conn = $this->getEntityManager()->getConnection();
  537.         $inQuery = implode(',', array_fill(0, count($ids), '?'));
  539.         $sql = $this->buildSQLSelectForFilterResponseDTO($lc);
  540.         $sql = "$sql WHERE f.id IN ($inQuery) ORDER BY gr.sort, f.sort";
  542.         $sql = preg_replace('/[\s\n\r]+/', ' ', $sql);
  544.         $memcache = $this->cacheService->getMemcache();
  545.         $memcacheKey = md5($sql) . implode('.', $ids);
  546.         $rows = $memcache->get($memcacheKey);
  548.         if ($rows) {
  549.             return $rows;
  550.         }
  552.         $stmt = $conn->prepare($sql);
  553.         foreach ($ids as $i => $id) {
  554.             $stmt->bindValue(($i + 1), $id);
  555.         }
  556.         $items = $stmt->executeQuery()->fetchAllAssociative();
  557.         $rows = [];
  558.         foreach ($items as $item) {
  559.             $row = $this->buildFilterResponseDTO($item);
  560.             if ($row) {
  561.                 $rows[] = $row;
  562.             }
  563.         }
  565.         $memcache->set($memcacheKey, $rows);
  567.         return $rows;
  568.     }
  570.     /**
  571.      * Осноной запрос получения фильтров из базы по ID с сортировкой по Filter SORT и FilterGroup SORT
  572.      * @param      $id
  573.      * @param bool $toArray
  574.      * @return array|null
  575.      */
  576.     public function getByIds($id, bool $toArray = false)
  577.     {
  578.         $q = $this->joinQuery('f');
  580.         $ids = is_string($id) ? explode(',', $id) : $id;
  582.         if (count($ids) == 1) {
  583.             $q->andWhere('f.id = :ids');
  584.         } else {
  585.             $q->andWhere('f.id IN (:ids)');
  586.         }
  587.         $q->andWhere('f.id IN (:ids)');
  588.         $q->addOrderBy('groups.sort', 'ASC');
  589.         $q->addOrderBy('f.sort', 'ASC');
  590.         $q->setParameter('ids', $ids);
  591.         $r = $q->getQuery();
  593.         $cacheName = $this->buildCacheName('filter_getByIds', $id);
  594.         $r->useQueryCache(true)->enableResultCache((int) TimeConstant::DAY, $cacheName);
  596.         if ($toArray) {
  597.             $items = $r->getArrayResult();
  598.         } else {
  599.             $items = $r->getResult();
  600.         }
  602.         return $items;
  603.     }
  605.     /**
  606.      * Осноной запрос получения фильтров из базы по ID с сортировкой по Filter SORT и FilterGroup SORT
  607.      * @param $altName
  608.      * @return array|null
  609.      */
  610.     public function getByGroupAlias($altName)
  611.     {
  612.         $q = $this->joinQuery('f');
  614.         $q->andWhere('groups.altName = :altName');
  615.         $q->addOrderBy('groups.sort', 'ASC');
  616.         $q->setParameter('altName', $altName);
  617.         $r = $q->getQuery();
  619.         $cacheName = $this->buildCacheName('filter_getByGroupAlias', $altName);
  620.         $r->useQueryCache(true)->enableResultCache((int) TimeConstant::DAY, $cacheName);
  622.         $items = $r->getResult();
  624.         return (count($items) == 1) ? $items[0] : $items;
  625.     }
  627.     public function getListDesignersByGroupAlias($altName)
  628.     {
  629.         $q = $this->joinQuery('f');
  631.         $q->andWhere('groups.altName = :altName');
  632.         $q->andWhere('param.count > 0');
  633.         $q->addOrderBy('f.name', 'ASC');
  634.         $q->addOrderBy('groups.sort', 'ASC');
  635.         $q->setParameter('altName', $altName);
  636.         $r = $q->getQuery();
  638.         $cacheName = $this->buildCacheName('filter_getListDesignersByGroupAlias', $altName);
  639.         $r->useQueryCache(true)->enableResultCache((int) TimeConstant::DAY, $cacheName);
  641.         return $r->getResult();
  642.     }
  644.     /**
  645.      * Формирование массива ссылок на фильтры в футере
  646.      * @return array
  647.      * @throws Exception
  648.      */
  649.     public function getForFooterByGroupAlias(): array
  650.     {
  651.         $memcache = $this->cacheService->getMemcache();
  652.         $lcFull = App::getCurLocale(true);
  653.         $list = $memcache->get('footer.links.filter.' . App::isDev() . $lcFull);
  655.         if (!$list) {
  656.             $ids = [10040, 10136, 10132, 10111, 10147, 10617, 10646, 10146];
  657.             $idsStr = '10040,10136,10132,10111,10147,10617,10646,10146';
  658.             $locales = LocaleHelper::getListAvailable();
  659.             $router = App::getContainer()->get('router');
  660.             $translator = App::getTranslator();
  662.             $urlStrSql = [];
  663.             foreach ($locales as $item) {
  664.                 $urlStrSql[] = "url.{$item['code']} AS `url.{$item['code']}`";
  665.             }
  666.             $urlStrSql = implode(', ', $urlStrSql);
  668.             $sql = "SELECT
  669.                 f.id,
  670.                 f.left_menu AS leftMenu, $urlStrSql
  671.                 FROM filters f
  672.                 LEFT JOIN `locale_url` `url` ON `url`.filter_id = f.id
  673.                 WHERE f.id IN ($idsStr)
  674.                 ";
  676.             $sql = preg_replace('/[\s\n\r]+/', ' ', $sql);
  677.             $items = $this->getEntityManager()->getConnection()->fetchAllAssociative($sql);
  679.             // в многомерные массивы переводим
  680.             foreach ($items as $i => $item) {
  681.                 foreach ($item as $k => $v) {
  682.                     if (preg_match("~(.*)\.(.*)~ui", $k, $out)) {
  683.                         $k1 = $out[1];
  684.                         $k2 = $out[2];
  685.                         if (empty($item[$k1])) {
  686.                             $item[$k1] = [];
  687.                         }
  688.                         $item[$k1][$k2] = $v;
  690.                         unset($item[$k]);
  691.                     }
  692.                 }
  693.                 $items[$i] = $item;
  694.             }
  696.             $ids = array_flip($ids);
  698.             $lc_ = App::getCurLocale();
  700.             // выставляем порядок и сразу формируем имя и урл
  701.             foreach ($items as $i => $item) {
  702.                 $key = $item['leftMenu'] . '_footer';
  703.                 //$key = $item['leftMenu'];
  704.                 $name = $translator->trans($key, [], null, $lc_);
  707.                 $ids[$item['id']] = [
  708.                     'name' => $name,
  709.                     'url' => urldecode(
  710.                         $router->generate(
  711.                             'app_catalog',
  712.                             [
  713.                                 'key' => $item['url'][$lc_],
  714.                                 '_locale' => $lcFull,
  715.                             ]
  716.                         )
  717.                     ),
  718.                 ];
  719.             }
  720.             $list = $ids;
  721.             $memcache->add('footer.links.filter.' . App::isDev() . $lcFull, $list, false, 3600 * 24 * 30);
  722.         }
  724.         return $list;
  725.     }
  727.     /**
  728.      * Получение фабрики через фильтры.
  729.      * @param array $param
  730.      * @return array|null
  731.      * @throws NonUniqueResultException
  732.      * @throws Exception
  733.      * @see WebBundle/Repository/FactoryRepository::getFactory()
  734.      */
  735.     public function getBrand(array $param = [])
  736.     {
  737.         if (!empty($param['count'])) {
  738.             $q = $this->createQueryBuilder('f')
  739.                 ->select('COUNT(f.id)')
  740.                 ->leftJoin('f.brand', 'brand')
  741.                 ->leftJoin('f.param', 'param');
  742.         } else {
  743.             $q = $this->joinQuery('f');
  744.         }
  746.         $q
  747.             ->andWhere('f.brand IS NOT NULL')
  748.             ->andWhere('f.id != 10639')// 10639 это тестовая фабрика, выкидываем ее
  749.             ->andWhere('brand.status = :status')
  750.             ->andWhere('param.isEnabled = true')
  751.             ->andWhere('param.count >= 0')
  752.             ->andWhere('brand.unid IS NOT NULL')
  753.             ->setParameter('status', BiConst::STATE_PUBLISHED)
  754.             ->orderBy('f.name');
  756.         if (!empty($param['url'])) {
  757.             $q->andWhere('f.url = :url')
  758.                 ->setParameter('url', $param['url']);
  759.         }
  761.         if (!empty($param['name'])) {
  762.             $q->andWhere('f.name = :name')
  763.                 ->setParameter('name', $param['name']);
  764.         }
  766.         if (!empty($param['id'])) {
  767.             $q->andWhere('f.id = :filterId');
  768.             $q->setParameter('filterId', $param['id']);
  769.         }
  771.         if (!App::isRole('ROLE_TEST')) {
  772.             $q->andWhere('brand.testAccess IS NULL');
  773.         }
  775.         $r = $q->getQuery();
  776.         $r->useQueryCache(true)->enableResultCache((int) TimeConstant::HOUR); // час
  778.         if (!empty($param['count'])) {
  779.             $items = $r->getSingleScalarResult();
  780.         } else {
  781.             if (empty($param['asArray'])) {
  782.                 $items = $r->getResult();
  783.             } else {
  784.                 $items = $r->getArrayResult();
  785.             }
  786.         }
  788.         return $items;
  789.     }
  791.     /**
  792.      * Хелпер по получению записей брендов
  793.      * @param array $param
  794.      * @return array|null
  795.      */
  796.     public function getBrands(array $param = [])
  797.     {
  798.         $parameters = [];
  799.         $q = $this->joinQuery('f');
  800.         $q
  801.             ->andWhere("groups.altName = 'brand'")
  802.             //->andWhere('f.brand IS NOT NULL')
  803.             //->addSelect('country')
  804.             //->leftJoin('brand.country', 'country')
  805.         ;
  808.         if (!is_array($param)) {
  809.             $paramId = intval($param);
  810.             if ($paramId) {
  811.                 $param = ['id' => $paramId];
  812.             }
  813.         }
  815.         if (!empty($param['id'])) {
  816.             $q->andWhere('f.id = :brandId');
  817.             $parameters['brandId'] = $param['id'];
  818.         }
  820.         if (isset($param['noBrand'])) {
  821.             $q->andWhere('f.brand IS NULL');
  822.         }
  824.         if (!empty($param['factoryId'])) {
  825.             $q->andWhere('f.brand = :factoryId');
  826.             $parameters['factoryId'] = $param['factoryId'];
  827.         }
  829.         if (!empty($param['name'])) {
  830.             $q->andWhere('f.name = :name');
  831.             $parameters['name'] = $param['name'];
  832.         }
  834.         if (count($parameters) > 0) {
  835.             $q->setParameters($parameters);
  836.         }
  838.         $r = $q->getQuery();
  839.         $r->useQueryCache(true)->enableResultCache((int) TimeConstant::HOUR); // час
  841.         if (empty($param['asArray'])) {
  842.             $items = $r->getResult();
  843.         } else {
  844.             $items = $r->getArrayResult();
  845.         }
  847.         return $items;
  848.     }
  850.     /**
  851.      * Получение списка фильтров для меню фильтрации
  852.      * @return array|null
  853.      */
  854.     public function getArrListForFilterMenu()
  855.     {
  856.         $q = $this->joinQuery('f');
  857.         $q
  858.             ->andWhere('param.isEnabled = 1')
  859.             //->andWhere('param.showMenuAdvanced = 1')
  860.             //->andWhere('param.count > 0')
  861.             //->andWhere("(param.showMenuAdvanced = 1 AND f.oldCommand != 'factory')")
  862.             ->orderBy('f.sort ASC, f.name');
  863.         $r = $q->getQuery();
  864.         $r->useQueryCache(true)->enableResultCache((int) TimeConstant::HOUR); // час
  866.         return $r->getResult();
  867.     }
  869.     /**
  870.      * Выборка для расширенного меню фильтров
  871.      * @param $lc
  872.      * @return array
  873.      * @throws \Doctrine\DBAL\Exception
  874.      */
  875.     public function getArrListForFilterMenuNew($lc): array
  876.     {
  877.         $sql = "SELECT
  878.                 f.id,
  879.                 f.alt_name AS `altName`,
  880.                 f.sort AS `sort`,
  881.                 f.parent_id AS `pid`,
  882.                 f.old_command AS `oldCommand`,
  883.                 fp.name_menu_$lc AS `name`,
  884.                    u.$lc AS `url`,
  885.                 p.count AS `count`,
  886.                 p.hex_code AS `hexCode`,
  887.                 p.show_menu_advanced AS `showMenuAdvanced`,
  888.                 g.id AS `group.id`,
  889.                 g.alt_name AS `group.altName`,
  890.                 gname.$lc AS `group.name`,
  891.                 tooltip.$lc AS `tooltip`,
  892.                 c.id AS `country.id`,
  893.                 c.old_id AS `country.code`,
  894.                    c.alt_name AS `country.altName`,
  895.                 cp.name_menu_$lc AS `country.name`,
  896.                 b.id AS `brand.id`,
  897.                 b.name AS `brand.name`
  898.             FROM
  899.                 filters f
  900.             LEFT JOIN filter_pages fp ON fp.id = f.page_id
  901.             LEFT JOIN filter_params p ON p.id = f.param_id
  902.             LEFT JOIN filter_groups g ON g.id = f.group_id
  903.             LEFT JOIN locale_text gname ON gname.filter_group_name = g.id
  904.             LEFT JOIN locale_text tooltip ON tooltip.filter_tooltip = f.id
  905.             LEFT JOIN filters c ON c.id = f.country_id
  906.             LEFT JOIN filter_pages cp ON cp.id = c.page_id
  907.             LEFT JOIN locale_url u ON u.filter_id = f.id
  908.             LEFT JOIN factory b ON b.id = f.brand
  909.             WHERE (g.alt_name <> 'brand' AND p.show_menu_advanced = 1 OR g.alt_name = 'brand' AND b.status = 1) AND
  910.             (p.count > 0 OR g.alt_name = 'brand' OR g.alt_name = 'reviews') AND
  911.             p.is_enable = 1 AND p.hide != 1 AND p.hide_all != 1 AND f.id != '10639'
  912.             ORDER BY f.sort, f.name";
  914.         $memcache = $this->cacheService->getMemcache();
  915.         $memcacheKey = md5($sql);
  916.         $rows = $memcache->get($memcacheKey);
  918.         if ($rows) {
  919.             return $rows;
  920.         }
  922.         $items = $this->getEntityManager()->getConnection()->fetchAllAssociative($sql);
  924.         $rows = [];
  925.         foreach ($items as $item) {
  926.             $name = $item['name'];
  928.             $group = [
  929.                 'id' => intval($item['group.id']),
  930.                 'name' => $item['group.name'],
  931.                 'altName' => $item['group.altName'],
  932.             ];
  934.             // выносим в отдельную категорию крупный размер плитки
  935.             if ($item['oldCommand'] == 'size_big') {
  936.                 $group = [
  937.                     'id' => 0,
  938.                     'name' => 'Other',
  939.                     'altName' => 'other',
  940.                 ];
  941.             }
  943.             $country = null;
  944.             if (!empty($item['country.id'])) {
  945.                 $country = [
  946.                     'id' => intval($item['country.id']),
  947.                     'code' => intval($item['country.code']),
  948.                     'name' => $item['country.name'],
  949.                     'altName' => $item['country.altName'],
  950.                 ];
  951.             }
  953.             $brand = null;
  954.             if (!empty($item['brand.id'])) {
  955.                 $brand = [
  956.                     'id' => intval($item['brand.id']),
  957.                     'name' => $item['brand.name'],
  958.                 ];
  959.                 // меняем основное имя на имя фабрики, на всякий случай
  960.                 $name = $item['brand.name'];
  961.             }
  963.             // ID родительского фильтра
  964.             $pid = intval($item['pid']);
  965.             $pid = $pid ?: null;
  967.             // исключил все случайно попадающие награды в список фильтров
  968.             if ($group['altName'] == 'rewards') {
  969.                 if ($item['id'] != '10546') {
  970.                     continue;
  971.                 }
  972.             }
  974.             $row = [
  975.                 'id' => intval($item['id']),
  976.                 'pid' => $pid,
  977.                 'name' => $name,
  978.                 'altName' => $item['altName'],
  979.                 'tooltip' => $item['tooltip'],
  980.                 'oldCommand' => $item['oldCommand'],
  981.                 'key' => $item['url'],
  982.                 'hexCode' => $item['hexCode'],
  983.                 'count' => intval($item['count']),
  984.                 'sort' => intval($item['sort']),
  985.                 'showMenuAdvanced' => boolval($item['showMenuAdvanced']),
  986.                 'group' => $group,
  987.                 'brand' => $brand,
  988.                 'country' => $country,
  989.                 'collection' => [],
  990.                 'selected' => [],
  991.                 'sub' => [],
  992.                 'groupList' => [],
  993.             ];
  995.             $rows[$row['id']] = $row;
  996.         }
  998.         $memcache->set($memcacheKey, $rows);
  1000.         return $rows;
  1001.     }
  1003.     /**
  1004.      * Получаем массив всех фильтров для меню
  1005.      * @param null $groups
  1006.      * @param      $lc
  1007.      * @param bool $ignoreEnabled
  1008.      * @return array|null
  1009.      * @throws Exception
  1010.      */
  1011.     public function getArrListForMenu($groups, $lc, bool $ignoreEnabled = false): ?array
  1012.     {
  1013.         $lcUc = ucfirst($lc);
  1015.         $selectByLc = "url.$lc url$lcUc, page.nameMenu$lcUc pageNameMenu$lcUc,";
  1017.         // костыль для фильтра цен, что бы показывать верно для разных стран
  1018.         $lcPrice = LocaleHelper::getLocaleForPriceFilter($lc);
  1019.         if ($lc != $lcPrice) {
  1020.             $lcUcPrice = ucfirst($lcPrice);
  1021.             $selectByLc .= "url.$lcPrice url$lcUcPrice, page.nameMenu$lcUcPrice pageNameMenu$lcUcPrice,";
  1022.         }
  1024.         $q = $this->createQueryBuilder('f')
  1025.             ->select(
  1026.                 "
  1027.             f,
  1028.             f.id,
  1029.             f.oldCommand,
  1030.             f.oldId,
  1031.             f.leftMenu,
  1032.             parent.id pid,
  1033.             f.important,
  1034.             $selectByLc
  1035.             groups.altName groupsAltName,
  1036.             param.count paramCount,
  1037.             country
  1038.             "
  1039.             )
  1040.             ->leftJoin('f.url', 'url')
  1041.             ->leftJoin('f.page', 'page')
  1042.             ->leftJoin('f.param', 'param')
  1043.             ->leftJoin('f.groups', 'groups')
  1044.             ->leftJoin('f.country', 'country')
  1045.             ->leftJoin('f.parent', 'parent');
  1047.         if (!$ignoreEnabled) {
  1048.             $q
  1049.                 ->andWhere('param.isEnabled = 1')
  1050.                 ->andWhere('param.showMenu = 1 OR param.showMenuAdvanced = 1')
  1051.                 ->andWhere('url.' . $lc . '  is not null')
  1052.                 ->andWhere('param.count > 0');
  1053.         }
  1054.         $q->orderBy('f.sort ASC, f.name');
  1056.         if ($groups) {
  1057.             $groups = is_array($groups) ? $groups : [$groups];
  1058.             $q->andWhere('groups.altName IN (:groups)')
  1059.                 ->setParameter('groups', $groups);
  1060.         }
  1061.         $r = $q->getQuery();
  1063.         $cacheName = $this->buildCacheName('filter_getArrListForMenu2_' . $lc . $lcPrice, $groups);
  1064.         $r->useQueryCache(true);
  1066.         if (!App::isDev() or !$ignoreEnabled) {
  1067.             $r->enableResultCache(TimeConstant::DAY, $cacheName);
  1068.         }
  1070.         $res = [];
  1071.         $items = $r->getArrayResult();
  1073.         /** @var FilterEntity $item */
  1074.         foreach ($items as $item) {
  1075.             $f = $item[0];
  1076.             unset($item[0]);
  1077.             $item['country'] = $f['country'];
  1078.             $res[$item['groupsAltName']][] = $item;
  1079.         }
  1081.         return $res;
  1082.     }
  1084.     /**
  1085.      * Получаем массив всех детей по рабителю для фейк тегов
  1086.      * @param null $groups
  1087.      * @param      $lc
  1088.      * @param bool $ignoreEnabled
  1089.      * @return array|null
  1090.      * @throws Exception
  1091.      */
  1092.     public function getArrListSubForMenu($pid, $lc, bool $ignoreEnabled = false): ?array
  1093.     {
  1094.         $lcUc = ucfirst($lc);
  1096.         $selectByLc = "url.$lc url$lcUc, page.nameMenu$lcUc pageNameMenu$lcUc,";
  1098.         // костыль для фильтра цен, что бы показывать верно для разных стран
  1099.         $lcPrice = LocaleHelper::getLocaleForPriceFilter($lc);
  1100.         if ($lc != $lcPrice) {
  1101.             $lcUcPrice = ucfirst($lcPrice);
  1102.             $selectByLc .= "url.$lcPrice url$lcUcPrice, page.nameMenu$lcUcPrice pageNameMenu$lcUcPrice,";
  1103.         }
  1105.         $q = $this->createQueryBuilder('f')
  1106.             ->select(
  1107.                 "
  1108.             $selectByLc
  1109.             f
  1110.             "
  1111.             )
  1112.             ->leftJoin('f.url', 'url')
  1113.             ->leftJoin('f.page', 'page')
  1114.             ->leftJoin('f.param', 'param')
  1115.             ->leftJoin('f.groups', 'groups')
  1116.             ->leftJoin('f.country', 'country')
  1117.             ->leftJoin('f.parent', 'parent');
  1119.         if (!$ignoreEnabled) {
  1120.             $q
  1121.                 ->andWhere('param.isEnabled = 1')
  1122.                 ->andWhere('parent.id = ' . $pid)
  1123.                 ->andWhere('param.showMenu = 1 OR param.showMenuAdvanced = 1')
  1124.                 ->andWhere('url.' . $lc . '  is not null')
  1125.                 ->andWhere('param.count > 0');
  1126.         }
  1127.         $q->orderBy('f.sort ASC, f.name');
  1129.         $r = $q->getQuery();
  1131.         $cacheName = $this->buildCacheName('filter_getArrListSubMenu_' . $lc . $lcPrice, $pid);
  1132.        // $r->useQueryCache(true);
  1134.         if (!App::isDev() or !$ignoreEnabled) {
  1135.             $r->enableResultCache(TimeConstant::DAY, $cacheName);
  1136.         }
  1138.         $res = [];
  1139.         $items = $r->getArrayResult();
  1141.         /** @var FilterEntity $item */
  1142.         foreach ($items as $item) {
  1143.             $f = $item[0];
  1144.             unset($item[0]);
  1145.             $item['url'] = $item["url$lcUc"];
  1146.             $item['pageNameMenu'] = $item["pageNameMenu$lcUc"];
  1148.             $res[] = $item;
  1149.         }
  1151.         return $res;
  1152.     }
  1153.     public function getFilterIdForSettingsCollectionByLeft($leftMenu)
  1154.     {
  1155.         $q = $this->createQueryBuilder('f')
  1156.             ->select('f.id, f.name')
  1157.             ->leftJoin('f.url', 'url')
  1158.             ->leftJoin('f.page', 'page')
  1159.             ->andWhere('f.leftMenu = :leftMenu')
  1160.             ->setParameter('leftMenu', $leftMenu)
  1161.             ->getQuery()
  1162.             ->enableResultCache(TimeConstant::DAY);
  1164.         $id = $q->getArrayResult();
  1166.         return $id ? $id[0] : null;
  1167.     }
  1169.     public function getFilterIdForSettingsColletionByIdDesigner(int $id)
  1170.     {
  1171.         $q = $this->createQueryBuilder('f')
  1172.             ->select('f.id, f.name')
  1173.             ->leftJoin('f.url', 'url')
  1174.             ->leftJoin('f.page', 'page')
  1175.             ->andWhere('f.id = :id')->setParameter('id', $id)
  1176.             ->andWhere('f.oldCommand != :oldCommand')->setParameter('oldCommand', 'factory');
  1178.         $q = $q->getQuery()->enableResultCache(TimeConstant::DAY);
  1180.         $id = $q->getArrayResult();
  1182.         return $id ? $id[0] : null;
  1183.     }
  1185.     /**
  1186.      * Получаем массив данных фильтра для свойств коллекции
  1187.      * URL и имя формируется сразу по локали
  1188.      * @param      $oldId
  1189.      * @param      $oldCommand
  1190.      * @param null $locale
  1191.      * @return mixed|null
  1192.      * @throws Exception
  1193.      */
  1194.     public function findFilterForSettingsColletion($oldId, $oldCommand, $locale = null)
  1195.     {
  1196.         $locale = $locale ?: App::getCurLocale();
  1197.         $localeUc = ucfirst($locale);
  1198.         $key = 'filter_' . $oldId . '_' . $oldCommand . '_' . $locale;
  1199.         $res = App::getMemcache()->get($key);
  1201.         if (!$res) {
  1202.             $q = $this->createQueryBuilder('f');
  1203.             $q->select('f, f.id, f.oldId, f.oldCommand, f.altName, f.rank, url, page');
  1204.             $q
  1205.                 ->leftJoin('f.url', 'url')
  1206.                 ->leftJoin('f.page', 'page');
  1207.             $q
  1208.                 ->andWhere("f.oldId = :old_id")
  1209.                 ->setParameter('old_id', $oldId)
  1210.                 ->andWhere("f.oldCommand = :old_command")
  1211.                 ->setParameter('old_command', $oldCommand);
  1212.             $q->setMaxResults(1);
  1214.             $r = $q->getQuery()->enableResultCache(TimeConstant::DAY);
  1216.             $item = ArrHelper::get($r->getArrayResult(), '0');
  1217.             if (!$item) {
  1218.                 return null;
  1219.             }
  1220.             $item['url'] = ArrHelper::get($item, "0.url.$locale");
  1221.             $item['name'] = ArrHelper::get($item, "0.page.nameMany$localeUc");
  1222.             unset($item[0]);
  1224.             if (!defined('DB_NOT_CASHED')) {
  1225.                 App::getMemcache()->set($key, $item, false, (int) TimeConstant::WEEK); // неделя
  1226.             }
  1228.             $res = $item;
  1229.         }
  1231.         return $res;
  1232.     }
  1234.     /**
  1235.      * Получаем список активных фильтров для просчета ранга
  1236.      * @return array|null
  1237.      */
  1238.     public function getForCalcRank()
  1239.     {
  1240.         $q = $this->createQueryBuilder('f');
  1241.         $q->select('f.id, f.name, f.rank, param.count, groups.id gid')
  1242.             ->leftJoin('f.groups', 'groups')
  1243.             ->leftJoin('f.param', 'param')
  1244.             ->andWhere("groups.id != 406")// исключаем бренды
  1245.             //->andWhere("groups.id != 411")// исключаем дизайнеров
  1246.             ->andWhere("groups.id != 408")// исключаем Размер
  1247.             ->andWhere("groups.id != 412")// исключаем top
  1248.             ->andWhere("groups.id != 415")// исключаем page
  1249.             ->andWhere("groups.id != 416")// исключаем БМ
  1250.             ->andWhere("groups.id != 407")// исключаем Сортировка
  1251.             ->andWhere("groups.id != 399")// исключаем распродажа
  1252.             ->andWhere("param.isEnabled = 1")//->andWhere("param.showMenu = 1")
  1253.         ;
  1255.         $result = $q->getQuery()->enableResultCache(TimeConstant::DAY);
  1257.         $res = [];
  1258.         foreach ($result->getArrayResult() as $i => $item) {
  1259.             $res[$item['id']] = $item;
  1260.         }
  1262.         return $res;
  1263.     }
  1266.     /**
  1267.      * @param string $key
  1268.      * @return FilterEntity|null
  1269.      */
  1270.     public function admGetExhibitionByKeyForConsole(string $key)
  1271.     {
  1272.         $q = $this->createQueryBuilder('f');
  1273.         $q->select('f, groups, param, page')
  1274.             ->leftJoin('f.groups', 'groups')
  1275.             ->leftJoin('f.param', 'param')
  1276.             ->leftJoin('f.page', 'page')
  1277.             ->andWhere("f.name LIKE '$key%'")
  1278.             ->andWhere('param.isEnabled = 1')
  1279.             ->andWhere('groups.id = 420 OR groups.id = 417')
  1280.             ->orderBy('f.id', 'DESC')
  1281.             ->setMaxResults(1);
  1283.         try {
  1284.             return $q->getQuery()->getSingleResult();
  1285.         } catch (NoResultException | NonUniqueResultException $e) {
  1286.             return null;
  1287.         }
  1288.     }
  1290.     /**
  1291.      * Получаем последний ID для сфинкса из группы
  1292.      * @param int $groupId
  1293.      * @return int
  1294.      * @throws Throwable
  1295.      */
  1296.     public function admGetExhibitionLastOldIdForConsole(int $groupId): int
  1297.     {
  1298.         $sql = "SELECT  f.old_id AS `oldId`
  1299.                 FROM filters f
  1300.                 WHERE f.group_id = $groupId
  1301.                 ORDER BY f.old_id DESC LIMIT 1";
  1303.         $oldId = $this->getEntityManager()
  1304.             ->getConnection()
  1305.             ->executeQuery($sql)
  1306.             ->fetchOne();
  1308.         return intval($oldId);
  1309.     }
  1312.     /**
  1313.      * Получение последнего дизайнера, для использования в качестве шаблона для создания нового
  1314.      * @return FilterEntity|null
  1315.      */
  1316.     public function admLastDesigner(): ?FilterEntity
  1317.     {
  1318.         $q = $this->createQueryBuilder('f');
  1319.         $q->select('f, groups, param, page')
  1320.             ->leftJoin('f.groups', 'groups')
  1321.             ->leftJoin('f.param', 'param')
  1322.             ->leftJoin('f.page', 'page')
  1323.             ->andWhere("f.parentKey = 'designer'")
  1324.             ->andWhere('param.isEnabled = 1')
  1325.             ->orderBy('f.id', 'DESC')
  1326.             ->setMaxResults(1);
  1328.         try {
  1329.             return $q->getQuery()->getSingleResult();
  1330.         } catch (NoResultException | NonUniqueResultException $e) {
  1331.             return null;
  1332.         }
  1333.     }
  1335.     /**
  1336.      * Поиск последней заполненной переводами записи награды.
  1337.      */
  1338.     public function getLastRewards(): ?FilterEntity
  1339.     {
  1340.         $q = $this->createQueryBuilder('f');
  1342.         $q->select('f, groups, param, page')
  1343.             ->innerJoin('f.groups', 'groups')
  1344.             ->leftJoin('f.param', 'param')
  1345.             ->innerJoin('f.page', 'page')
  1346.             ->where('groups.id = :groupId')
  1347.             ->andWhere('param.isEnabled = 1')
  1348.             ->andWhere('page.nameSingleEn IS NOT NULL AND page.nameSingleEn != :empty')
  1349.             ->andWhere('page.descriptionEn IS NOT NULL AND page.descriptionEn != :empty')
  1350.             ->orderBy('f.id', 'DESC')
  1351.             ->setMaxResults(1)
  1352.             ->setParameters([
  1353.                 'groupId' => FilterGroupEnum::REWARD,
  1354.                 'empty' => ''
  1355.             ]);
  1357.         $query = $q->getQuery();
  1359.         $query->useQueryCache(true);
  1360.         $query->setQueryCacheLifetime(self::QUERY_CACHE_LIFETIME);
  1362.         try {
  1363.             return $query->getSingleResult();
  1364.         } catch (NoResultException | NonUniqueResultException $e) {
  1365.             return null;
  1366.         }
  1367.     }
  1369.     /**
  1370.      * Получение списка наград для выпадающего списка
  1371.      * @return array
  1372.      */
  1373.     public function admGetAwardsForSelectMenu(): array
  1374.     {
  1375.         $q = $this->createQueryBuilder('f');
  1376.         $q->select('f.id, f.name')
  1377.             ->leftJoin('f.groups', 'groups')
  1378.             ->andWhere("groups.altName = 'rewards'")
  1379.             ->andWhere("f.oldId != 1") // исключаем фильтр общий Премированные
  1380.         ;
  1382.         $res = [];
  1383.         $out = $q->getQuery()->getArrayResult();
  1384.         foreach ($out as $i => $item) {
  1385.             $res[(string) $item['id']] = $item['name'];
  1386.         }
  1388.         return $res;
  1389.     }
  1391.     /**
  1392.      * Список выставок для БИ и админки
  1393.      * @return array
  1394.      */
  1395.     public function admGetExhibitionForSelectMenu(): array
  1396.     {
  1397.         $q = $this->createQueryBuilder('f');
  1398.         $q->select('f.oldId id, f.name')
  1399.             ->leftJoin('f.groups', 'groups')
  1400.             ->andWhere("groups.altName = 'exhibition'");
  1402.         $res = [];
  1403.         $out = $q->getQuery()->getArrayResult();
  1404.         foreach ($out as $i => $item) {
  1405.             $res[(string) $item['id']] = $item['name'];
  1406.         }
  1408.         return $res;
  1409.     }
  1411.     /**
  1412.      * @param $exhibition
  1413.      * @return array
  1414.      */
  1415.     public function admGetExhibitionForBI($exhibition): array
  1416.     {
  1417.         $q = $this->createQueryBuilder('f');
  1418.         $q->select('f.id, f.name, f.iconUrl')
  1419.             ->leftJoin('f.groups', 'groups')
  1420.             ->leftJoin('f.param', 'param')
  1421.             ->andWhere("groups.altName = 'exhibition'")
  1422.             ->andWhere("f.oldId in (:exhibition)")
  1423.             ->setParameter('exhibition', $exhibition);
  1425.         $res = [];
  1426.         $out = $q->getQuery()->getArrayResult();
  1427.         foreach ($out as $i => $item) {
  1428.             $link = $item['iconUrl'];
  1429.             $res[(string) $item['id']] = (!empty($link)) ? $item['name'] . '(<a href="' . $link . '" target="_blank" rel="noopener noreferrer">' . $link . '</a>)' : $item['name'];
  1430.         }
  1432.         return $res;
  1433.     }
  1435.     public function admGetAwardsForBi($awards): array
  1436.     {
  1437.         $q = $this->createQueryBuilder('f');
  1438.         $q->select('f.id, f.name, f.iconUrl')
  1439.             ->leftJoin('f.groups', 'groups')
  1440.             ->andWhere("groups.altName = 'rewards'")
  1441.             ->andWhere("f.oldId != 1") // исключаем фильтр общий Премированные
  1442.             ->andWhere("f.id in (:awards)")
  1443.             ->setParameter('awards', $awards);
  1444.         $res = [];
  1445.         $out = $q->getQuery()->getArrayResult();
  1446.         foreach ($out as $i => $item) {
  1447.             $link = $item['iconUrl'];
  1448.             $res[(string) $item['id']] = (!empty($link)) ? $item['name'] . '(<a href="' . $link . '" target="_blank" rel="noopener noreferrer">' . $link . '</a>)' : $item['name'];
  1449.         }
  1451.         return $res;
  1452.     }
  1454.     public function admGetForJsTree(): array
  1455.     {
  1456.         $q = $this->createQueryBuilder('f');
  1457.         $q->select('f.id, f.name, groups.id gr_id, groups.altName gr_name')
  1458.             ->leftJoin('f.groups', 'groups')
  1459.             ->leftJoin('f.param', 'param')
  1460.             ->andWhere("groups.id != 411")// исключаем дизайнеров
  1461.             ->andWhere("groups.id != 408")// исключаем Размер
  1462.             //->andWhere("groups.id != 412")// исключаем top
  1463.             ->andWhere("groups.id != 415")// исключаем page
  1464.             ->andWhere("groups.id != 416")// исключаем БМ
  1465.             ->andWhere("groups.id != 407")// исключаем Сортировка
  1466.             ->andWhere("groups.id != 399")// исключаем распродажа
  1467.             ->andWhere("param.isEnabled = true")
  1468.             ->andWhere("param.showMenuAdvanced = true")
  1469.             ->orderBy('gr_name', 'ASC')
  1470.             ->addOrderBy('f.name', 'ASC')
  1471.             ->andWhere("groups.id != 406") // исключаем бренды
  1472.             //->andWhere("groups.id = 397") // временно, что бы был один
  1473.         ;
  1475.         $items = $q->getQuery()->getArrayResult();
  1477.         $res = [];
  1478.         foreach ($items as $item) {
  1479.             $res[$item['gr_id']][] = $item;
  1480.         }
  1482.         return $res;
  1483.     }
  1485.     public function getSortListCataloge($locale = null)
  1486.     {
  1487.         $locale = $locale ?: App::getCurLocale();
  1488.         $localeUc = ucfirst($locale);
  1490.         $q = $this->createQueryBuilder('f')
  1491.             ->select("f.oldId as id, page.nameSingle$localeUc as nameSingle, page.nameMenu$localeUc as nameMenu")
  1492.             ->leftJoin('f.page', 'page')
  1493.             ->leftJoin('f.groups', 'gr')
  1494.             ->andWhere('gr.id = 407')
  1495.             ->orderBy('f.sort', 'ASC');
  1497.         $r = $q->getQuery()
  1498.             ->useQueryCache(true);
  1500.         $items = $r->getArrayResult();
  1501.         $res = [];
  1503.         foreach ($items as $item) {
  1504.             $res[$item['id']] = $item;
  1505.         }
  1507.         return $res;
  1508.     }
  1510.     public function getAwards(array $id)
  1511.     {
  1512.         $localeUc = ucfirst(App::getCurLocale());
  1514.         if (count($id) == 0) {
  1515.             return [];
  1516.         }
  1518.         if (is_array($id)) {
  1519.             $id = implode(', ', $id);
  1520.             $id = "($id)";
  1521.         }
  1523.         $q = $this->createQueryBuilder('f')
  1524.             ->select("f.id, f.icon, f.iconUrl, page.nameSingle$localeUc")
  1525.             ->leftJoin('f.page', 'page')
  1526.             //            ->andWhere('f.icon IS NOT NULL') решили выводить данные https://te.remote.team/#/discus/649252D6-AAD4-D219-FD67-BBF3CDCA1062/
  1527.             ->andWhere("f.id IN $id");
  1529.         $r = $q->getQuery()->useQueryCache(true);
  1531.         $items = $r->getArrayResult();
  1533.         $res = [];
  1534.         foreach ($items as $item) {
  1535.             $res[$item['id']] = [
  1536.                 'id' => $item['id'],
  1537.                 'icon' => PathHelper::pathGenerate('filter', $item),
  1538.                 'title' => $item["nameSingle$localeUc"],
  1539.                 'url' => $item['iconUrl'],
  1540.             ];
  1541.         }
  1543.         return $res;
  1544.     }
  1546.     /**
  1547.      * Получаем выставки по oldId
  1548.      * @param array $id
  1549.      * @return array
  1550.      * @throws Exception
  1551.      */
  1552.     public function getExhibitions(array $id): array
  1553.     {
  1554.         $lcVo = new LocaleVo();
  1555.         $lc = $lcVo->getCode();
  1556.         $lcUc = ucfirst($lc);
  1557.         $lcFull = $lcVo->getCodeFull();
  1559.         $id = array_filter($id);
  1560.         if (count($id) == 0) {
  1561.             return [];
  1562.         }
  1564.         $id = implode(', ', $id);
  1565.         $id = "($id)";
  1567.         $q = $this->createQueryBuilder('f')
  1568.             ->select(
  1569.                 "f.id, f.oldId, f.iconUrl, tooltip.$lc as tooltipLc , page.nameMenu$lcUc, url.$lc as urlLocal"
  1570.             )
  1571.             ->leftJoin('f.page', 'page')
  1572.             ->leftJoin('f.url', 'url')
  1573.             ->leftJoin('f.param', 'param')
  1574.             ->leftJoin('f.tooltip', 'tooltip')
  1575.             ->andWhere('param.isEnabled = 1')
  1576.             ->andWhere('param.count > 0')
  1577.             ->andWhere("f.oldCommand = 'exhibition'")
  1578.             ->andWhere("f.oldId IN $id");
  1580.         $r = $q->getQuery()->enableResultCache(TimeConstant::DAY);
  1582.         $router = App::getRouter();
  1583.         $items = $r->getArrayResult();
  1584.         $res = [];
  1585.         foreach ($items as $item) {
  1586.             $name = $item["nameMenu$lcUc"];
  1588.             // показываем бирки только с возрастом не более 2-х лет
  1589.             $year = intval(preg_replace('/\D/', '', $name));
  1590.             $yearLimit = intval(date("Y")) - 2;
  1591.             if ($year <= $yearLimit) {
  1592.                 continue;
  1593.             }
  1595.             $res[$item['id']] = [
  1596.                 'id' => $item['id'],
  1597.                 'sphinxId' => $item['oldId'],
  1598.                 'name' => $name,
  1599.                 'tooltip' => $item['tooltipLc'],
  1600.                 'urlRemote' => $item['iconUrl'],
  1601.                 'urlLocal' => $router->generate('app_catalog', ['key' => $item['urlLocal'], '_locale' => $lcFull]),
  1602.             ];
  1603.         }
  1605.         return $res;
  1606.     }
  1608.     /**
  1609.      * Получаем список url фильтров по языку для sitemap
  1610.      * @param $lang
  1611.      * @return array|null
  1612.      */
  1613.     public function getListUrlFiltersByLang($lang): ?array
  1614.     {
  1615.         $q = $this->createQueryBuilder('f')
  1616.             ->select("u.$lang url, f.leftMenu")
  1617.             ->leftJoin('f.url', 'u')
  1618.             ->leftJoin('f.groups', 'g')
  1619.             ->leftJoin('f.param', 'p')
  1620.             ->andWhere('p.hide = 0')
  1621.             ->andWhere('p.count > 0')
  1622.             ->andWhere('g.id NOT IN (:groups)')
  1623.             ->setParameter('groups', [407, 416, 417])
  1624.             ->getQuery();
  1626.         $cacheName = $this->buildCacheName('filter_getListUrlFiltersByLang', $lang);
  1627.         $q->useQueryCache(true)->enableResultCache((int) TimeConstant::DAY, $cacheName);
  1629.         return $q->getArrayResult();
  1630.     }
  1632.     /**
  1633.      * Получение списка для проверки на наличие кириллических символов
  1634.      * @return array
  1635.      */
  1636.     public function getCollectionsAdmForCheckCyrillic(): array
  1637.     {
  1638.         $q = $this->createQueryBuilder('f')
  1639.             ->select('f, page')
  1640.             ->leftJoin('f.page', 'page')
  1641.             ->leftJoin('f.param', 'param')
  1642.             ->andWhere("param.isEnabled = true");
  1644.         return $q->getQuery()->getArrayResult();
  1645.     }
  1647.     /**
  1648.      * Получение ID фильтра по ID бренда
  1649.      * @param $idBrand
  1650.      * @return mixed|null
  1651.      * @throws NonUniqueResultException
  1652.      */
  1653.     public function getIdFilterByIdBrand($idBrand)
  1654.     {
  1655.         $q = $this
  1656.             ->createQueryBuilder('f')
  1657.             ->select('f.id')
  1658.             ->leftJoin('f.brand', 'brand')
  1659.             ->andWhere('brand.id = :idBrand')
  1660.             ->setParameter('idBrand', $idBrand)
  1661.             ->setMaxResults(1)
  1662.             ->getQuery();
  1664.         try {
  1665.             $id = $q->getSingleResult();
  1666.             $id = $id['id'];
  1667.         } catch (NoResultException $e) {
  1668.             return null;
  1669.         }
  1671.         return $id;
  1672.     }
  1675.     /**
  1676.      * Проставляем связи фильтра с коллекциями
  1677.      * @param int $fID
  1678.      * @param     $cIDs
  1679.      * @return bool
  1680.      * @throws Throwable
  1681.      */
  1682.     public function setCollections(int $fID, $cIDs)
  1683.     {
  1684.         if (!$cIDs) {
  1685.             return false;
  1686.         }
  1688.         $conn = $this->getEntityManager()->getConnection();
  1689.         $cIDs = is_array($cIDs) ? $cIDs : [$cIDs];
  1691.         // находим коллекции, которых нет больше и удаляем их
  1692.         $cIDstr = implode(',', $cIDs);
  1693.         $conn->executeStatement(
  1694.             "DELETE FROM `collection_filters` WHERE `collection_id` NOT IN ($cIDstr) AND `filter_id` = '$fID';"
  1695.         );
  1698.         // проставляем связи для всех остальных записей
  1699.         // делаем порциями по почке запросов за раз
  1700.         $maxPortion = 100;
  1701.         $sqlUpdate = '';
  1702.         $cnt = 0;
  1703.         foreach ($cIDs as $cID) {
  1704.             $sqlUpdate .= "INSERT INTO `collection_filters` (`collection_id`,`filter_id`)  VALUES  ('$cID', '$fID') ON DUPLICATE KEY UPDATE collection_id='$cID', filter_id='$fID';";
  1706.             $cnt++;
  1708.             if ($cnt == $maxPortion) {
  1709.                 $sth = $conn->prepare($sqlUpdate);
  1710.                 $sth->execute();
  1711.                 $sth->closeCursor();
  1713.                 $cnt = 0;
  1714.                 $sqlUpdate = '';
  1715.             }
  1716.         }
  1718.         if ($sqlUpdate != '') {
  1719.             $sth = $conn->prepare($sqlUpdate);
  1720.             $sth->execute();
  1721.             $sth->closeCursor();
  1722.         }
  1724.         return true;
  1725.     }
  1727.     /**
  1728.      * Получение фильтра для DTO выставки
  1729.      * @param $fids
  1730.      * @param $lc
  1731.      * @return array
  1732.      * @throws \Doctrine\DBAL\Exception
  1733.      */
  1734.     public function getForExhDTO($fids, $lc)
  1735.     {
  1736.         if (!$fids) {
  1737.             return [];
  1738.         }
  1739.         $fidsStr = implode(',', $fids);
  1741.         $sql = "SELECT
  1742.                 f.id,
  1743.                 f.alt_name AS `altName`,
  1744.                 f.old_command AS `nameSphinx`,
  1745.                 fp.name_menu_$lc AS `name`,
  1746.                 fp.name_many_$lc AS `nameMany`,
  1747.                 fp.name_single_$lc AS `nameFull`,
  1748.                 p.count AS `count`,
  1749.                 p.hex_code AS `hexCode`,
  1750.                 p.show_menu_advanced AS `showMenuAdvanced`,
  1751.                 p.show_menu AS `showMenu`,
  1752.                 g.alt_name AS `groupAltName`,
  1753.                 gname.$lc AS `groupName`,
  1754.                 c.id AS `countryId`,
  1755.                 c.old_id AS `countryOldId`,
  1756.                 cfp.name_menu_$lc AS `countryName`,
  1757.                 u.$lc AS `slug`
  1758.             FROM
  1759.                 filters f
  1760.             LEFT JOIN filter_pages fp ON fp.id = f.page_id
  1761.             LEFT JOIN filter_params p ON p.id = f.param_id
  1762.             LEFT JOIN filter_groups g ON g.id = f.group_id
  1763.             LEFT JOIN locale_text gname ON gname.filter_group_name = g.id
  1764.             LEFT JOIN filters c ON c.id = f.country_id
  1765.             LEFT JOIN filter_pages cfp ON cfp.id = c.page_id
  1766.             LEFT JOIN locale_url u ON u.filter_id = f.id
  1767.             WHERE f.id IN ($fidsStr) AND
  1768.             p.count > 0 AND
  1769.             g.alt_name != 'top' AND
  1770.             g.alt_name != 'release_year_collection' AND
  1771.             g.alt_name != 'price' AND
  1772.             g.alt_name != 'brand' AND
  1773.             f.alt_name != 'cataloge' AND
  1774.             g.alt_name != 'using' AND
  1775.             p.is_enable = 1
  1776.             ORDER BY f.sort, f.name";
  1778.         $memcache = $this->cacheService->getMemcache();
  1779.         $memcacheKey = md5($sql);
  1780.         $items = $memcache->get($memcacheKey);
  1782.         if ($items) {
  1783.             return $items;
  1784.         }
  1786.         $items = $this->getEntityManager()->getConnection()->fetchAllAssociative($sql);
  1788.         $memcache->set($memcacheKey, $items);
  1790.         return $items;
  1791.     }
  1793.     /**
  1794.      * Получение имени для графика статистик в админке
  1795.      * @param array $fids
  1796.      * @param bool $isBrand
  1797.      * @return array
  1798.      */
  1799.     public function getNamesForStatChartAdmin(array $fids, bool $isBrand = false)
  1800.     {
  1801.         $fidsStr = implode(',', $fids);
  1803.         if ($isBrand) {
  1804.             $where = "WHERE f.brand IN ($fidsStr)";
  1805.         } else {
  1806.             $where = "WHERE f.id IN ($fidsStr)";
  1807.         }
  1809.         $sql = "SELECT
  1810.                 f.id,
  1811.                 f.brand,
  1812.                 fp.name_menu_ru AS `name`
  1813.             FROM
  1814.                 filters f
  1815.             LEFT JOIN filter_pages fp ON fp.id = f.page_id
  1816.             $where
  1817.             ORDER BY fp.name_menu_ru ASC";
  1819.         $sql = preg_replace('/[\s\n\r]+/', ' ', $sql);
  1820.         $items = $this->getEntityManager()->getConnection()->fetchAll($sql);
  1822.         $r = [];
  1824.         foreach ($items as $item) {
  1825.             $id = $isBrand ? $item['brand'] : $item['id'];
  1826.             $r[$id] = [
  1827.                 'name' => $item['name'],
  1828.                 'data' => [],
  1829.             ];
  1830.         }
  1832.         return $r;
  1833.     }
  1835.     /**
  1836.      * @return array
  1837.      */
  1838.     public function admGetDesigners()
  1839.     {
  1840.         $q = $this->createQueryBuilder('f');
  1841.         $q->select('f.id, f.name')
  1842.             ->leftJoin('f.groups', 'groups')
  1843.             ->andWhere("groups.altName = 'designer'")
  1844.             ->andWhere("f.oldId != 1")
  1845.             ->orderBy('f.name');
  1847.         $res = [];
  1848.         $out = $q->getQuery()->getArrayResult();
  1849.         foreach ($out as $i => $item) {
  1850.             $res[$item['name']] = StrHelper::toLower($item['name']);
  1851.         }
  1853.         return $res;
  1854.     }
  1856.     public function admGetDesignersId()
  1857.     {
  1858.         $q = $this->createQueryBuilder('f');
  1859.         $q->select('f.id, f.name')
  1860.             ->leftJoin('f.groups', 'groups')
  1861.             ->andWhere("groups.altName = 'designer'")
  1862.             ->andWhere("f.oldId != 1")
  1863.             ->orderBy('f.name');
  1865.         return $q->getQuery()->getArrayResult();
  1866.     }
  1868.     /**
  1869.      * Выборка фильтров для формирования свойств коллекции
  1870.      * @param $fids
  1871.      * @param null $lc
  1872.      * @return array
  1873.      */
  1874.     public function getForCollSettings($fids, $lc = null): array
  1875.     {
  1876.         $lc = $lc ?: App::getCurLocale();
  1877.         $fidsStr = implode(',', $fids);
  1879.         $sql = "SELECT
  1880.                 f.id,
  1881.                 f.rank AS `rank`,
  1882.                 f.alt_name AS `altName`,
  1883.                 f.old_command AS `sphinxName`,
  1884.                 f.old_id AS `sphinxId`,
  1885.                 fp.name_menu_$lc AS `name`,
  1886.                 fp.name_many_$lc AS `nameMany`,
  1887.                 fp.name_single_$lc AS `nameFull`,
  1888.                 p.count AS `count`,
  1889.                 g.id AS `group.id`,
  1890.                 g.alt_name AS `group.altName`,
  1891.                 gname.$lc AS `group.name`,
  1892.                 url.$lc AS `slug`
  1893.             FROM
  1894.                 filters f
  1895.             LEFT JOIN filter_pages fp ON fp.id = f.page_id
  1896.             LEFT JOIN filter_params p ON p.id = f.param_id
  1897.             LEFT JOIN filter_groups g ON g.id = f.group_id
  1898.             LEFT JOIN locale_text gname ON gname.filter_group_name = g.id
  1899.             LEFT JOIN locale_url url ON url.filter_id = f.id
  1900.             WHERE
  1901.                 f.id IN ($fidsStr) AND
  1902.                 p.is_enable = 1
  1903.             ORDER BY f.sort, f.name";
  1905.         $sql = preg_replace('/[\s\n\r]+/', ' ', $sql);
  1907.         $memcache = $this->cacheService->getMemcache();
  1908.         $memcacheKey = md5($sql);
  1909.         $items = $memcache->get($memcacheKey);
  1911.         if ($items) {
  1912.             return $items;
  1913.         }
  1915.         $items = $this->getEntityManager()->getConnection()->fetchAll($sql);
  1917.         $memcache->set($memcacheKey, $items);
  1919.         return $items;
  1920.     }
  1922.     /**
  1923.      * Получение данных для формирования имени фильтра в хистри расширенного поиска
  1924.      * @param array $fids
  1925.      * @return array
  1926.      */
  1927.     public function getForFilterNameHistorySearch(array $fids): array
  1928.     {
  1929.         $lc = App::getCurLocale();
  1930.         $fids = array_unique(array_map('intval', array_filter($fids, 'is_numeric')));
  1931.         if (empty($fids)) {
  1932.             return [];
  1933.         }
  1934.         $fidsStr = implode(',', $fids);
  1936.         $sql = "SELECT
  1937.                 f.id AS `id`,
  1938.                 f.alt_name AS `altName`,
  1939.                 fpg.name_many_$lc AS `name`,
  1940.                 fpr.code AS `code`,
  1941.                 fg.alt_name AS `groupAltName`,
  1942.                 fg.left_menu AS `groupLeftMenu`
  1943.             FROM
  1944.                 filters f
  1945.             LEFT JOIN filter_groups fg ON fg.id = f.group_id
  1946.             LEFT JOIN filter_pages fpg ON fpg.id = f.page_id
  1947.             LEFT JOIN filter_params fpr ON fpr.id = f.param_id
  1948.             WHERE
  1949.                 f.id IN ($fidsStr)";
  1951.         $memcache = $this->cacheService->getMemcache();
  1952.         $memcacheKey = md5($sql);
  1953.         $items = $memcache->get($memcacheKey);
  1955.         if ($items) {
  1956.             return $items;
  1957.         }
  1959.         $items = $this->getEntityManager()->getConnection()->fetchAll($sql);
  1961.         $memcache->set($memcacheKey, $items);
  1963.         return $items;
  1964.     }
  1966.     /**
  1967.      * Список для назначения родителя в админке
  1968.      * @param $gid
  1969.      * @param $fid
  1970.      * @return array
  1971.      * @throws \Doctrine\DBAL\Exception
  1972.      */
  1973.     public function admGetListForParent($gid, $fid): array
  1974.     {
  1975.         $sql = "SELECT
  1976.                 f.id as `id`,
  1977.                    f.name AS `name.ru`,
  1978.                    fp.name_menu_en AS `name.en`
  1979.             FROM
  1980.                 filters f
  1981.             LEFT JOIN filter_pages fp ON fp.id = f.page_id
  1982.             LEFT JOIN filter_params p ON p.id = f.param_id
  1983.             WHERE f.id != $fid AND f.group_id = $gid AND p.is_enable = 1
  1984.             ORDER BY `name.ru`";
  1986.         $items = $this->getEntityManager()->getConnection()->fetchAllAssociative($sql);
  1988.         $rows = [];
  1989.         foreach ($items as $item) {
  1990.             $rows[$item['id']] = "{$item['name.ru']} ({$item['name.en']}) #{$item['id']}";
  1991.         }
  1993.         return $rows;
  1994.     }
  1996.     /**
  1997.      * @param string $leftMenu
  1998.      * @return string|null
  1999.      */
  2000.     public function getKeyByLeftMenu(string $leftMenu): ?string
  2001.     {
  2002.         $lc = App::getCurLocale();
  2003.         $sql = "SELECT
  2004.                    lurl.$lc AS `url`
  2005.             FROM
  2006.                 filters f
  2007.             LEFT JOIN locale_url lurl ON f.id = lurl.filter_id
  2008.             WHERE f.left_menu = '$leftMenu'
  2009.             LIMIT 1";
  2011.         $memcache = $this->cacheService->getMemcache();
  2012.         $memcacheKey = md5($sql);
  2013.         $items = $memcache->get($memcacheKey);
  2015.         if ($items) {
  2016.             return $items;
  2017.         }
  2019.         try {
  2020.             $items = $this->getEntityManager()
  2021.                 ->getConnection()
  2022.                 ->executeQuery($sql)
  2023.                 ->fetchOne() ?: null;
  2025.             $memcache->set($memcacheKey, $items);
  2027.             return $items;
  2028.         } catch (Throwable $e) {
  2029.             return null;
  2030.         }
  2031.     }
  2033.     public function getListForTestCountTranslate()
  2034.     {
  2035.         $q = $this->createQueryBuilder('f')
  2036.             ->select('f, g, p, descr, htmlShow')
  2037.             ->leftJoin('f.groups', 'g')
  2038.             ->leftJoin('f.page', 'p')
  2039.             ->leftJoin('f.htmlShow', 'htmlShow')
  2040.             ->leftJoin('f.nameForMetaDescr', 'descr')
  2041.             ->andWhere('g.id != 406')// фабрики
  2042.             ->andWhere('g.id != 411')// дизайнеры
  2043.             ->getQuery();
  2045.         return $q->getArrayResult();
  2046.     }
  2048.     /**
  2049.      * Получение списка ТОП фильтров, для формирования меню карусели на главной
  2050.      * @return array
  2051.      * @throws Exception
  2052.      * @see src/WebBundle/Resources/views/Home/_top-carousel.html.twig
  2053.      */
  2054.     public function getItemsForTopCollectionCarouselMenu(): array
  2055.     {
  2056.         $lc = App::getCurLocale();
  2057.         $cacheKey = "ItemsForTopCollectionCarouselMenu.$lc";
  2058.         $redisCachePool = App::getContainer()->get(RedisCachePool::class)->getPool();
  2059.         $cacheItem = $redisCachePool->getItem($cacheKey);
  2061.         if ($cacheItem->isHit()) {
  2062.             return $cacheItem->get();
  2063.         }
  2064.         $translator = App::getTranslator();
  2066.         $sql = "SELECT
  2067.                lurl.$lc AS `url`,
  2068.                lurl.en AS `key`,
  2069.                f.alt_name AS `alt`,
  2070.                f.id AS `id`
  2071.         FROM
  2072.             filters f
  2073.         LEFT JOIN locale_url lurl ON f.id = lurl.filter_id
  2074.         WHERE f.id in (10592,10591)";
  2076.         $rows = $this->getEntityManager()
  2077.             ->getConnection()
  2078.             ->executeQuery($sql)
  2079.             ->fetchAll();
  2081.         $items = [
  2082.             'top-all' => [
  2083.                 'title' => $translator->trans('main_top_all'),
  2084.                 'link' => App::generateUrl('app_catalog'),
  2085.                 'url-json' => App::generateUrl('app_last_collection', ['type' => 'top-all']),
  2086.                 'key' => 'top-all',
  2087.             ],
  2088.         ];
  2090.         if ($rows) {
  2091.             foreach ($rows as $row) {
  2092.                 $items[$row['key']] = [
  2093.                     'title' => $translator->trans("main_{$row['alt']}"),
  2094.                     'link' => App::generateUrl('app_catalog', ['key' => $row['url']]),
  2095.                     'url-json' => App::generateUrl('app_last_collection', ['type' => $row['key']]),
  2096.                     'key' => $row['key'],
  2097.                 ];
  2098.             }
  2100.             $cacheItem->set($items);
  2102.             $redisCachePool->save($cacheItem);
  2103.         }
  2105.         return $items;
  2106.     }
  2108.     /**
  2109.      * Выборка для отдачи списка дизайнеров в меню в каталоге
  2110.      * @param array $onlyIds
  2111.      * @return array
  2112.      * @throws \Doctrine\DBAL\Exception
  2113.      */
  2114.     public function getListDesignersForCataloge(array $onlyIds = []): array
  2115.     {
  2116.         if ($onlyIds) {
  2117.             $onlyIds = implode("','", $onlyIds);
  2118.             $onlyIds = " AND f.id IN ('$onlyIds')";
  2119.         } else {
  2120.             $onlyIds = '';
  2121.         }
  2122.         $sql = "SELECT
  2123.                 f.id,
  2124.                 f.rank AS `rank`,
  2125.                 f.old_command AS `oldCommand`,
  2126.                 f.old_id AS `oldId`,
  2127.                 fp.name_menu_en AS `name`,
  2128.                 p.count AS `cnt`,
  2129.                 url.en AS `slug`
  2130.             FROM
  2131.                 filters f
  2132.             LEFT JOIN filter_pages fp ON fp.id = f.page_id
  2133.             LEFT JOIN filter_params p ON p.id = f.param_id
  2134.             LEFT JOIN locale_url url ON url.filter_id = f.id
  2135.             WHERE p.count > 0 AND p.is_enable = 1 AND f.group_id = 411 $onlyIds
  2136.             ORDER BY f.name";
  2138.         $sql = preg_replace('/[\s\n\r]+/', ' ', $sql);
  2140.         $memcache = $this->cacheService->getMemcache();
  2141.         $memcacheKey = md5($sql);
  2142.         $items = $memcache->get($memcacheKey);
  2144.         if ($items) {
  2145.             return $items;
  2146.         }
  2148.         $items = $this
  2149.             ->getEntityManager()
  2150.             ->getConnection()
  2151.             ->fetchAllAssociative($sql);
  2153.         $memcache->set($memcacheKey, $items);
  2155.         return $items;
  2156.     }
  2158.     /**
  2159.      * @param string $lc
  2160.      * @param TranslatorInterface $translator
  2161.      * @return array
  2162.      */
  2163.     public function getListBrandsForMenu(string $lc, TranslatorInterface $translator): array
  2164.     {
  2165.         $status = BiConst::STATE_PUBLISHED . ', ' . BiConst::STATE_WORK_CONTINUED;
  2166.         $hideFactories = HideFactoryCountriesHelper::length() > 0
  2167.             ? join(', ', HideFactoryCountriesHelper::codes())
  2168.             : 0;
  2170.         $sql = "SELECT
  2171.                 b.id AS `id`,
  2172.                 url.$lc AS `slug`,
  2173.                 fp.name_menu_en AS `name`,
  2174.                 f.name AS `name2`,
  2175.                 f.id AS `filter_id`,
  2176.                 c.old_id AS `country.id`,
  2177.                 c.left_menu AS `country.alias`,
  2178.                 count(iia.idea_id) AS `totalIdeas`,
  2179.                 b.votes_submit AS `votesSubmit`,
  2180.                 b.votes_stars AS `votesStars`
  2181.             FROM
  2182.                 filters f
  2183.             LEFT JOIN filter_pages fp ON fp.id = f.page_id
  2184.             LEFT JOIN filter_params p ON p.id = f.param_id
  2185.             LEFT JOIN locale_url url ON url.filter_id = f.id
  2186.             LEFT JOIN factory b ON b.id = f.brand
  2187.             LEFT JOIN filters c ON c.id = f.country_id
  2188.             LEFT JOIN collection coll on b.id = coll.factory and coll.status = 1
  2189.             LEFT JOIN interior inte on coll.id = inte.collection
  2190.             LEFT JOIN idea_interior iia on inte.id = iia.interior_id
  2191.             WHERE f.brand IS NOT NULL
  2192.               AND f.id != '10639'
  2193.               AND p.is_enable = 1
  2194.               AND p.count >= 0
  2195.               AND b.status IN ($status)
  2196.               AND b.unid  IS NOT NULL
  2197.               AND b.id NOT IN ($hideFactories)
  2198.             group by f.id
  2199.             ORDER BY fp.name_menu_en";
  2201.         $memcache = $this->cacheService->getMemcache();
  2202.         $memcacheKey = md5($sql);
  2203.         $rows = $memcache->get($memcacheKey);
  2205.         if ($rows) {
  2206.             return $rows;
  2207.         }
  2209.         $rows = $this
  2210.             ->getEntityManager()
  2211.             ->getConnection()
  2212.             ->fetchAll($sql);
  2214.         foreach ($rows as $i => $row) {
  2215.             $row['id'] = intval($row['id']);
  2216.             $row['totalIdeas'] = intval($row['totalIdeas']);
  2217.             $row['votesSubmit'] = intval($row['votesSubmit']);
  2218.             $row['votesStars'] = intval($row['votesStars']);
  2220.             $row['country'] = [
  2221.                 'id' => intval($row['country.id']),
  2222.                 'alias' => trim($translator->trans($row['country.alias'])),
  2223.             ];
  2224.             unset($row['country.id']);
  2225.             unset($row['country.alias']);
  2226.             $rows[$i] = $row;
  2227.         }
  2229.         $memcache->set($memcacheKey, $rows);
  2231.         return $rows;
  2232.     }
  2234.     /**
  2235.      * @param int $filterParamId
  2236.      * @param int $count
  2237.      * @return bool
  2238.      * @throws \Doctrine\DBAL\Exception
  2239.      */
  2240.     public function updateCountAndShow(int $filterParamId, int $count)
  2241.     {
  2242.         // исключил из обновы фильтр коммерческая плитка и размеры
  2243.         if (in_array($filterParamId, [10171, 10405, 10406, 10407, 10408])) {
  2244.             return true;
  2245.         }
  2247.         $isEnabled = $count > 0 ? 1 : 0;
  2249.         $sql = "UPDATE `filter_params` SET `count` = '$count', `is_enable` = '$isEnabled' WHERE `id` = '$filterParamId';";
  2251.         $this->getEntityManager()->getConnection()->executeStatement($sql);
  2253.         return true;
  2254.     }
  2256.     /**
  2257.      * Выборка для простановки данных из шаблона переводов
  2258.      * @return FilterEntity[]
  2259.      */
  2260.     public function consoleGetListDesigners(): array
  2261.     {
  2262.         $q = $this->createQueryBuilder('f');
  2263.         $q->select('f, groups, param, page')
  2264.             ->leftJoin('f.groups', 'groups')
  2265.             ->leftJoin('f.param', 'param')
  2266.             ->leftJoin('f.page', 'page')
  2267.             ->andWhere("f.parentKey = 'designer'");
  2269.         return $q->getQuery()->getResult();
  2270.     }
  2272.     /**
  2273.      * @deprecated todo на удаление - не используется
  2274.      */
  2275.     public function getDesigners()
  2276.     {
  2277.         $q = $this->createQueryBuilder('f');
  2278.         $q
  2279.             ->andWhere("f.oldCommand =getDesigner")
  2280.             ->setParameter('getDesigner', 'getDesigner')
  2281.             ->orderBy('f.name');
  2283.         return $q->getQuery()->getArrayResult();
  2284.     }
  2286.     /**
  2287.      * Выборка для слайдера
  2288.      * @param string $lc
  2289.      * @param array $filters
  2290.      * @return array
  2291.      * @throws \Doctrine\DBAL\Exception
  2292.      */
  2293.     public function getArrListForSlider(string $lc, array $filters): array
  2294.     {
  2295.         $where = [];
  2296.         foreach ($filters as $group => $ides) {
  2297.             if ($ides[0] != null) {
  2298.                 if (is_int($ides[0])) {
  2299.                     $where[] = 'g.id = ' . $group . ' AND f.old_id = ' . $ides[0] . ' AND f.old_command = "' . $ides[1] . '"';
  2300.                 } elseif (is_array($ides[0])) {
  2301.                     $where[] = 'g.id = ' . $group . ' AND f.old_id IN (' . join(',', $ides[0]) . ') AND f.old_command = "' . $ides[1] . '"';
  2302.                 }
  2303.             }
  2304.         }
  2306.         if (count($where) == 0) {
  2307.             return [];
  2308.         }
  2310.         $sql = "SELECT
  2311.                 f.id,
  2312.                 f.alt_name AS `altName`,
  2313.                 fp.name_menu_$lc AS `name`,
  2314.                    u.$lc AS `url`,
  2315.                 p.count AS `count`,
  2316.                 g.id AS `group.id`,
  2317.                 g.alt_name AS `group.altName`,
  2318.                 gname.$lc AS `group.name`
  2319.             FROM
  2320.                 filters f
  2321.             LEFT JOIN filter_pages fp ON fp.id = f.page_id
  2322.             LEFT JOIN filter_params p ON p.id = f.param_id
  2323.             LEFT JOIN filter_groups g ON g.id = f.group_id
  2324.             LEFT JOIN locale_text gname ON gname.filter_group_name = g.id
  2325.             LEFT JOIN locale_url u ON u.filter_id = f.id
  2326.             LEFT JOIN factory b ON b.id = f.brand
  2327.             WHERE (g.alt_name <> 'brand' AND p.show_menu_advanced = 1 OR g.alt_name = 'brand' AND b.status = 1) AND
  2328.             (p.count > 0 OR g.alt_name = 'brand' OR g.alt_name = 'reviews') AND
  2329.             p.is_enable = 1 AND p.hide != 1 AND p.hide_all != 1 AND f.id != '10639'
  2330.             ";
  2332.         if ($where != null) {
  2333.             $sql .= ' AND (' . join(' OR ', $where) . ')';
  2334.         }
  2336.         $memcache = $this->cacheService->getMemcache();
  2337.         $memcacheKey = md5($sql);
  2338.         $rows = $memcache->get($memcacheKey);
  2340.         if ($rows) {
  2341.             return $rows;
  2342.         }
  2344.         $rows = $this->getEntityManager()->getConnection()->fetchAllAssociative($sql);
  2346.         $memcache->set($memcacheKey, $rows);
  2348.         return $rows;
  2349.     }
  2351.     public function getFiltersForSearchSphinx(array $keys, $lc = null)
  2352.     {
  2353.         $keys = implode("','", $keys);
  2355.         $sql = "SELECT
  2356.                 f.id,
  2357.                 f.old_command AS `oldCommand`,
  2358.                 f.old_id AS `oldId`
  2359.             FROM
  2360.                 filters f
  2361.             LEFT JOIN filter_params p ON p.id = f.param_id
  2362.             LEFT JOIN locale_url url ON url.filter_id = f.id
  2363.             WHERE p.count > 0 AND p.is_enable = 1 AND $lc IN ('$keys')
  2364.             ORDER BY f.name";
  2366.         $sql = preg_replace('/[\s\n\r]+/', ' ', $sql);
  2368.         $memcache = $this->cacheService->getMemcache();
  2369.         $memcacheKey = md5($sql);
  2370.         $items = $memcache->get($memcacheKey);
  2372.         if ($items) {
  2373.             return $items;
  2374.         }
  2376.         try {
  2377.             $items = $this->getEntityManager()->getConnection()->fetchAllAssociative($sql);
  2378.         } catch (\Doctrine\DBAL\Exception $e) {
  2379.             return [];
  2380.         }
  2382.         $res = [];
  2383.         foreach ($items as $item) {
  2384.             if (empty($res[$item['oldCommand']])) {
  2385.                 $res[$item['oldCommand']] = [];
  2386.             }
  2387.             $res[$item['oldCommand']][] = $item['oldId'];
  2388.         }
  2390.         $memcache->set($memcacheKey, $res);
  2392.         return $res;
  2393.     }
  2395.     /**
  2396.      * Получение списка фильтров для формирования ссылок под рекламу в гугле
  2397.      * @return array
  2398.      * @throws \Doctrine\DBAL\Exception
  2399.      */
  2400.     public function getListForGoogleAds()
  2401.     {
  2402.         //  -- группы ------------
  2403.         // Фактура 402
  2404.         // Стиль 400
  2405.         // Мотив рисунка 421
  2406.         // Цвет 395
  2407.         // Применение 394
  2408.         // Форма 413 (кроме прямоугольник 10507, квадрат 10845, неправильная форма 10510, Многоугольник 10509 )
  2409.         // Коэффициент антискольжения 422
  2410.         // Производство 396
  2411.         //  -- фильтры ------------
  2412.         // мозаика на сетке/бумаге 10114
  2413.         // фоновая плитка 10167
  2414.         // имитация мозаики 10677
  2415.         // раковина 10162
  2416.         // Виниловая плитка 10757
  2417.         // Назначение напольное 10170
  2418.         // Назначение настенное 10169
  2419.         // Поверхность 3D 10526
  2420.         // Поверхность состаренная 10613
  2421.         // Крупноформатная плитка 10617
  2422.         // Керамогранит утолщенный 10512
  2423.         // Керамогранит тонкий 10411
  2425.         $urlStrSql = [];
  2426.         $nameSingleStrSql = [];
  2427.         $nameManyStrSql = [];
  2428.         $nameGroupStrSql = [];
  2429.         $keyAdwords = $titleAdwords = $keyAdwCombiFirst = $titleAdwCombiFirst = $keyAdwCombiOther = $titleAdwCombiOther = [];
  2431.         $locales = LocaleHelper::getListAvailable();
  2432.         foreach ($locales as $lc) {
  2433.             $urlStrSql[] = "url.{$lc['code']} AS `url.{$lc['code']}`";
  2434.             $nameSingleStrSql[] = "page.name_single_{$lc['code']} AS `nameSingle.{$lc['code']}`";
  2435.             $nameManyStrSql[] = "page.name_many_{$lc['code']} AS `nameMany.{$lc['code']}`";
  2436.             $nameGroupStrSql[] = "fgname.{$lc['code']} AS `groupName.{$lc['code']}`";
  2438.             $keyAdwords[] = "keyAdw.{$lc['code']} AS `keyAdwords.{$lc['code']}`";
  2439.             $titleAdwords[] = "titleAdw.{$lc['code']} AS `titleAdwords.{$lc['code']}`";
  2440.             $keyAdwCombiFirst[] = "keyAdwCombiFirst.{$lc['code']} AS `keyAdwCombiFirst.{$lc['code']}`";
  2441.             $titleAdwCombiFirst[] = "titleAdwCombiFirst.{$lc['code']} AS `titleAdwCombiFirst.{$lc['code']}`";
  2442.             $keyAdwCombiOther[] = "keyAdwCombiOther.{$lc['code']} AS `keyAdwCombiOther.{$lc['code']}`";
  2443.             $titleAdwCombiOther[] = "titleAdwCombiOther.{$lc['code']} AS `titleAdwCombiOther.{$lc['code']}`";
  2444.         }
  2446.         $urlStrSql = implode(', ', $urlStrSql);
  2447.         $nameSingleStrSql = implode(', ', $nameSingleStrSql);
  2448.         $nameManyStrSql = implode(', ', $nameManyStrSql);
  2449.         $nameGroupStrSql = implode(', ', $nameGroupStrSql);
  2450.         $keyAdwords = implode(', ', $keyAdwords);
  2451.         $titleAdwords = implode(', ', $titleAdwords);
  2452.         $keyAdwCombiFirst = implode(', ', $keyAdwCombiFirst);
  2453.         $titleAdwCombiFirst = implode(', ', $titleAdwCombiFirst);
  2454.         $keyAdwCombiOther = implode(', ', $keyAdwCombiOther);
  2455.         $titleAdwCombiOther = implode(', ', $titleAdwCombiOther);
  2457.         $sql = "SELECT
  2458.                 f.id,
  2459.                 fg.alt_name AS `groupAltName`,
  2460.                 page.name_single_ru AS `name.single.ru`,
  2461.                 page.name_many_ru AS `name.many.ru`,
  2462.                 f.group_id AS `groupId`,
  2463.                 f.old_command AS `oldCommand`,
  2464.                 f.old_id AS `oldId`,
  2465.                 $urlStrSql, $nameSingleStrSql, $nameManyStrSql, $nameGroupStrSql, $keyAdwords, $titleAdwords, $keyAdwCombiFirst, $titleAdwCombiFirst, $keyAdwCombiOther, {$titleAdwCombiOther}
  2466.             FROM
  2467.                 filters f
  2468.             LEFT JOIN filter_params par ON par.id = f.param_id
  2469.             LEFT JOIN filter_pages page ON page.id = f.param_id
  2470.             LEFT JOIN locale_url url ON url.filter_id = f.id
  2471.             LEFT JOIN filter_groups fg ON fg.id = f.group_id
  2472.             LEFT JOIN locale_text fgname ON fg.id = fgname.filter_group_name
  2473.             LEFT JOIN locale_text keyAdw ON f.id = keyAdw.filter_key_adwords
  2474.             LEFT JOIN locale_text titleAdw ON f.id = titleAdw.filter_title_adwords
  2475.             LEFT JOIN locale_text keyAdwCombiFirst ON f.id = keyAdwCombiFirst.filter_key_adwords_combi_first
  2476.             LEFT JOIN locale_text titleAdwCombiFirst ON f.id = titleAdwCombiFirst.filter_title_adwords_combi_first
  2477.             LEFT JOIN locale_text keyAdwCombiOther ON f.id = keyAdwCombiOther.filter_key_adwords_combi_other
  2478.             LEFT JOIN locale_text titleAdwCombiOther ON f.id = titleAdwCombiOther.filter_title_adwords_combi_other
  2479.             WHERE par.is_enable = 1 AND par.count > 3
  2480.                 AND (
  2481.                     f.group_id IN (402,400,421,395,394,413,422,396) OR
  2482.                     f.id IN (10114,10677,10162,10757,10170,10169,10526,10613,10617,10512,10411)
  2483.                     )
  2484.                 AND (f.id NOT IN (10507,10845,10510,10509) )
  2485.             ";
  2487.         $sql = preg_replace('/[\s\n\r]+/', ' ', $sql);
  2488.         $items = $this->getEntityManager()->getConnection()->fetchAllAssociative($sql);
  2490.         $rows = [];
  2491.         foreach ($items as $item) {
  2492.             $fId = $item['id'];
  2494.             $url = [];
  2495.             $nameSingle = [];
  2496.             $nameMany = [];
  2497.             $groupName = [];
  2498.             $keyAdwords = $titleAdwords = $keyAdwCombiFirst = $titleAdwCombiFirst = $keyAdwCombiOther = $titleAdwCombiOther = [];
  2500.             foreach ($locales as $lc) {
  2501.                 $lcCode = $lc['code'];
  2502.                 $url[$lcCode] = $item["url.$lcCode"];
  2503.                 $nameSingle[$lcCode] = $item["nameSingle.$lcCode"];
  2504.                 $nameMany[$lcCode] = $item["nameMany.$lcCode"];
  2505.                 $groupName[$lcCode] = $item["groupName.$lcCode"];
  2508.                 $keyAdwords[$lcCode] = trim($item["keyAdwords.$lcCode"]);
  2509.                 $titleAdwords[$lcCode] = trim($item["titleAdwords.$lcCode"]);
  2511.                 $keyAdwCombiFirst[$lcCode] = trim($item["keyAdwCombiFirst.$lcCode"]);
  2512.                 $titleAdwCombiFirst[$lcCode] = trim($item["titleAdwCombiFirst.$lcCode"]);
  2513.                 $keyAdwCombiOther[$lcCode] = trim($item["keyAdwCombiOther.$lcCode"]);
  2514.                 $titleAdwCombiOther[$lcCode] = trim($item["titleAdwCombiOther.$lcCode"]);
  2515.             }
  2517.             //заменяем первый заговоловок на поле Заголовок из формы рекламы фильтра
  2518.             $titleAdwCombiFirst = $titleAdwords;
  2520.             $rows[$fId] = [
  2521.                 'id' => $fId,
  2522.                 'groupId' => $item['groupId'],
  2523.                 'groupAltName' => $item['groupAltName'],
  2524.                 'name.single.ru' => $item['name.single.ru'],
  2525.                 'oldCommand' => $item['oldCommand'],
  2526.                 'oldId' => $item['oldId'],
  2527.                 'url' => $url,
  2528.                 'nameSingle' => $nameSingle,
  2529.                 'nameMany' => $nameMany,
  2530.                 'groupName' => $groupName,
  2531.                 'adwords' => [
  2532.                     'keysOne' => $keyAdwords,
  2533.                     'titleOne' => $titleAdwords,
  2534.                     'keysCombiFirst' => $keyAdwCombiFirst,
  2535.                     'titleCombiFirst' => $titleAdwCombiFirst,
  2536.                     'keysCombiOther' => $keyAdwCombiOther,
  2537.                     'titleCombiOther' => $titleAdwCombiOther,
  2538.                 ],
  2540.             ];
  2541.         }
  2543.         return $rows;
  2544.     }
  2546.     private function buildSQLSelectForFilterResponseDTO(string $lc): string
  2547.     {
  2548.         $lcs = LocaleHelper::getListAvailable();
  2549.         $lcs = array_column($lcs, 'code');
  2551.         $urlSelect = [];
  2552.         foreach ($lcs as $lc_) {
  2553.             $urlSelect[] = "url.$lc_ AS `slug.$lc_`";
  2554.         }
  2555.         $urlSelect = implode(', ', $urlSelect);
  2557.         return "SELECT
  2558.                 f.id,
  2559.                 f.rank AS `rank`,
  2560.                 f.alt_name AS `altName`,
  2561.                 f.old_command AS `sphinxName`,
  2562.                 f.old_id AS `sphinxId`,
  2563.                 htmlshow.$lc AS `isHtmlShow`,
  2564.                 fp.name_menu_$lc AS `nameMenu`,
  2565.                 fp.name_many_$lc AS `nameMany`,
  2566.                 fp.name_single_$lc AS `nameSingle`,
  2567.                 fp.html_$lc AS `html`,
  2568.                 fp.description_$lc AS `description`,
  2569.                 metadesc.$lc AS `metaDescriptionName`,
  2570.                 par.count AS `count`,
  2571.                 par.code AS `code`,
  2572.                 par.is_enable AS `isEnable`,
  2573.                 gr.id AS `groupId`,
  2574.                 gr.alt_name AS `groupAltName`,
  2575.                 gpname.$lc AS `groupName`,
  2576.                 url.$lc AS `slug`, $urlSelect,
  2577.                 b.id AS `brandId`,
  2578.                 b.status AS `brandStatus`,
  2579.                 b.stated_at AS `brandStatedAt`,
  2580.                 b.type AS `brandType`,
  2581.                 b.name AS `brandName`,
  2582.                 f.logo AS `brandLogo`,
  2583.                 f.logo_url AS `brandLogoUrl`,
  2584.                 b.sound AS `brandSound`,
  2585.                 b.video AS `brandVideo`,
  2586.                 cn.id AS `countryId`,
  2587.                 cnfp.name_single_$lc AS `countryName`,
  2588.                 cnurl.$lc AS `countrySlug`,
  2589.                 cnpar.code AS `countryCode`
  2590.             FROM
  2591.                 filters f
  2592.             LEFT JOIN filter_pages fp ON fp.id = f.page_id
  2593.             LEFT JOIN filter_params par ON par.id = f.param_id
  2594.             LEFT JOIN filter_groups gr ON gr.id = f.group_id
  2595.             LEFT JOIN locale_text gpname ON gpname.filter_group_name = gr.id
  2596.             LEFT JOIN locale_text metadesc ON metadesc.filter_name_for_meta_descr_id = f.id
  2597.             LEFT JOIN locale_url url ON url.filter_id = f.id
  2598.             LEFT JOIN locale_bool htmlshow ON htmlshow.filter_html_show_id = f.id
  2599.             LEFT JOIN factory b ON b.id = f.brand
  2600.             LEFT JOIN filters cn ON cn.id = f.country_id
  2601.             LEFT JOIN filter_pages cnfp ON cnfp.id = cn.page_id
  2602.             LEFT JOIN locale_url cnurl ON cnurl.filter_id = cn.id
  2603.             LEFT JOIN filter_params cnpar ON cnpar.id = cn.param_id
  2604.             ";
  2605.     }
  2607.     /**
  2608.      * $this->buildFilterResponseDTO($item);
  2609.      * @param array $data
  2610.      * @return FilterResponseDTO|null
  2611.      */
  2612.     private function buildFilterResponseDTO(array $data): ?FilterResponseDTO
  2613.     {
  2614.         if (!$data['slug']) {
  2615.             return null;
  2616.         }
  2618.         $lcs = LocaleHelper::getListAvailable();
  2619.         $lcs = array_column($lcs, 'code');
  2621.         $slugs = [];
  2622.         foreach ($lcs as $lc_) {
  2623.             $slugs[$lc_] = $data["slug.$lc_"];
  2624.         }
  2626.         $country = !$data['countryId']
  2627.             ? null
  2628.             : new FilterCountryResponseDTO(
  2629.                 (int) $data['countryId'],
  2630.                 $data['countryName'],
  2631.                 $data['countrySlug'],
  2632.                 $data['countryCode'],
  2633.             );
  2635.         $brand = !$data['brandId']
  2636.             ? null
  2637.             : new BrandResponseDTO(
  2638.                 (int) $data['brandId'],
  2639.                 (int) $data['brandStatus'],
  2640.                 $data['brandName'],
  2641.                 $data['slug'],
  2642.                 $data['brandLogo'],
  2643.                 $data['brandLogoUrl'],
  2644.                 (int) $data['brandType'],
  2645.                 $data['brandStatedAt'],
  2646.                 $data['brandSound'],
  2647.                 $data['brandVideo'] ? json_decode($data['brandVideo']) : null,
  2648.                 $data['description'],
  2649.                 $country,
  2650.             );
  2652.         return new FilterResponseDTO(
  2653.             (int) $data['id'],
  2654.             $data['altName'],
  2655.             (int) $data['sphinxId'],
  2656.             $data['sphinxName'],
  2657.             $data['nameMenu'],
  2658.             $data['nameMany'],
  2659.             $data['nameSingle'],
  2660.             (bool) $data['isHtmlShow'],
  2661.             $data['metaDescriptionName'],
  2662.             $data['html'],
  2663.             $data['count'],
  2664.             $data['code'],
  2665.             (bool) $data['isEnable'],
  2666.             (int) $data['groupId'],
  2667.             $data['groupName'],
  2668.             $data['groupAltName'],
  2669.             $data['slug'],
  2670.             $slugs,
  2671.             $data['description'],
  2672.             $brand
  2673.         );
  2674.     }
  2676.     /**
  2677.      * @param string $sql
  2678.      * @param string $locale
  2679.      * @return FilterResponseDTO[]
  2680.      * @throws \Doctrine\DBAL\Driver\Exception
  2681.      * @throws \Doctrine\DBAL\Exception
  2682.      */
  2683.     private function getKeysBySql(string $sql, string $locale): array
  2684.     {
  2685.         $memcache = $this->cacheService->getMemcache();
  2686.         $memcacheKey = md5($sql) . $locale;
  2687.         $rows = $memcache->get($memcacheKey);
  2689.         if ($rows) {
  2690.             return $rows;
  2691.         }
  2693.         $items = $this->getEntityManager()->getConnection()->fetchAllAssociative($sql);
  2695.         $ids = array_column($items, 'id');
  2697.         $rows = $this->getSortedByIds($ids, $locale);
  2699.         $memcache->set($memcacheKey, $rows);
  2701.         return $rows;
  2702.     }
  2704.     /**
  2705.      * Получает фильтры и соответствующие группы по идентификатору группы.
  2706.      *
  2707.      * @param int $groupId Идентификатор группы.
  2708.      * @return array Массив с данными фильтров и групп.
  2709.      */
  2710.     public function getFiltersByGroupId(int $groupId): array
  2711.     {
  2712.         $urlStrSql = [];
  2713.         $keyAdwords = $titleAdwords = $keyAdwCombiFirst = $titleAdwCombiFirst = $keyAdwCombiOther = $titleAdwCombiOther = [];
  2715.         $locales = LocaleHelper::getListAvailable();
  2716.         foreach ($locales as $lc) {
  2717.             $urlStrSql[] = "url.{$lc['code']} AS `url.{$lc['code']}`";
  2718.             $keyAdwords[] = "keyAdw.{$lc['code']} AS `keyAdwords.{$lc['code']}`";
  2719.             $titleAdwords[] = "titleAdw.{$lc['code']} AS `titleAdwords.{$lc['code']}`";
  2720.             $keyAdwCombiFirst[] = "keyAdwCombiFirst.{$lc['code']} AS `keyAdwCombiFirst.{$lc['code']}`";
  2721.             $titleAdwCombiFirst[] = "titleAdwCombiFirst.{$lc['code']} AS `titleAdwCombiFirst.{$lc['code']}`";
  2722.             $keyAdwCombiOther[] = "keyAdwCombiOther.{$lc['code']} AS `keyAdwCombiOther.{$lc['code']}`";
  2723.             $titleAdwCombiOther[] = "titleAdwCombiOther.{$lc['code']} AS `titleAdwCombiOther.{$lc['code']}`";
  2724.         }
  2726.         $urlStrSql = implode(', ', $urlStrSql);
  2727.         $keyAdwords = implode(', ', $keyAdwords);
  2728.         $titleAdwords = implode(', ', $titleAdwords);
  2729.         $keyAdwCombiFirst = implode(', ', $keyAdwCombiFirst);
  2730.         $titleAdwCombiFirst = implode(', ', $titleAdwCombiFirst);
  2731.         $keyAdwCombiOther = implode(', ', $keyAdwCombiOther);
  2732.         $titleAdwCombiOther = implode(', ', $titleAdwCombiOther);
  2734.         $sql = "SELECT
  2735.                 f.id,
  2736.                 f.name AS name,
  2737.                 f.alt_name AS altName,
  2738.                 g.id AS groupId,
  2739.                 p.count AS count,
  2740.                 $urlStrSql,
  2741.                 $keyAdwords,
  2742.                 $titleAdwords,
  2743.                 $keyAdwCombiFirst,
  2744.                 $titleAdwCombiFirst,
  2745.                 $keyAdwCombiOther,
  2746.                 $titleAdwCombiOther
  2747.             FROM
  2748.                 filters f
  2749.             LEFT JOIN filter_groups g ON g.id = f.group_id
  2750.             LEFT JOIN filter_params p ON p.id = f.param_id
  2751.             LEFT JOIN locale_url url ON url.filter_id = f.id
  2752.             LEFT JOIN locale_text keyAdw ON keyAdw.filter_key_adwords = f.id
  2753.             LEFT JOIN locale_text titleAdw ON titleAdw.filter_title_adwords = f.id
  2754.             LEFT JOIN locale_text keyAdwCombiFirst ON keyAdwCombiFirst.filter_key_adwords_combi_first = f.id
  2755.             LEFT JOIN locale_text titleAdwCombiFirst ON titleAdwCombiFirst.filter_title_adwords_combi_first = f.id
  2756.             LEFT JOIN locale_text keyAdwCombiOther ON keyAdwCombiOther.filter_key_adwords_combi_other = f.id
  2757.             LEFT JOIN locale_text titleAdwCombiOther ON titleAdwCombiOther.filter_title_adwords_combi_other = f.id
  2758.             WHERE
  2759.                 g.id = :groupId
  2760.             ORDER BY
  2761.                 p.count DESC
  2762.                ";
  2764.         $items = $this->getEntityManager()->getConnection()->fetchAllAssociative($sql, [
  2765.             'groupId' => $groupId
  2766.         ]);
  2768.         return $items;
  2769.     }
  2770. }