src/Service/Client/ActivityFeedService.php line 48

Open in your IDE?
  1. <?php
  3. namespace App\Service\Client;
  5. use Frivol\Common\Dict\ActivityFeedType;
  6. use Frivol\Common\JSON;
  7. use Knp\Component\Pager\Pagination\PaginationInterface;
  8. use Symfony\Component\HttpFoundation\Response;
  9. use Symfony\Contracts\Cache\ItemInterface;
  10. use Symfony\Contracts\HttpClient\Exception\TransportExceptionInterface;
  11. use Twig\Error\Error;
  12. use Websocket\InfostreamHandler;
  13. use Websocket\TemplateRendererTwig;
  15. class ActivityFeedService extends AbstractClient
  16. {
  17.     public function getTimelineFeedForMember(int $member, int $page, int $perPage): PaginationInterface
  18.     {
  19.         $key = (new \ReflectionClass($this))->getShortName() . '_' . __FUNCTION__ . '_' . $member . '_' . $page . '_' . $perPage;
  21.         return $this->getCacheService()->get($key, function (ItemInterface $item) use ($member, $page, $perPage) {
  22.             try {
  23.                 $response = $this->requestJSON('GET', 'api/public/feeds/activity/timeline/' . $member . '/' . $page, [
  24.                     'query' => [
  25.                         'limit' => $perPage,
  26.                     ]
  27.                 ]);
  28.             } catch (TransportExceptionInterface $exception) {
  29.                 return $this->getDefaultPagination([], $page, $perPage);
  30.             }
  32.             if (is_array($response)) {
  33.                 $item->expiresAfter(600);
  34.                 $item->tag([
  35.                     'timelinefeed',
  36.                     'timelinefeed-' . $member
  37.                 ]);
  38.             }
  40.             return $this->getDefaultPagination($response, $page, $perPage);
  41.         });
  42.     }
  44.     /**
  45.      * @param int $page
  46.      * @param int $limit
  47.      */
  48.     public function getGlobalTimelineFeed(int $page, int $limit): PaginationInterface {
  49.         $key = (new \ReflectionClass($this))->getShortName() . '_' . __FUNCTION__ . '_' . $page . '_' . $limit;
  51.         return $this->getCacheService()->get($key, function (ItemInterface $item) use ($page, $limit) {
  52.             try {
  53.                 $response = $this->requestJSON('GET', 'api/public/feeds/activity/infostream/global/' . $page, [
  54.                     'query' => [
  55.                         'limit' => $limit,
  56.                     ]
  57.                 ]);
  58.             } catch (TransportExceptionInterface $exception) {
  59.                 return $this->getDefaultPagination([], $page, $limit);
  60.             }
  62.             if (is_array($response)) {
  63.                 $item->expiresAfter(30);
  64.                 $item->tag([
  65.                     'timelinefeed-global'
  66.                 ]);
  67.             }
  69.             return $this->getDefaultPagination($response, $page, $limit);
  70.         });
  71.     }
  73.     /**
  74.      * @param int $member
  75.      * @return PaginationInterface
  76.      * @throws \Psr\Cache\InvalidArgumentException
  77.      * @throws \ReflectionException
  78.      */
  79.     public function getProfileVisitsForMember(int $member): PaginationInterface
  80.     {
  81.         $key = (new \ReflectionClass($this))->getShortName() . '_' . __FUNCTION__ . '_' . $member;
  83.         return $this->getCacheService()->get($key, function (ItemInterface $item) use ($member) {
  84.             $item->expiresAfter(60 * 5);
  86.             $response = $this->requestJSON('GET', 'api/user/profilevisits/' . $member);
  88.             // old code does not keep more than 30 items in the redis key (applied in api aswell).
  90.             return $this->getDefaultPagination($response, 1, 30);
  91.         });
  92.     }
  94.     /**
  95.      * @param int $hostMemberId
  96.      * @param int $visitorMemberId
  97.      * @return bool
  98.      */
  99.     public function createProfileVisit(int $hostMemberId, int $visitorMemberId): bool
  100.     {
  101.         try {
  102.             $response = $this->issuePost('api/user/profilevisits/visit/' . $hostMemberId . '/' . $visitorMemberId, []);
  103.         } catch (TransportExceptionInterface $e) {
  104.             return false;
  105.         }
  107.         return $response->getStatusCode() === Response::HTTP_CREATED;
  108.     }
  110.     public function createProfileVisitFromPath(string $profileUri, int $visitorMemberId): bool
  111.     {
  112.         if (preg_match('#^/profil/([a-z0-9\-]+)$#iu', $profileUri, $matches) !== 1) {
  113.             return false;
  114.         }
  116.         try {
  117.             $response = $this->issuePost('api/user/profilevisits/visitusername/' . $matches[1] . '/' . $visitorMemberId, []);
  118.         } catch (TransportExceptionInterface $e) {
  119.             return false;
  120.         }
  122.         return $response->getStatusCode() === Response::HTTP_CREATED;
  123.     }
  125.     public function updatePublicInfostream(TemplateRendererTwig $renderer, \Redis $redis): array
  126.     {
  127.         $publicActivities = $this->requestJSON('GET', 'api/public/feeds/activity/infostream/public');
  128.         $storedStream = [];
  129.         foreach ($publicActivities['data'] as $activity) {
  130.             try {
  131.                 $html = $renderer->renderInfostreamItem($activity);
  132.             } catch (Error $e) {
  133.                 $this->logger->error($e->getMessage() . PHP_EOL . $e->getTraceAsString());
  134.                 continue;
  135.             }
  137.             if (empty($html)) {
  138.                 continue;
  139.             }
  140.             $storedStream[$activity['id']] = $html;
  141.         }
  142.         krsort($storedStream);
  144.         $redis->set(InfostreamHandler::PUBLIC_INFOSTREAM_CACHE_KEY, gzcompress(JSON::encode($storedStream)));
  145.         return $storedStream;
  146.     }
  148.     /**
  149.      * Returns list with new activities for ['all'] or [$memberId] to be published by websocket server.
  150.      * Need to use activityId as key, to be capable of loading only new events for each member.
  151.      * @param string $memberId2ActivityId
  152.      * @param TemplateRendererTwig $renderer
  153.      * @param \Redis $redis
  154.      * @return array[]
  155.      * @throws TransportExceptionInterface
  156.      * @throws \JsonException
  157.      * @throws \RedisException
  158.      * @throws \Symfony\Contracts\HttpClient\Exception\ClientExceptionInterface
  159.      * @throws \Symfony\Contracts\HttpClient\Exception\RedirectionExceptionInterface
  160.      * @throws \Symfony\Contracts\HttpClient\Exception\ServerExceptionInterface
  161.      */
  162.     public function updateMemberInfostream(string $memberId2ActivityId, TemplateRendererTwig $renderer, \Redis $redis): array
  163.     {
  164.         $memberActivities = $this->requestJSON('POST', 'api/public/feeds/activity/infostream/members', [
  165.             'body' => [
  166.                 'member_activity_ids' => $memberId2ActivityId,
  167.             ]
  168.         ]);
  169.         $renderer->setLogger($this->logger);
  170.         $activityUpdates = $visitorUpdates = $infostreamUpdates = [];
  171.         foreach ($memberActivities['data'] as $memberId => $activities) {
  172.             if (empty($activities)) {
  173.                 continue;
  174.             }
  176.             [$infostreamItems, $activityItems, $visitItems] = self::getMemberLists($memberId, $redis);
  177.             if (!is_array($infostreamItems)) {
  178.                 $infostreamItems = [];
  179.             }
  180.             if (!is_array($activityItems)) {
  181.                 $activityItems = [];
  182.             }
  183.             if (!is_array($visitItems)) {
  184.                 $visitItems = [];
  185.             }
  187.             foreach ($activities as $activity) {
  188.                 //#564 member infostream is now clone of sidebar activity items handled in app.js & HeaderApp!
  189.                 //$html = $renderer->renderInfostreamItem($activity, true);
  190.                 //if ('' !== trim($html)) {
  191.                 //    $infostreamItems[$activity['id']] = $html;
  192.                 //    $infostreamUpdates[$memberId][$activity['id']] = $html;
  193.                 //}
  195.                 $html = $renderer->renderSidebarActivityItem($activity);
  196.                 if ('' !== trim($html)) {
  197.                     $activityItems[$activity['id']] = $html;
  198.                     $activityUpdates[$memberId][$activity['id']] = $html;
  199.                 }
  201.                 if ($activity['type'] === ActivityFeedType::PROFILE_VISIT && ('' !== $html = $renderer->renderSidebarProfileVisitItem($activity))) {
  202.                     $visitorUpdates[$memberId][$activity['id']] = $visitItems[$activity['id']] = $html;
  203.                 }
  204.             }
  205.             krsort($infostreamItems);
  206.             krsort($activityItems);
  207.             krsort($visitItems);
  209.             if (!$this->setMemberLists($memberId, array_slice($infostreamItems, 0, 20, true), array_slice($activityItems, 0, 100, true), array_slice($visitItems, 0, 100, true), $redis)) {
  210.                 $this->logger->critical('Failed to store infostream/activitySidebar/visitsSidebar items in redis.');
  211.             }
  212.         }
  214.         krsort($infostreamUpdates);
  215.         krsort($activityUpdates);
  216.         krsort($visitorUpdates);
  218.         return [
  219.             'infostreamUpdates' => $infostreamUpdates,
  220.             'activityUpdates' => $activityUpdates,
  221.             'visitorUpdates' => $visitorUpdates,
  222.         ];
  223.     }
  225.     /**
  226.      * @param int $memberId
  227.      * @param \Redis $redis
  228.      * @return array[]
  229.      * @throws \JsonException
  230.      * @throws \RedisException
  231.      */
  232.     public static function getMemberLists(int $memberId, \Redis $redis): array
  233.     {
  234.         [$infostreamJson, $activitiesJson, $visitsJson] = $redis->mGet([
  235.             InfostreamHandler::MEMBER_INFOSTREAM_CACHE_KEY . $memberId,
  236.             InfostreamHandler::ACTIVITIES_SIDEBAR_CACHE_KEY . $memberId,
  237.             InfostreamHandler::PROFILE_VISIT_SIDEBAR_CACHE_KEY . $memberId,
  238.         ]);
  240.         return [
  241.             0 => is_string($infostreamJson) ? JSON::decode(gzuncompress($infostreamJson)) : [],
  242.             1 => is_string($activitiesJson) ? JSON::decode(gzuncompress($activitiesJson)) : [],
  243.             2 => is_string($visitsJson) ? JSON::decode(gzuncompress($visitsJson)) : [],
  244.         ];
  245.     }
  247.     public function getPublicInfostream(\Redis $redis, int $initialEntries = 8): array
  248.     {
  249.         $returnStruct = ['initial' => [], 'delayed' => []];
  250.         $feedJson = $redis->get(InfostreamHandler::PUBLIC_INFOSTREAM_CACHE_KEY);
  251.         if (empty($feedJson)) {
  252.             return $returnStruct;
  253.         }
  254.         $feedItems = JSON::decode(gzuncompress($feedJson));
  256.         ksort($feedItems);
  257.         $processed = $sendDelay = 0;
  258.         foreach ($feedItems as $itemHtml) {
  259.             $processed++;
  261.             if ($processed <= $initialEntries) {
  262.                 $returnStruct['initial'][] = $itemHtml;
  263.                 continue;
  264.             }
  266.             $sendDelay += random_int(1, 3);//Fake constant stream of activity, so users can keep up with reading.
  267.             $returnStruct['delayed'][$sendDelay] = $itemHtml;
  268.         }
  270.         return $returnStruct;
  271.     }
  273.     private function setMemberLists(int $memberId, array $infostreamItems, array $activityItems, array $visitItems, \Redis $redis): bool
  274.     {
  275.         return $redis->mSet([
  276.             InfostreamHandler::MEMBER_INFOSTREAM_CACHE_KEY . $memberId => gzcompress(JSON::encode($infostreamItems), 6),
  277.             InfostreamHandler::ACTIVITIES_SIDEBAR_CACHE_KEY . $memberId => gzcompress(JSON::encode($activityItems), 6),
  278.             InfostreamHandler::PROFILE_VISIT_SIDEBAR_CACHE_KEY . $memberId => gzcompress(JSON::encode($visitItems), 6),
  279.         ]);
  280.     }
  281. }