src/Services/BannerService.php line 162

Open in your IDE?
  1. <?php
  3. namespace Slivki\Services;
  5. use Doctrine\ORM\EntityManagerInterface;
  6. use Slivki\Entity\Banner\AbstractMobileAppBanner;
  7. use Slivki\Entity\Banner\CategoryMobileAppBanner;
  8. use Slivki\Entity\Banner\ExternalMobileAppBanner;
  9. use Slivki\Entity\Banner\OfferMobileAppBanner;
  10. use Slivki\Entity\City;
  11. use Slivki\Entity\Banner;
  12. use Slivki\Entity\Category;
  13. use Slivki\Entity\SidebarBanner;
  14. use Slivki\Repository\Banner\CommentsBannerRepositoryInterface;
  15. use Slivki\Repository\Banner\MobileAppBannerRepositoryInterface;
  16. use Slivki\Util\SoftCache;
  17. use Symfony\Component\DependencyInjection\ContainerInterface;
  18. use Symfony\Component\HttpFoundation\Session\Session;
  19. use Symfony\Component\HttpKernel\KernelInterface;
  21. final class BannerService
  22. {
  23.     const CACHE_NAME = 'banner-1-';
  24.     const MOBILE_CACHE_NAME_PREFIX = 'mobile-1-';
  25.     const CACHE_INDEX_KEY = 'index-for-comments-3-';
  26.     const SIDEBAR_BANNER_CACHE_KEY = 'sidebar-banner-12-1-';
  27.     const MAIN_MENU_BANNER_CACHE_KEY = 'main-menu-banner-1-';
  28.     const CACHE_VERSION_CACHE_KEY = '-version-1-';
  29.     const MOBILE_APP_MAIN_PAGE_BANNER_CACHE_KEY = 'mobile-app-1-';
  30.     // offerId => bannerId
  31.     private const BANNER_BAN_LIST = [
  32.         143636 => 9322
  33.     ];
  35.     private $bannerRepository;
  36.     private $entityManager;
  37.     private $container;
  38.     private $kernel;
  39.     private MobileAppBannerRepositoryInterface $mobileAppBannerRepository;
  40.     private CommentsBannerRepositoryInterface $commentsBannerRepository;
  42.     public function __construct(
  43.         EntityManagerInterface $entityManager,
  44.         ContainerInterface $container,
  45.         KernelInterface $kernel,
  46.         MobileAppBannerRepositoryInterface $mobileAppBannerRepository,
  47.         CommentsBannerRepositoryInterface $commentsBannerRepository
  48.     ) {
  49.         $this->bannerRepository = $entityManager->getRepository(Banner::class);
  50.         $this->entityManager = $entityManager;
  51.         $this->container = $container;
  52.         $this->kernel = $kernel;
  53.         $this->mobileAppBannerRepository = $mobileAppBannerRepository;
  54.         $this->commentsBannerRepository = $commentsBannerRepository;
  55.     }
  57.     public function getHeadBannerCached($cityID, $categoryIDs, $mobile, $mobileCache = false) {
  58.         $cacheName = $mobileCache ? Banner::MOBILE_HEAD_BANNER_CACHE_NAME : Banner::HEAD_BANNER_CACHE_NAME;
  59.         $cacheName .= $this->getCacheVersion() . '-' . $cityID;
  60.         $softCache = new SoftCache($cacheName);
  61.         $bannersAmount = $softCache->get('amount');
  62.         if (!$bannersAmount) {
  63.             $this->reloadHeadBannerCache($cityID, $mobileCache);
  64.             $bannersAmount = $softCache->get('amount');
  65.         }
  66.         if ($bannersAmount <= 0 || $bannersAmount == SoftCache::LOCKED_KEY) {
  67.             return '';
  68.         }
  69.         $cacheKey = $mobile ? '-mobile' : '';
  70.         $bannerHtml = '';
  71.         $banners = [];
  72.         for ($i = 1; $i <= $bannersAmount; $i++) {
  73.             $banner = $softCache->get($i . $cacheKey);
  74.             $banners[$i] = $banner;
  75.         }
  76.         $session = new Session();
  77.         $bannerIndexSessionKey = $mobile ? '2-bannerIndex-mobile' : '2-bannerIndex';
  78.         $bannerIndex = $session->get($bannerIndexSessionKey);
  79.         if (!$bannerIndex || $bannerIndex > $bannersAmount) {
  80.             $bannerIndex = 1;
  81.             $session->set($bannerIndexSessionKey, $bannerIndex);
  82.         }
  83.         $categoryBannerIDs = [];
  84.         $isPassThroughOnly = true;
  85.         foreach ($categoryIDs as $categoryID) {
  86.             $currentCategory = $this->entityManager->getRepository(Category::class)->findCached((int)$categoryID);
  87.             if (isset($currentCategory['category'])) {
  88.                 foreach ($banners as $key => $banner) {
  89.                     if (in_array($key, $categoryBannerIDs) || (!$banner['categoryID'] && !$banner['passThrough'])) {
  90.                         continue;
  91.                     }
  92.                     if ($banner['passThrough']) {
  93.                         $categoryBannerIDs[] = $key;
  94.                     } elseif ($banner['categoryID'] == $categoryID || $currentCategory['category']->isChildOfRecursive($banner['categoryID']) || $banner['passThrough']) {
  95.                         $categoryBannerIDs[] = $key;
  96.                         if (!$banner['passThrough']) {
  97.                             $isPassThroughOnly = false;
  98.                         }
  99.                     }
  100.                 }
  101.             }
  102.         }
  103.         if (empty($categoryBannerIDs) || $isPassThroughOnly) {
  104.             foreach ($banners as $key => $banner) {
  105.                 if ($banner['categoryID'] && !$banner['passThrough']) {
  106.                     unset($banners[$key]);
  107.                 }
  108.             }
  109.             if (count($banners) == 0) {
  110.                 return '';
  111.             }
  112.             $banners = array_combine(range(1, count($banners)), array_values($banners));
  113.             $bannersAmount = count($banners);
  114.             if ($bannerIndex > $bannersAmount) {
  115.                 $bannerIndex = 1;
  116.                 $session->set($bannerIndexSessionKey, $bannerIndex);
  117.             }
  118.             if (isset($banners[$bannerIndex]['html']) && (!$banners[$bannerIndex]['categoryID'] || $banners[$bannerIndex]['passThrough'])) {
  119.                 $bannerHtml = $banners[$bannerIndex]['html'];
  120.                 $session->set($bannerIndexSessionKey, $bannerIndex + 1);
  121.             } else {
  122.                 $nextBannerIndex = $bannerIndex + 1;
  123.                 $nextBannerIndex = $nextBannerIndex > $bannersAmount ? 1 : $nextBannerIndex;
  124.                 while ($nextBannerIndex != $bannerIndex) {
  125.                     if (isset($banners[$nextBannerIndex]['html'])) {
  126.                         $bannerHtml = $banners[$nextBannerIndex]['html'];
  127.                         $session->set($bannerIndexSessionKey, $nextBannerIndex);
  128.                         break;
  129.                     }
  130.                     $nextBannerIndex++;
  131.                     $nextBannerIndex = $nextBannerIndex > $bannersAmount ? 1 : $nextBannerIndex;
  132.                 }
  133.             }
  134.         } else {
  135.             if (isset($banners[$bannerIndex]['html']) && in_array($bannerIndex, $categoryBannerIDs)) {
  136.                 $bannerHtml = $banners[$bannerIndex]['html'];
  137.                 $session->set($bannerIndexSessionKey, $bannerIndex + 1);
  138.             } else {
  139.                 $nextBannerIndex = $bannerIndex + 1;
  140.                 $nextBannerIndex = $nextBannerIndex > $bannersAmount ? 1 : $nextBannerIndex;
  141.                 while ($nextBannerIndex != $bannerIndex) {
  142.                     if (isset($banners[$nextBannerIndex]['html']) && in_array($nextBannerIndex, $categoryBannerIDs)) {
  143.                         $bannerHtml = $banners[$nextBannerIndex]['html'];
  144.                         $session->set($bannerIndexSessionKey, $nextBannerIndex + 1);
  145.                         break;
  146.                     }
  147.                     $nextBannerIndex++;
  148.                     $nextBannerIndex = $nextBannerIndex > $bannersAmount ? 1 : $nextBannerIndex;
  149.                 }
  150.             }
  151.         }
  152.         return $bannerHtml ? $bannerHtml : '';
  153.     }
  155.     public function resetHeadBannerCache() {
  156.         $softCache = new SoftCache(self::CACHE_NAME);
  157.         $version = $softCache->get(self::CACHE_VERSION_CACHE_KEY, 0);
  158.         $version++;
  159.         $softCache->set(self::CACHE_VERSION_CACHE_KEY, $version,30 * 60);
  160.     }
  162.     public function reloadHeadBannerCache($cityID, $mobileCache = false) {
  163.         $cacheName = $mobileCache ? Banner::MOBILE_HEAD_BANNER_CACHE_NAME : Banner::HEAD_BANNER_CACHE_NAME;
  164.         $cacheName .= $this->getCacheVersion() . '-' . $cityID;
  165.         $softCache = new SoftCache($cacheName);
  166.         $previousBannersAmount = $softCache->get('amount');
  167.         if ($previousBannersAmount == SoftCache::LOCKED_KEY) {
  168.             return;
  169.         }
  170.         $softCache->set('amount', SoftCache::LOCKED_KEY, 30);
  171.         if (!$previousBannersAmount) {
  172.             $previousBannersAmount = 0;
  173.         }
  174.         $bannerList = $this->entityManager->getRepository(Banner\HeaderBanner::class)->findBy(['active' => true], ['ID' => 'DESC']);
  175.         $currentBannerAmount = 0;
  177.         $bannerListByCity = [];
  178.         foreach ($bannerList as $key => $banner) {
  179.             if (in_array($cityID, $banner->getCityIds(), true)) {
  180.                 $bannerListByCity[$key] = $banner;
  181.             }
  182.         }
  183.         if (!empty($bannerListByCity)) {
  184.             $bannerList = $bannerListByCity;
  185.         }
  187.         /** @var Banner\HeaderBanner $banner */
  188.         foreach ($bannerList as $key => $banner) {
  189.             if (!$mobileCache && $banner->getCodeFilePath()) {
  190.                 continue;
  191.             }
  192.             if ($banner->getCityIds() && !in_array($cityID, $banner->getCityIds(), true)) {
  193.                 continue;
  194.             }
  195.             $currentBannerAmount++;
  196.             if ($banner->isJavaScript()) {
  197.                 $bannerHTML = $banner->getCode();
  198.                 if ($banner->getCodeFilePath()) {
  199.                     $bannerHTML = @file_get_contents(realpath($this->kernel->getProjectDir() . '/public') . $banner->getCodeFilePath());
  200.                     $softCache->set($currentBannerAmount . '-mobile', ['categoryID' => $banner->getCategoryID(), 'passThrough' => $banner->isPassThrough(), 'html' => $bannerHTML], 0);
  201.                 }
  202.             } else {
  203.                 if (stripos($banner->getFilePath(), '.swf') !== false) {
  204.                     $data = [
  205.                         'banner' => $banner,
  206.                         'width' => '100%',
  207.                         'height' => 90
  208.                     ];
  209.                     $bannerHTML = $this->container->get('twig')->render('Slivki/banners/swf_banner.html.twig', $data);
  210.                 } else {
  211.                     $view = 'Slivki/banners/head_banner.html.twig';
  212.                     if ($mobileCache) {
  213.                         $view = 'Slivki/mobile/banner/header_banner.html.twig';
  214.                     }
  215.                     $bannerHTML = $this->container->get('twig')->render($view, ['topSiteBanner' => $banner]);
  216.                 }
  217.             }
  218.             $softCache->set($currentBannerAmount, ['categoryID' => $banner->getCategoryID(), 'passThrough' => $banner->isPassThrough(), 'html' => $bannerHTML], 0);
  219.             if ($banner->getFilePathMobile() != '') {
  220.                 if (!$banner->getCodeFilePath()) {
  221.                     $view = 'Slivki/banners/head_banner.html.twig';
  222.                     if ($mobileCache) {
  223.                         $view = 'Slivki/mobile/banner/header_banner.html.twig';
  224.                     }
  225.                     $banner->setFilePath($banner->getFilePathMobile());
  226.                     $bannerHTML = $this->container->get('twig')->render($view, ['topSiteBanner' => $banner]);
  227.                 }
  228.                 $softCache->set($currentBannerAmount . '-mobile', ['categoryID' => $banner->getCategoryID(), 'passThrough' => $banner->isPassThrough(), 'html' => $bannerHTML], 0);
  229.             }
  230.         };
  231.         for ($i = $currentBannerAmount + 1; $i <= $previousBannersAmount; $i++) {
  232.             $softCache->delete($i);
  233.         }
  234.         $softCache->set('amount', $currentBannerAmount, 30 * 60);
  235.     }
  237.     private function getCacheVersion() {
  238.         return (new SoftCache(self::CACHE_NAME))->get(self::CACHE_VERSION_CACHE_KEY, 0);
  239.     }
  241.     public function getMainMenuBannerCached() {
  242.         $softCache = new SoftCache(self::CACHE_NAME);
  243.         $cacheKey = self::MAIN_MENU_BANNER_CACHE_KEY;
  244.         $mainMenuBannerList = $softCache->get($cacheKey, []);
  245.         return $mainMenuBannerList;
  246.     }
  248.     public function reloadMainMenuBannerCache() {
  249.         $softCache = new SoftCache(self::CACHE_NAME);
  250.         $cacheKey = self::MAIN_MENU_BANNER_CACHE_KEY;
  251.         $mainMenuBannerList = $this->entityManager->getRepository(Banner\MainMenuBanner::class)->findBy(['active' => true], ['ID' => 'DESC']);
  252.         $twig = $this->container->get('twig');
  253.         $i = 0;
  254.         $banners = [];
  255.         foreach ($mainMenuBannerList as $banner) {
  256.             $banners[$i] = $twig->render('Slivki/banners/main_menu_banner.html.twig', ['banner' => $banner, 'index' => $i]);
  257.             $i++;
  258.         }
  259.         $softCache->set($cacheKey, $banners, 0);
  260.     }
  262.     public function getCategoryBannerCached(Category $category = null, $isMobile) {
  263.         if (!$category) {
  264.             return '';
  265.         }
  266.         $softCache = new SoftCache(Banner::CATEGORY_BANNER_CACHE_NAME);
  267.         $cachedBannerList = $softCache->get('category'.$category->getID());
  268.         if (!$cachedBannerList) {
  269.             $cachedBannerList = $this->reloadCategoryBannerCache($category);
  270.         }
  271.         if ($cachedBannerList == '') {
  272.             return '';
  273.         }
  274.         $bannerIDList = explode(',', $cachedBannerList);
  275.         return $this->getCategoryBannerCachedByID($bannerIDList[array_rand($bannerIDList)], $isMobile);
  276.     }
  278.     public function reloadCategoryBannerCache(Category $category) {
  279.         $softCache = new SoftCache(Banner::CATEGORY_BANNER_CACHE_NAME);
  280.         $bannerList = $category->getActiveBannersByType(Banner::TYPE_CATEGORY_BANNER);
  281.         $bannerIDList = [];
  282.         foreach ($bannerList as $banner) {
  283.             $bannerIDList[] = $banner->getID();
  284.         }
  285.         $imlodedBanerIDList = implode($bannerIDList, ',');
  286.         if (empty($bannerIDList)) {
  287.             $softCache->delete('category'.$category->getID());
  288.             return '';
  289.         }
  290.         $softCache->set('category'.$category->getID(), $imlodedBanerIDList, 30 * 40);
  291.         return $imlodedBanerIDList;
  292.     }
  294.     public function reloadCategoryBannerListCache() {
  295.         $bannerList = $this->bannerRepository->findBy(['typeID' => Banner::TYPE_CATEGORY_BANNER, 'active' => true]);
  296.         foreach ($bannerList as $banner) {
  297.             $this->reloadCategoryBannerCacheByID($banner->getID());
  298.         }
  299.     }
  301.     public function getCategoryBannerCachedByID($bannerID, $isMobile = false) {
  302.         $softCache = new SoftCache($isMobile ? self::MOBILE_CACHE_NAME_PREFIX . Banner::CATEGORY_BANNER_CACHE_NAME
  303.             : Banner::CATEGORY_BANNER_CACHE_NAME);
  305.         $bannerContent = $softCache->get($bannerID);
  306.         if (!$bannerContent) {
  307.             $bannerContent = $this->reloadCategoryBannerCacheByID($bannerID, $isMobile);
  308.         }
  309.         return $bannerContent;
  310.     }
  312.     public function reloadCategoryBannerCacheByID($bannerID, $isMobile = false) {
  313.         $softCache = new SoftCache(Banner::CATEGORY_BANNER_CACHE_NAME);
  314.         $mobileSoftCache = new SoftCache(self::MOBILE_CACHE_NAME_PREFIX . Banner::CATEGORY_BANNER_CACHE_NAME);
  315.         /** @var Banner $banner */
  316.         $banner = $this->bannerRepository->find($bannerID);
  317.         if (!$banner) {
  318.             return '';
  319.         }
  320.         if ($banner->getTypeID() != Banner::TYPE_CATEGORY_BANNER) {
  321.             return '';
  322.         }
  323.         if (!$banner->isActive()) {
  324.             $softCache->delete($bannerID);
  325.         }
  326.         $data['categoryBanner'] = $banner;
  327.         $twig = $this->container->get('twig');
  328.         $bannerContent = $twig->render('Slivki/banners/category_banner.html.twig', $data);
  329.         $softCache->set($bannerID, $bannerContent, 60 * 40);
  330.         $mobileBannerContent = $twig->render('Slivki/mobile/banner/banner.html.twig', ['banner' => $banner]);
  331.         $mobileSoftCache->set($bannerID, $mobileBannerContent, 60 * 40);
  332.         return $isMobile ? $mobileBannerContent : $bannerContent;
  333.     }
  335.     public function getCommentsBanners($mobileDevice = false, $cityID = City::DEFAULT_CITY_ID, $offerId = null) {
  336.         $commentsBannerList = $this->commentsBannerRepository->findActiveByCities([$cityID]);
  337.         $commentsBannerHtmlList = [];
  338.         $view = $mobileDevice ? 'Slivki/mobile/banner/banner.html.twig' : 'Slivki/banners/comments_banner.html.twig';
  339.         /** @var Banner $banner */
  340.         foreach($commentsBannerList as $banner) {
  341.             if (null !== $offerId && !empty(self::BANNER_BAN_LIST[$offerId]) && (int) $banner->getID() === self::BANNER_BAN_LIST[$offerId]) {
  342.                 continue;
  343.             }
  344.             $commentsBannerHtmlList[$banner->getPositionRow()][] = $this->container->get('twig')->render($view, ['banner' => $banner]);
  345.         }
  346.         // Add offer button
  347.         ksort($commentsBannerHtmlList);
  348.         $i = 1;
  349.         foreach ($commentsBannerHtmlList as $key=>$item) {
  350.             if ($i == 2 && !isset($commentsBannerHtmlList[$key+2]) && !$mobileDevice) {
  351.                 $commentsBannerHtmlList[$key+2][0] = '<div class="add-offer-comment-link"><a class="button--rose button" href="/moya_akciya" onclick="ga(\'send\', \'event\', \'create-own-offer-button--comments\', \'Click\', \'1\');">Разместить свою акцию на Slivki.by</a></div>';
  352.             }
  353.             if ($i > 2) {
  354.                 break;
  355.             }
  356.             $i++;
  357.         }
  358.         return $commentsBannerHtmlList;
  359.     }
  361.     public function getCacheIndex() {
  362.         $softCache = new SoftCache(self::CACHE_NAME);
  363.         $cacheKey = self::CACHE_INDEX_KEY;
  364.         $cacheIndex = $softCache->get($cacheKey);
  366.         return $cacheIndex ? $cacheIndex : 0;
  367.     }
  369.     public function incrementCacheIndex() {
  370.         $softCache = new SoftCache(self::CACHE_NAME);
  371.         $cacheKey = self::CACHE_INDEX_KEY;
  372.         $cacheIndex = $softCache->get($cacheKey);
  373.         $cacheIndex = $cacheIndex ? $cacheIndex + 1 : 1;
  374.         $softCache->set($cacheKey, $cacheIndex, 0);
  375.     }
  377.     public function getSidebarBannerCached($cityID) {
  378.         $softCache = new SoftCache(self::CACHE_NAME);
  379.         $cacheKey = self::SIDEBAR_BANNER_CACHE_KEY . '-' . $cityID;
  380.         $cacheKeyLocked = $cacheKey . '-locked';
  381.         $sidebarBannerCached = $softCache->get($cacheKey);
  382.         if (!$sidebarBannerCached || ($sidebarBannerCached['expiredOn'] > time() && !$softCache->get($cacheKeyLocked))) {
  383.             return $this->reloadSidebarBannerCache($cityID);
  384.         }
  385.         $sidebarBannerCached['serverTimeToBannerTime'] = strtotime(date("Y-m-d 09:00:00")) - time();
  386.         return $sidebarBannerCached;
  387.     }
  389.     public function reloadSidebarBannerCache($cityID) {
  390.         $softCache = new SoftCache(self::CACHE_NAME);
  391.         $cacheKey = self::SIDEBAR_BANNER_CACHE_KEY . '-' . $cityID;
  392.         $cacheKeyLocked = $cacheKey . '-locked';
  393.         $softCache->add($cacheKeyLocked, 'locked', 20);
  394.         $sidebarBannerRepository = $this->entityManager->getRepository(SidebarBanner::class);
  395.         $bannerList = $sidebarBannerRepository->findBy(['active' => true, 'cityID' => $cityID], ['ID' => 'ASC']);
  396.         if (!$bannerList) {
  397.             $bannerList = $sidebarBannerRepository->findBy(['active' => true, 'cityID' => City::DEFAULT_CITY_ID], ['ID' => 'ASC']);
  398.         }
  400.         $sidebarBannerCached['serverTimeToBannerTime'] = strtotime(date("Y-m-d 09:00:00")) - time();
  401.         $sidebarBannerCached['html'] = $this->container->get('twig')->render('Slivki/banners/sidebar_banner.html.twig', [
  402.             'bannerList' => $bannerList,
  403.             'lastPurchasesOfferList' => []
  404.         ]);
  405.         $sidebarBannerCached['expiredOn'] = time() + 60 * 5;
  406.         $softCache->set($cacheKey, $sidebarBannerCached, 0);
  407.         return $sidebarBannerCached;
  408.     }
  410.     public function getBeautyShopBannerCached() {
  411.         $softCache = new SoftCache(Banner::BEAUTY_SHOPS_CACHE_NAME);
  412.         $cachedBannerList = $softCache->get('beautyShop');
  413.         if (!$cachedBannerList) {
  414.             $cachedBannerList = $this->reloadBeautyShopBannerCache();
  415.         }
  416.         if ($cachedBannerList == '') {
  417.             return '';
  418.         }
  419.         $bannerIDList = explode(',', $cachedBannerList);
  420.         return $this->getBeautyShopBannerCachedByID($bannerIDList[array_rand($bannerIDList)]);
  421.     }
  423.     public function reloadBeautyShopBannerCache() {
  424.         $softCache = new SoftCache(Banner::CATEGORY_BANNER_CACHE_NAME);
  425.         $bannerList = $this->bannerRepository->findBy(['typeID' => Banner::TYPE_BEAUTY_SHOPS_BANNER, 'active' => true]);
  426.         $bannerIDList = [];
  427.         foreach ($bannerList as $banner) {
  428.             $bannerIDList[] = $banner->getID();
  429.         }
  430.         $imlodedBanerIDList = implode($bannerIDList, ',');
  431.         if (empty($bannerIDList)) {
  432.             $softCache->delete('beautyShop');
  433.             return '';
  434.         }
  435.         $softCache->set('beautyShop', $imlodedBanerIDList, 30 * 40);
  436.         return $imlodedBanerIDList;
  437.     }
  439.     public function reloadBeautyShopBannerListCache() {
  440.         $bannerList = $this->bannerRepository->findBy(['typeID' => Banner::TYPE_BEAUTY_SHOPS_BANNER, 'active' => true]);
  441.         foreach ($bannerList as $banner) {
  442.             $this->reloadBeautyShopBannerCacheByID($banner->getID());
  443.         }
  444.     }
  446.     public function getBeautyShopBannerCachedByID($bannerID) {
  447.         $softCache = new SoftCache(Banner::BEAUTY_SHOPS_CACHE_NAME);
  448.         $bannerContent = $softCache->get($bannerID);
  449.         if (!$bannerContent) {
  450.             $bannerContent = $this->reloadBeautyShopBannerCacheByID($bannerID);
  451.         }
  452.         return $bannerContent;
  453.     }
  455.     public function reloadBeautyShopBannerCacheByID($bannerID) {
  456.         $softCache = new SoftCache(Banner::BEAUTY_SHOPS_CACHE_NAME);
  457.         /** @var Banner $banner */
  458.         $banner = $this->bannerRepository->find($bannerID);
  459.         if (!$banner) {
  460.             return '';
  461.         }
  462.         if ($banner->getTypeID() != Banner::TYPE_BEAUTY_SHOPS_BANNER) {
  463.             return '';
  464.         }
  465.         if (!$banner->isActive()) {
  466.             $softCache->delete($bannerID);
  467.         }
  468.         $data['banner'] = $banner;
  469.         $bannerContent = $this->container->get('twig')->render('Slivki/banners/beauty_shop_banner.html.twig', $data);
  470.         $softCache->set($bannerID, $bannerContent, 60 * 40);
  471.         return $bannerContent;
  472.     }
  474.     public function getMobileAppMainPageBannerCache($cityID = City::DEFAULT_CITY_ID) {
  475.         $softCache = new SoftCache(self::CACHE_NAME);
  476.         $result = $softCache->get(self::MOBILE_APP_MAIN_PAGE_BANNER_CACHE_KEY . $cityID);
  477.         if (!$result) {
  478.             return $this->reloadMobileAppMainPageBannerCache($cityID);
  479.         }
  480.         return $result;
  481.     }
  483.     public function reloadMobileAppMainPageBannerCache(int $cityID = City::DEFAULT_CITY_ID): array
  484.     {
  485.         $softCache = new SoftCache(self::CACHE_NAME);
  487.         $result = [];
  488.         $banners = $this->mobileAppBannerRepository->findActiveByCity($cityID);
  489.         $baseURL = $this->container->getParameter('base_url');
  491.         /** @var AbstractMobileAppBanner $banner */
  492.         foreach ($banners as $banner) {
  493.             $entityID = null;
  495.             if ($banner instanceof CategoryMobileAppBanner) {
  496.                 $entityID = $banner->getCategory()->getID();
  497.                 $target = 'category';
  498.                 $entityName = $banner->getCategory()->getName();
  499.             } elseif ($banner instanceof OfferMobileAppBanner) {
  500.                 $entityID = $banner->getOffer()->getID();
  501.                 $target = 'offer';
  502.                 $entityName = $banner->getOffer()->getTitle();
  503.             } elseif ($banner instanceof ExternalMobileAppBanner) {
  504.                 $target = 'external';
  505.             }
  507.             $result[] = [
  508.                 'ID' => $banner->getID(),
  509.                 'imageURL' => $baseURL . $banner->getFilePath(),
  510.                 'target' => $target,
  511.                 'entityID' => $entityID,
  512.                 'entityName' => $entityName,
  513.                 'externalUrl' => $banner->getURL(),
  514.             ];
  515.         }
  517.         $softCache->set(self::MOBILE_APP_MAIN_PAGE_BANNER_CACHE_KEY . $cityID, $result, 60 * 30);
  519.         return $result;
  520.     }
  521. }