src/Controller/Api/User/UserRetrieveApi.php
<?php
// SPDX-FileCopyrightText: 2023 /kbin contributors <https://kbin.pub/>
//
// SPDX-License-Identifier: AGPL-3.0-only
declare(strict_types=1);
namespace App\Controller\Api\User;
use App\Controller\Traits\PrivateContentTrait;
use App\Entity\User;
use App\Entity\UserBlock;
use App\Entity\UserFollow;
use App\Kbin\User\DTO\UserResponseDto;
use App\Kbin\User\DTO\UserSettingsDto;
use App\Kbin\User\Factory\UserFactory;
use App\Repository\UserRepository;
use App\Schema\PaginationSchema;
use App\Service\UserSettingsManager;
use Nelmio\ApiDocBundle\Annotation\Model;
use Nelmio\ApiDocBundle\Annotation\Security;
use OpenApi\Attributes as OA;
use Symfony\Bridge\Doctrine\Attribute\MapEntity;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\HttpKernel\Exception\AccessDeniedHttpException;
use Symfony\Component\RateLimiter\RateLimiterFactory;
use Symfony\Component\Security\Http\Attribute\IsGranted;
class UserRetrieveApi extends UserBaseApi
{
use PrivateContentTrait;
#[OA\Response(
response: 200,
description: 'Returns the User',
content: new Model(type: UserResponseDto::class),
headers: [
new OA\Header(
header: 'X-RateLimit-Remaining',
schema: new OA\Schema(type: 'integer'),
description: 'Number of requests left until you will be rate limited'
),
new OA\Header(
header: 'X-RateLimit-Retry-After',
schema: new OA\Schema(type: 'integer'),
description: 'Unix timestamp to retry the request after'
),
new OA\Header(
header: 'X-RateLimit-Limit',
schema: new OA\Schema(type: 'integer'),
description: 'Number of requests available'
),
]
)]
#[OA\Response(
response: 401,
description: 'Permission denied due to missing or expired token',
content: new OA\JsonContent(ref: new Model(type: \App\Schema\Errors\UnauthorizedErrorSchema::class))
)]
#[OA\Response(
response: 404,
description: 'User not found',
content: new OA\JsonContent(ref: new Model(type: \App\Schema\Errors\NotFoundErrorSchema::class))
)]
#[OA\Response(
response: 429,
description: 'You are being rate limited',
content: new OA\JsonContent(ref: new Model(type: \App\Schema\Errors\TooManyRequestsErrorSchema::class)),
headers: [
new OA\Header(
header: 'X-RateLimit-Remaining',
schema: new OA\Schema(type: 'integer'),
description: 'Number of requests left until you will be rate limited'
),
new OA\Header(
header: 'X-RateLimit-Retry-After',
schema: new OA\Schema(type: 'integer'),
description: 'Unix timestamp to retry the request after'
),
new OA\Header(
header: 'X-RateLimit-Limit',
schema: new OA\Schema(type: 'integer'),
description: 'Number of requests available'
),
]
)]
#[OA\Parameter(
name: 'user_id',
in: 'path',
description: 'The user to retrieve',
schema: new OA\Schema(type: 'integer'),
)]
#[OA\Tag(name: 'user')]
public function __invoke(
#[MapEntity(id: 'user_id')]
User $user,
UserFactory $factory,
RateLimiterFactory $apiReadLimiter,
RateLimiterFactory $anonymousApiReadLimiter,
): JsonResponse {
$headers = $this->rateLimit($apiReadLimiter, $anonymousApiReadLimiter);
$dto = $factory->createDto($user);
return new JsonResponse(
$this->serializeUser($dto),
headers: $headers
);
}
#[OA\Response(
response: 200,
description: 'Returns the user by username',
content: new Model(type: UserResponseDto::class),
headers: [
new OA\Header(
header: 'X-RateLimit-Remaining',
schema: new OA\Schema(type: 'integer'),
description: 'Number of requests left until you will be rate limited'
),
new OA\Header(
header: 'X-RateLimit-Retry-After',
schema: new OA\Schema(type: 'integer'),
description: 'Unix timestamp to retry the request after'
),
new OA\Header(
header: 'X-RateLimit-Limit',
schema: new OA\Schema(type: 'integer'),
description: 'Number of requests available'
),
]
)]
#[OA\Response(
response: 401,
description: 'Permission denied due to missing or expired token',
content: new OA\JsonContent(ref: new Model(type: \App\Schema\Errors\UnauthorizedErrorSchema::class))
)]
#[OA\Response(
response: 404,
description: 'User not found',
content: new OA\JsonContent(ref: new Model(type: \App\Schema\Errors\NotFoundErrorSchema::class))
)]
#[OA\Response(
response: 429,
description: 'You are being rate limited',
content: new OA\JsonContent(ref: new Model(type: \App\Schema\Errors\TooManyRequestsErrorSchema::class)),
headers: [
new OA\Header(
header: 'X-RateLimit-Remaining',
schema: new OA\Schema(type: 'integer'),
description: 'Number of requests left until you will be rate limited'
),
new OA\Header(
header: 'X-RateLimit-Retry-After',
schema: new OA\Schema(type: 'integer'),
description: 'Unix timestamp to retry the request after'
),
new OA\Header(
header: 'X-RateLimit-Limit',
schema: new OA\Schema(type: 'integer'),
description: 'Number of requests available'
),
]
)]
#[OA\Parameter(
name: 'username',
in: 'path',
description: 'The user to retrieve',
schema: new OA\Schema(type: 'string'),
)]
#[OA\Tag(name: 'user')]
public function username(
#[MapEntity(mapping: ['username' => 'username'])]
User $user,
UserFactory $factory,
RateLimiterFactory $apiReadLimiter,
RateLimiterFactory $anonymousApiReadLimiter,
): JsonResponse {
$headers = $this->rateLimit($apiReadLimiter, $anonymousApiReadLimiter);
$dto = $factory->createDto($user);
return new JsonResponse(
$this->serializeUser($dto),
headers: $headers
);
}
#[OA\Response(
response: 200,
description: 'Returns the current user',
content: new Model(type: UserResponseDto::class),
headers: [
new OA\Header(
header: 'X-RateLimit-Remaining',
schema: new OA\Schema(type: 'integer'),
description: 'Number of requests left until you will be rate limited'
),
new OA\Header(
header: 'X-RateLimit-Retry-After',
schema: new OA\Schema(type: 'integer'),
description: 'Unix timestamp to retry the request after'
),
new OA\Header(
header: 'X-RateLimit-Limit',
schema: new OA\Schema(type: 'integer'),
description: 'Number of requests available'
),
]
)]
#[OA\Response(
response: 401,
description: 'Permission denied due to missing or expired token',
content: new OA\JsonContent(ref: new Model(type: \App\Schema\Errors\UnauthorizedErrorSchema::class))
)]
#[OA\Response(
response: 429,
description: 'You are being rate limited',
content: new OA\JsonContent(ref: new Model(type: \App\Schema\Errors\TooManyRequestsErrorSchema::class)),
headers: [
new OA\Header(
header: 'X-RateLimit-Remaining',
schema: new OA\Schema(type: 'integer'),
description: 'Number of requests left until you will be rate limited'
),
new OA\Header(
header: 'X-RateLimit-Retry-After',
schema: new OA\Schema(type: 'integer'),
description: 'Unix timestamp to retry the request after'
),
new OA\Header(
header: 'X-RateLimit-Limit',
schema: new OA\Schema(type: 'integer'),
description: 'Number of requests available'
),
]
)]
#[OA\Tag(name: 'user')]
#[Security(name: 'oauth2', scopes: ['user:profile:read'])]
#[IsGranted('ROLE_OAUTH2_USER:PROFILE:READ')]
public function me(
UserFactory $factory,
RateLimiterFactory $apiReadLimiter,
): JsonResponse {
$headers = $this->rateLimit($apiReadLimiter);
$dto = $factory->createDto($this->getUserOrThrow());
return new JsonResponse(
$this->serializeUser($dto),
headers: $headers
);
}
#[OA\Response(
response: 200,
description: 'Returns the current user\'s settings',
content: new Model(type: UserSettingsDto::class),
headers: [
new OA\Header(
header: 'X-RateLimit-Remaining',
schema: new OA\Schema(type: 'integer'),
description: 'Number of requests left until you will be rate limited'
),
new OA\Header(
header: 'X-RateLimit-Retry-After',
schema: new OA\Schema(type: 'integer'),
description: 'Unix timestamp to retry the request after'
),
new OA\Header(
header: 'X-RateLimit-Limit',
schema: new OA\Schema(type: 'integer'),
description: 'Number of requests available'
),
]
)]
#[OA\Response(
response: 401,
description: 'Permission denied due to missing or expired token',
content: new OA\JsonContent(ref: new Model(type: \App\Schema\Errors\UnauthorizedErrorSchema::class))
)]
#[OA\Response(
response: 429,
description: 'You are being rate limited',
content: new OA\JsonContent(ref: new Model(type: \App\Schema\Errors\TooManyRequestsErrorSchema::class)),
headers: [
new OA\Header(
header: 'X-RateLimit-Remaining',
schema: new OA\Schema(type: 'integer'),
description: 'Number of requests left until you will be rate limited'
),
new OA\Header(
header: 'X-RateLimit-Retry-After',
schema: new OA\Schema(type: 'integer'),
description: 'Unix timestamp to retry the request after'
),
new OA\Header(
header: 'X-RateLimit-Limit',
schema: new OA\Schema(type: 'integer'),
description: 'Number of requests available'
),
]
)]
#[OA\Tag(name: 'user')]
#[Security(name: 'oauth2', scopes: ['user:profile:read'])]
#[IsGranted('ROLE_OAUTH2_USER:PROFILE:READ')]
public function settings(
UserSettingsManager $manager,
RateLimiterFactory $apiReadLimiter,
): JsonResponse {
$headers = $this->rateLimit($apiReadLimiter);
$dto = $manager->createDto($this->getUserOrThrow());
return new JsonResponse(
$dto,
headers: $headers
);
}
#[OA\Response(
response: 200,
description: 'Returns a paginated list of users',
content: new OA\JsonContent(
type: 'object',
properties: [
new OA\Property(
property: 'items',
type: 'array',
items: new OA\Items(ref: new Model(type: UserResponseDto::class))
),
new OA\Property(
property: 'pagination',
ref: new Model(type: PaginationSchema::class)
),
]
),
headers: [
new OA\Header(
header: 'X-RateLimit-Remaining',
schema: new OA\Schema(type: 'integer'),
description: 'Number of requests left until you will be rate limited'
),
new OA\Header(
header: 'X-RateLimit-Retry-After',
schema: new OA\Schema(type: 'integer'),
description: 'Unix timestamp to retry the request after'
),
new OA\Header(
header: 'X-RateLimit-Limit',
schema: new OA\Schema(type: 'integer'),
description: 'Number of requests available'
),
]
)]
#[OA\Response(
response: 401,
description: 'Permission denied due to missing or expired token',
content: new OA\JsonContent(ref: new Model(type: \App\Schema\Errors\UnauthorizedErrorSchema::class))
)]
#[OA\Response(
response: 429,
description: 'You are being rate limited',
content: new OA\JsonContent(ref: new Model(type: \App\Schema\Errors\TooManyRequestsErrorSchema::class)),
headers: [
new OA\Header(
header: 'X-RateLimit-Remaining',
schema: new OA\Schema(type: 'integer'),
description: 'Number of requests left until you will be rate limited'
),
new OA\Header(
header: 'X-RateLimit-Retry-After',
schema: new OA\Schema(type: 'integer'),
description: 'Unix timestamp to retry the request after'
),
new OA\Header(
header: 'X-RateLimit-Limit',
schema: new OA\Schema(type: 'integer'),
description: 'Number of requests available'
),
]
)]
#[OA\Parameter(
name: 'p',
description: 'Page of users to retrieve',
in: 'query',
schema: new OA\Schema(type: 'integer', default: 1, minimum: 1)
)]
#[OA\Parameter(
name: 'perPage',
description: 'Number of users per page',
in: 'query',
schema: new OA\Schema(
type: 'integer',
default: UserRepository::PER_PAGE,
minimum: self::MIN_PER_PAGE,
maximum: self::MAX_PER_PAGE
)
)]
#[OA\Parameter(
name: 'group',
description: 'What group of users to retrieve',
in: 'query',
schema: new OA\Schema(type: 'string', default: UserRepository::USERS_ALL, enum: UserRepository::USERS_OPTIONS)
)]
#[OA\Tag(name: 'user')]
public function collection(
UserRepository $userRepository,
UserFactory $userFactory,
RateLimiterFactory $apiReadLimiter,
RateLimiterFactory $anonymousApiReadLimiter
): JsonResponse {
$headers = $this->rateLimit($apiReadLimiter, $anonymousApiReadLimiter);
$request = $this->request->getCurrentRequest();
$group = $request->get('group', UserRepository::USERS_ALL);
$users = $userRepository->findWithAboutPaginated(
$this->getPageNb($request),
$group,
$this->constrainPerPage($request->get('perPage', UserRepository::PER_PAGE))
);
$dtos = [];
foreach ($users->getCurrentPageResults() as $value) {
\assert($value instanceof User);
array_push($dtos, $this->serializeUser($userFactory->createDto($value)));
}
return new JsonResponse(
$this->serializePaginated($dtos, $users),
headers: $headers
);
}
#[OA\Response(
response: 200,
description: 'Returns a paginated list of users being followed by given user',
content: new OA\JsonContent(
type: 'object',
properties: [
new OA\Property(
property: 'items',
type: 'array',
items: new OA\Items(ref: new Model(type: UserResponseDto::class))
),
new OA\Property(
property: 'pagination',
ref: new Model(type: PaginationSchema::class)
),
]
),
headers: [
new OA\Header(
header: 'X-RateLimit-Remaining',
schema: new OA\Schema(type: 'integer'),
description: 'Number of requests left until you will be rate limited'
),
new OA\Header(
header: 'X-RateLimit-Retry-After',
schema: new OA\Schema(type: 'integer'),
description: 'Unix timestamp to retry the request after'
),
new OA\Header(
header: 'X-RateLimit-Limit',
schema: new OA\Schema(type: 'integer'),
description: 'Number of requests available'
),
]
)]
#[OA\Response(
response: 401,
description: 'Permission denied due to missing or expired token',
content: new OA\JsonContent(ref: new Model(type: \App\Schema\Errors\UnauthorizedErrorSchema::class))
)]
#[OA\Response(
response: 403,
description: 'This user does not allow others to view the users they follow',
content: new OA\JsonContent(ref: new Model(type: \App\Schema\Errors\ForbiddenErrorSchema::class))
)]
#[OA\Response(
response: 429,
description: 'You are being rate limited',
content: new OA\JsonContent(ref: new Model(type: \App\Schema\Errors\TooManyRequestsErrorSchema::class)),
headers: [
new OA\Header(
header: 'X-RateLimit-Remaining',
schema: new OA\Schema(type: 'integer'),
description: 'Number of requests left until you will be rate limited'
),
new OA\Header(
header: 'X-RateLimit-Retry-After',
schema: new OA\Schema(type: 'integer'),
description: 'Unix timestamp to retry the request after'
),
new OA\Header(
header: 'X-RateLimit-Limit',
schema: new OA\Schema(type: 'integer'),
description: 'Number of requests available'
),
]
)]
#[OA\Parameter(
name: 'user_id',
description: 'User from which to retrieve followed users',
in: 'path',
schema: new OA\Schema(type: 'integer')
)]
#[OA\Parameter(
name: 'p',
description: 'Page of users to retrieve',
in: 'query',
schema: new OA\Schema(type: 'integer', default: 1, minimum: 1)
)]
#[OA\Parameter(
name: 'perPage',
description: 'Number of users per page',
in: 'query',
schema: new OA\Schema(
type: 'integer',
default: UserRepository::PER_PAGE,
minimum: self::MIN_PER_PAGE,
maximum: self::MAX_PER_PAGE
)
)]
#[OA\Tag(name: 'user')]
#[Security(name: 'oauth2', scopes: ['user:follow'])]
#[IsGranted('ROLE_OAUTH2_USER:FOLLOW')]
public function followed(
#[MapEntity(id: 'user_id')]
User $user,
UserRepository $repository,
UserFactory $factory,
RateLimiterFactory $apiReadLimiter,
): JsonResponse {
$headers = $this->rateLimit($apiReadLimiter);
if ($user->getId() !== $this->getUserOrThrow()->getId() && !$user->getShowProfileFollowings()) {
throw new AccessDeniedHttpException('You are not permitted to view the users followed by this user');
}
$request = $this->request->getCurrentRequest();
$users = $repository->findFollowing(
$this->getPageNb($request),
$user,
self::constrainPerPage($request->get('perPage', UserRepository::PER_PAGE))
);
$dtos = [];
foreach ($users->getCurrentPageResults() as $value) {
\assert($value instanceof UserFollow);
array_push($dtos, $this->serializeUser($factory->createDto($value->following)));
}
return new JsonResponse(
$this->serializePaginated($dtos, $users),
headers: $headers
);
}
#[OA\Response(
response: 200,
description: 'Returns a paginated list of users following the given user',
content: new OA\JsonContent(
type: 'object',
properties: [
new OA\Property(
property: 'items',
type: 'array',
items: new OA\Items(ref: new Model(type: UserResponseDto::class))
),
new OA\Property(
property: 'pagination',
ref: new Model(type: PaginationSchema::class)
),
]
),
headers: [
new OA\Header(
header: 'X-RateLimit-Remaining',
schema: new OA\Schema(type: 'integer'),
description: 'Number of requests left until you will be rate limited'
),
new OA\Header(
header: 'X-RateLimit-Retry-After',
schema: new OA\Schema(type: 'integer'),
description: 'Unix timestamp to retry the request after'
),
new OA\Header(
header: 'X-RateLimit-Limit',
schema: new OA\Schema(type: 'integer'),
description: 'Number of requests available'
),
]
)]
#[OA\Response(
response: 401,
description: 'Permission denied due to missing or expired token',
content: new OA\JsonContent(ref: new Model(type: \App\Schema\Errors\UnauthorizedErrorSchema::class))
)]
#[OA\Response(
response: 429,
description: 'You are being rate limited',
content: new OA\JsonContent(ref: new Model(type: \App\Schema\Errors\TooManyRequestsErrorSchema::class)),
headers: [
new OA\Header(
header: 'X-RateLimit-Remaining',
schema: new OA\Schema(type: 'integer'),
description: 'Number of requests left until you will be rate limited'
),
new OA\Header(
header: 'X-RateLimit-Retry-After',
schema: new OA\Schema(type: 'integer'),
description: 'Unix timestamp to retry the request after'
),
new OA\Header(
header: 'X-RateLimit-Limit',
schema: new OA\Schema(type: 'integer'),
description: 'Number of requests available'
),
]
)]
#[OA\Parameter(
name: 'user_id',
description: 'User from which to retrieve following users',
in: 'path',
schema: new OA\Schema(type: 'integer')
)]
#[OA\Parameter(
name: 'p',
description: 'Page of users to retrieve',
in: 'query',
schema: new OA\Schema(type: 'integer', default: 1, minimum: 1)
)]
#[OA\Parameter(
name: 'perPage',
description: 'Number of users per page',
in: 'query',
schema: new OA\Schema(
type: 'integer',
default: UserRepository::PER_PAGE,
minimum: self::MIN_PER_PAGE,
maximum: self::MAX_PER_PAGE
)
)]
#[OA\Tag(name: 'user')]
#[Security(name: 'oauth2', scopes: ['user:follow'])]
#[IsGranted('ROLE_OAUTH2_USER:FOLLOW')]
public function followers(
#[MapEntity(id: 'user_id')]
User $user,
UserRepository $repository,
UserFactory $factory,
RateLimiterFactory $apiReadLimiter,
): JsonResponse {
$headers = $this->rateLimit($apiReadLimiter);
$request = $this->request->getCurrentRequest();
$users = $repository->findFollowers(
$this->getPageNb($request),
$user,
self::constrainPerPage($request->get('perPage', UserRepository::PER_PAGE))
);
$dtos = [];
foreach ($users->getCurrentPageResults() as $value) {
\assert($value instanceof UserFollow);
array_push($dtos, $this->serializeUser($factory->createDto($value->follower)));
}
return new JsonResponse(
$this->serializePaginated($dtos, $users),
headers: $headers
);
}
#[OA\Response(
response: 200,
description: 'Returns a paginated list of users being followed by the current user',
content: new OA\JsonContent(
type: 'object',
properties: [
new OA\Property(
property: 'items',
type: 'array',
items: new OA\Items(ref: new Model(type: UserResponseDto::class))
),
new OA\Property(
property: 'pagination',
ref: new Model(type: PaginationSchema::class)
),
]
),
headers: [
new OA\Header(
header: 'X-RateLimit-Remaining',
schema: new OA\Schema(type: 'integer'),
description: 'Number of requests left until you will be rate limited'
),
new OA\Header(
header: 'X-RateLimit-Retry-After',
schema: new OA\Schema(type: 'integer'),
description: 'Unix timestamp to retry the request after'
),
new OA\Header(
header: 'X-RateLimit-Limit',
schema: new OA\Schema(type: 'integer'),
description: 'Number of requests available'
),
]
)]
#[OA\Response(
response: 401,
description: 'Permission denied due to missing or expired token',
content: new OA\JsonContent(ref: new Model(type: \App\Schema\Errors\UnauthorizedErrorSchema::class))
)]
#[OA\Response(
response: 403,
description: 'This user does not allow others to view the users they follow',
content: new OA\JsonContent(ref: new Model(type: \App\Schema\Errors\ForbiddenErrorSchema::class))
)]
#[OA\Response(
response: 429,
description: 'You are being rate limited',
content: new OA\JsonContent(ref: new Model(type: \App\Schema\Errors\TooManyRequestsErrorSchema::class)),
headers: [
new OA\Header(
header: 'X-RateLimit-Remaining',
schema: new OA\Schema(type: 'integer'),
description: 'Number of requests left until you will be rate limited'
),
new OA\Header(
header: 'X-RateLimit-Retry-After',
schema: new OA\Schema(type: 'integer'),
description: 'Unix timestamp to retry the request after'
),
new OA\Header(
header: 'X-RateLimit-Limit',
schema: new OA\Schema(type: 'integer'),
description: 'Number of requests available'
),
]
)]
#[OA\Parameter(
name: 'p',
description: 'Page of users to retrieve',
in: 'query',
schema: new OA\Schema(type: 'integer', default: 1, minimum: 1)
)]
#[OA\Parameter(
name: 'perPage',
description: 'Number of users per page',
in: 'query',
schema: new OA\Schema(
type: 'integer',
default: UserRepository::PER_PAGE,
minimum: self::MIN_PER_PAGE,
maximum: self::MAX_PER_PAGE
)
)]
#[OA\Tag(name: 'user')]
#[Security(name: 'oauth2', scopes: ['user:follow'])]
#[IsGranted('ROLE_OAUTH2_USER:FOLLOW')]
public function followedByCurrent(
UserRepository $repository,
UserFactory $factory,
RateLimiterFactory $apiReadLimiter,
): JsonResponse {
$headers = $this->rateLimit($apiReadLimiter);
$request = $this->request->getCurrentRequest();
$users = $repository->findFollowing(
$this->getPageNb($request),
$this->getUserOrThrow(),
self::constrainPerPage($request->get('perPage', UserRepository::PER_PAGE))
);
$dtos = [];
foreach ($users->getCurrentPageResults() as $value) {
\assert($value instanceof UserFollow);
array_push($dtos, $this->serializeUser($factory->createDto($value->following)));
}
return new JsonResponse(
$this->serializePaginated($dtos, $users),
headers: $headers
);
}
#[OA\Response(
response: 200,
description: 'Returns a paginated list of users following the current user',
content: new OA\JsonContent(
type: 'object',
properties: [
new OA\Property(
property: 'items',
type: 'array',
items: new OA\Items(ref: new Model(type: UserResponseDto::class))
),
new OA\Property(
property: 'pagination',
ref: new Model(type: PaginationSchema::class)
),
]
),
headers: [
new OA\Header(
header: 'X-RateLimit-Remaining',
schema: new OA\Schema(type: 'integer'),
description: 'Number of requests left until you will be rate limited'
),
new OA\Header(
header: 'X-RateLimit-Retry-After',
schema: new OA\Schema(type: 'integer'),
description: 'Unix timestamp to retry the request after'
),
new OA\Header(
header: 'X-RateLimit-Limit',
schema: new OA\Schema(type: 'integer'),
description: 'Number of requests available'
),
]
)]
#[OA\Response(
response: 401,
description: 'Permission denied due to missing or expired token',
content: new OA\JsonContent(ref: new Model(type: \App\Schema\Errors\UnauthorizedErrorSchema::class))
)]
#[OA\Response(
response: 429,
description: 'You are being rate limited',
content: new OA\JsonContent(ref: new Model(type: \App\Schema\Errors\TooManyRequestsErrorSchema::class)),
headers: [
new OA\Header(
header: 'X-RateLimit-Remaining',
schema: new OA\Schema(type: 'integer'),
description: 'Number of requests left until you will be rate limited'
),
new OA\Header(
header: 'X-RateLimit-Retry-After',
schema: new OA\Schema(type: 'integer'),
description: 'Unix timestamp to retry the request after'
),
new OA\Header(
header: 'X-RateLimit-Limit',
schema: new OA\Schema(type: 'integer'),
description: 'Number of requests available'
),
]
)]
#[OA\Parameter(
name: 'p',
description: 'Page of users to retrieve',
in: 'query',
schema: new OA\Schema(type: 'integer', default: 1, minimum: 1)
)]
#[OA\Parameter(
name: 'perPage',
description: 'Number of users per page',
in: 'query',
schema: new OA\Schema(
type: 'integer',
default: UserRepository::PER_PAGE,
minimum: self::MIN_PER_PAGE,
maximum: self::MAX_PER_PAGE
)
)]
#[OA\Tag(name: 'user')]
#[Security(name: 'oauth2', scopes: ['user:follow'])]
#[IsGranted('ROLE_OAUTH2_USER:FOLLOW')]
public function followersOfCurrent(
UserRepository $repository,
UserFactory $factory,
RateLimiterFactory $apiReadLimiter,
): JsonResponse {
$headers = $this->rateLimit($apiReadLimiter);
$request = $this->request->getCurrentRequest();
$users = $repository->findFollowers(
$this->getPageNb($request),
$this->getUserOrThrow(),
self::constrainPerPage($request->get('perPage', UserRepository::PER_PAGE))
);
$dtos = [];
foreach ($users->getCurrentPageResults() as $value) {
\assert($value instanceof UserFollow);
array_push($dtos, $this->serializeUser($factory->createDto($value->follower)));
}
return new JsonResponse(
$this->serializePaginated($dtos, $users),
headers: $headers
);
}
#[OA\Response(
response: 200,
description: 'Returns a paginated list of users blocked by the current user',
content: new OA\JsonContent(
type: 'object',
properties: [
new OA\Property(
property: 'items',
type: 'array',
items: new OA\Items(ref: new Model(type: UserResponseDto::class))
),
new OA\Property(
property: 'pagination',
ref: new Model(type: PaginationSchema::class)
),
]
),
headers: [
new OA\Header(
header: 'X-RateLimit-Remaining',
schema: new OA\Schema(type: 'integer'),
description: 'Number of requests left until you will be rate limited'
),
new OA\Header(
header: 'X-RateLimit-Retry-After',
schema: new OA\Schema(type: 'integer'),
description: 'Unix timestamp to retry the request after'
),
new OA\Header(
header: 'X-RateLimit-Limit',
schema: new OA\Schema(type: 'integer'),
description: 'Number of requests available'
),
]
)]
#[OA\Response(
response: 401,
description: 'Permission denied due to missing or expired token',
content: new OA\JsonContent(ref: new Model(type: \App\Schema\Errors\UnauthorizedErrorSchema::class))
)]
#[OA\Response(
response: 429,
description: 'You are being rate limited',
content: new OA\JsonContent(ref: new Model(type: \App\Schema\Errors\TooManyRequestsErrorSchema::class)),
headers: [
new OA\Header(
header: 'X-RateLimit-Remaining',
schema: new OA\Schema(type: 'integer'),
description: 'Number of requests left until you will be rate limited'
),
new OA\Header(
header: 'X-RateLimit-Retry-After',
schema: new OA\Schema(type: 'integer'),
description: 'Unix timestamp to retry the request after'
),
new OA\Header(
header: 'X-RateLimit-Limit',
schema: new OA\Schema(type: 'integer'),
description: 'Number of requests available'
),
]
)]
#[OA\Parameter(
name: 'p',
description: 'Page of users to retrieve',
in: 'query',
schema: new OA\Schema(type: 'integer', default: 1, minimum: 1)
)]
#[OA\Parameter(
name: 'perPage',
description: 'Number of users per page',
in: 'query',
schema: new OA\Schema(
type: 'integer',
default: UserRepository::PER_PAGE,
minimum: self::MIN_PER_PAGE,
maximum: self::MAX_PER_PAGE
)
)]
#[OA\Tag(name: 'user')]
#[Security(name: 'oauth2', scopes: ['user:block'])]
#[IsGranted('ROLE_OAUTH2_USER:BLOCK')]
public function blocked(
UserRepository $repository,
UserFactory $factory,
RateLimiterFactory $apiReadLimiter,
): JsonResponse {
$headers = $this->rateLimit($apiReadLimiter);
$request = $this->request->getCurrentRequest();
$users = $repository->findBlockedUsers(
$this->getPageNb($request),
$this->getUserOrThrow(),
self::constrainPerPage($request->get('perPage', UserRepository::PER_PAGE))
);
$dtos = [];
foreach ($users->getCurrentPageResults() as $value) {
\assert($value instanceof UserBlock);
array_push($dtos, $this->serializeUser($factory->createDto($value->blocked)));
}
return new JsonResponse(
$this->serializePaginated($dtos, $users),
headers: $headers
);
}
}