src/Service/Top100ProfilesService.php line 111

Open in your IDE?
  1. <?php
  3. namespace App\Service;
  5. use App\Dto\Top100\Top100ProfileQueryByIdsDTO;
  6. use App\Dto\Top100\Top100ProfileQueryRandomDTO;
  7. use App\Entity\Location\City;
  8. use App\Entity\Profile\Genders;
  9. use App\Repository\ProfileCtrRepository;
  10. use App\Service\Top100\Top100ProfileQueryService;
  11. use App\Specification\Profile\ProfileIdNotIn;
  12. use App\Specification\Profile\ProfileIsApproved;
  13. use Psr\Cache\CacheItemPoolInterface;
  15. class Top100ProfilesService
  16. {
  18.     public const LIMIT = 100;
  19.     public const CACHE_LIMIT = 200;
  21.     public const GENDERS_DEFAULT = [Genders::FEMALE];
  23.     public function __construct(
  24.         private ProfileCtrRepository $profileCtrRepository,
  25.         private Top100ProfileQueryService $profileQueryService,
  26.         private CacheItemPoolInterface $cache,
  27.     ) {}
  30.     public function getCachedProfileIds(City $city): array
  31.     {
  32.         $cacheKey = $this->getCacheKey($city);
  34.         $cacheItem = $this->cache->getItem($cacheKey);
  35.         if (!$cacheItem->isHit()) {
  36.             return [];
  37.         }
  39.         $profileIds = $cacheItem->get();
  41.         return is_array($profileIds) ? $profileIds : [];
  42.     }
  45.     public function refreshProfileIdsCache(City $city): array
  46.     {
  47.         $cacheKey = $this->getCacheKey($city);
  48.         $profileIds = $this->buildProfileIds($city);
  50.         $cacheItem = $this->cache->getItem($cacheKey);
  51.         $cacheItem->set($profileIds);
  52.         $this->cache->save($cacheItem);
  54.         return $profileIds;
  55.     }
  58.     private function buildProfileIds(City $city): array
  59.     {
  60.         $dateStart = new \DateTimeImmutable('-30 days');
  61.         $rankedIds = $this->profileCtrRepository->topVisitedApprovedProfileIdsInCity($city, $dateStart, self::CACHE_LIMIT);
  63.        
  64.         $rankedProfiles = empty($rankedIds)
  65.             ? []
  66.             : $this->profileQueryService->getActiveProfilesByIds(
  67.                 new Top100ProfileQueryByIdsDTO(
  68.                     city: $city,
  69.                     ids: $rankedIds,
  70.                     filters: [new ProfileIsApproved()],
  71.                     genders: self::GENDERS_DEFAULT,
  72.                     limit: self::CACHE_LIMIT,
  73.                 )
  74.             );
  76.         
  77.         $ranked = array_map(static fn($profile) => $profile->id, $rankedProfiles);
  79.         if (count($ranked) >= self::CACHE_LIMIT) {
  80.             return array_slice($ranked, 0, self::CACHE_LIMIT);
  81.         }
  83.         $toFill = self::CACHE_LIMIT - count($ranked);
  85.         $randomFilters = [new ProfileIsApproved()];
  86.         if (!empty($ranked)) {
  87.             $randomFilters[] = new ProfileIdNotIn($ranked);
  88.         }
  90.         $randomDto = new Top100ProfileQueryRandomDTO(
  91.             city: $city,
  92.             filters: $randomFilters,
  93.             genders: self::GENDERS_DEFAULT,
  94.             limit: $toFill,
  95.         );
  96.        
  97.         $randomApproved = $this->profileQueryService->getRandomProfiles($randomDto);
  99.         
  100.         $randomIds = array_map(static fn($profile) => $profile->id, $randomApproved);
  101.         return array_merge($ranked, $randomIds);
  102.     }
  104.     private function getCacheKey(City $city): string
  105.     {
  106.         return sprintf('listing.top_100.profile_ids.city.%d', $city->getId());
  107.     }
  108.     
  111.     public function getSortedProfilesByVisits(City $city): \Porpaginas\Page
  112.     {
  113.         $rankedIds = $this->getCachedProfileIds($city);
  115.         $rankedProfiles = $this->profileQueryService->getActiveProfilesByIds(
  116.             new Top100ProfileQueryByIdsDTO(
  117.                 city: $city,
  118.                 ids: $rankedIds,
  119.                 filters: [new ProfileIsApproved()],
  120.                 genders: self::GENDERS_DEFAULT,
  121.                 limit: self::LIMIT,
  122.             )
  123.         );
  125.         if (count($rankedProfiles) < self::LIMIT) {
  126.             $toFill = self::LIMIT - count($rankedProfiles);
  127.             $rankedProfileIds = array_map(static fn($profile) => $profile->id, $rankedProfiles);
  129.             $randomFilters = [new ProfileIsApproved()];
  130.             if (!empty($rankedProfileIds)) {
  131.                 $randomFilters[] = new ProfileIdNotIn($rankedProfileIds);
  132.             }
  134.             $randomApproved = $this->profileQueryService->getRandomProfiles(
  135.                 new Top100ProfileQueryRandomDTO(
  136.                     city: $city,
  137.                     filters: $randomFilters,
  138.                     genders: self::GENDERS_DEFAULT,
  139.                     limit: $toFill,
  140.                 )
  141.             );
  143.             $rankedProfiles = array_merge($rankedProfiles, $randomApproved);
  144.         }
  146.         return $this->profileQueryService->createFakePageFromProfiles(count($rankedProfiles), $rankedProfiles);
  147.     }
  148. }