src/Controller/Api/Domain/DomainRetrieveApi.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\Domain;
use App\Controller\Traits\PrivateContentTrait;
use App\Entity\Domain;
use App\Entity\DomainBlock;
use App\Entity\DomainSubscription;
use App\Entity\User;
use App\Factory\DomainFactory;
use App\Kbin\Domain\DTO\DomainDto;
use App\Repository\DomainRepository;
use App\Schema\PaginationSchema;
use App\Service\SearchManager;
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 DomainRetrieveApi extends DomainBaseApi
{
use PrivateContentTrait;
#[OA\Response(
response: 200,
description: 'Returns the Domain',
content: new Model(type: DomainDto::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: 'Domain 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: 'domain_id',
in: 'path',
description: 'The domain to retrieve',
schema: new OA\Schema(type: 'integer'),
)]
#[OA\Tag(name: 'domain')]
public function __invoke(
#[MapEntity(id: 'domain_id')]
Domain $domain,
DomainFactory $factory,
RateLimiterFactory $apiReadLimiter,
RateLimiterFactory $anonymousApiReadLimiter,
): JsonResponse {
$headers = $this->rateLimit($apiReadLimiter, $anonymousApiReadLimiter);
$dto = $factory->createDto($domain);
return new JsonResponse(
$this->serializeDomain($dto),
headers: $headers
);
}
#[OA\Response(
response: 200,
description: 'Returns a paginated list of domains',
content: new OA\JsonContent(
type: 'object',
properties: [
new OA\Property(
property: 'items',
type: 'array',
items: new OA\Items(ref: new Model(type: DomainDto::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 domains to retrieve',
in: 'query',
schema: new OA\Schema(type: 'integer', default: 1, minimum: 1)
)]
#[OA\Parameter(
name: 'perPage',
description: 'Number of domains per page',
in: 'query',
schema: new OA\Schema(
type: 'integer',
default: DomainRepository::PER_PAGE,
minimum: self::MIN_PER_PAGE,
maximum: self::MAX_PER_PAGE
)
)]
#[OA\Parameter(
name: 'q',
description: 'Domain search term',
in: 'query',
schema: new OA\Schema(type: 'string')
)]
#[OA\Tag(name: 'domain')]
public function collection(
DomainRepository $repository,
SearchManager $searchManager,
RateLimiterFactory $apiReadLimiter,
RateLimiterFactory $anonymousApiReadLimiter
): JsonResponse {
$headers = $this->rateLimit($apiReadLimiter, $anonymousApiReadLimiter);
$request = $this->request->getCurrentRequest();
$perPage = self::constrainPerPage($request->get('perPage', DomainRepository::PER_PAGE));
if ($q = $request->get('q')) {
$domains = $searchManager->findDomainsPaginated($q, $this->getPageNb($request), $perPage);
} else {
$domains = $repository->findAllPaginated(
$this->getPageNb($request),
$perPage
);
}
$dtos = [];
foreach ($domains->getCurrentPageResults() as $value) {
\assert($value instanceof Domain);
array_push($dtos, $this->serializeDomain($value));
}
return new JsonResponse(
$this->serializePaginated($dtos, $domains),
headers: $headers
);
}
#[OA\Response(
response: 200,
description: 'Returns a paginated list of subscribed domains',
content: new OA\JsonContent(
type: 'object',
properties: [
new OA\Property(
property: 'items',
type: 'array',
items: new OA\Items(ref: new Model(type: DomainDto::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 domains to retrieve',
in: 'query',
schema: new OA\Schema(type: 'integer', default: 1, minimum: 1)
)]
#[OA\Parameter(
name: 'perPage',
description: 'Number of domains per page',
in: 'query',
schema: new OA\Schema(
type: 'integer',
default: DomainRepository::PER_PAGE,
minimum: self::MIN_PER_PAGE,
maximum: self::MAX_PER_PAGE
)
)]
#[OA\Tag(name: 'domain')]
#[Security(name: 'oauth2', scopes: ['domain:subscribe'])]
#[IsGranted('ROLE_OAUTH2_DOMAIN:SUBSCRIBE')]
public function subscribed(
DomainRepository $repository,
RateLimiterFactory $apiReadLimiter,
): JsonResponse {
$headers = $this->rateLimit($apiReadLimiter);
$request = $this->request->getCurrentRequest();
$domains = $repository->findSubscribedDomains(
$this->getPageNb($request),
$this->getUserOrThrow(),
self::constrainPerPage($request->get('perPage', DomainRepository::PER_PAGE))
);
$dtos = [];
foreach ($domains->getCurrentPageResults() as $value) {
\assert($value instanceof DomainSubscription);
array_push($dtos, $this->serializeDomain($value->domain));
}
return new JsonResponse(
$this->serializePaginated($dtos, $domains),
headers: $headers
);
}
#[OA\Response(
response: 200,
description: 'Returns a paginated list of user\'s subscribed domains',
content: new OA\JsonContent(
type: 'object',
properties: [
new OA\Property(
property: 'items',
type: 'array',
items: new OA\Items(ref: new Model(type: DomainDto::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 their subscribed domains',
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 subscribed domains',
in: 'path',
schema: new OA\Schema(type: 'integer')
)]
#[OA\Parameter(
name: 'p',
description: 'Page of domains to retrieve',
in: 'query',
schema: new OA\Schema(type: 'integer', default: 1, minimum: 1)
)]
#[OA\Parameter(
name: 'perPage',
description: 'Number of domains per page',
in: 'query',
schema: new OA\Schema(
type: 'integer',
default: DomainRepository::PER_PAGE,
minimum: self::MIN_PER_PAGE,
maximum: self::MAX_PER_PAGE
)
)]
#[OA\Tag(name: 'user')]
#[Security(name: 'oauth2', scopes: ['read'])]
#[IsGranted('ROLE_OAUTH2_READ')]
public function subscriptions(
#[MapEntity(id: 'user_id')]
User $user,
DomainRepository $repository,
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 domains followed by this user');
}
$request = $this->request->getCurrentRequest();
$domains = $repository->findSubscribedDomains(
$this->getPageNb($request),
$user,
self::constrainPerPage($request->get('perPage', DomainRepository::PER_PAGE))
);
$dtos = [];
foreach ($domains->getCurrentPageResults() as $value) {
array_push($dtos, $this->serializeDomain($value->domain));
}
return new JsonResponse(
$this->serializePaginated($dtos, $domains),
headers: $headers
);
}
#[OA\Response(
response: 200,
description: 'Returns a paginated list of blocked domains',
content: new OA\JsonContent(
type: 'object',
properties: [
new OA\Property(
property: 'items',
type: 'array',
items: new OA\Items(ref: new Model(type: DomainDto::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 domains to retrieve',
in: 'query',
schema: new OA\Schema(type: 'integer', default: 1, minimum: 1)
)]
#[OA\Parameter(
name: 'perPage',
description: 'Number of domains per page',
in: 'query',
schema: new OA\Schema(
type: 'integer',
default: DomainRepository::PER_PAGE,
minimum: self::MIN_PER_PAGE,
maximum: self::MAX_PER_PAGE
)
)]
#[OA\Tag(name: 'domain')]
#[Security(name: 'oauth2', scopes: ['domain:block'])]
#[IsGranted('ROLE_OAUTH2_DOMAIN:BLOCK')]
public function blocked(
DomainRepository $repository,
RateLimiterFactory $apiReadLimiter,
): JsonResponse {
$headers = $this->rateLimit($apiReadLimiter);
$request = $this->request->getCurrentRequest();
$domains = $repository->findBlockedDomains(
$this->getPageNb($request),
$this->getUserOrThrow(),
self::constrainPerPage($request->get('perPage', DomainRepository::PER_PAGE))
);
$dtos = [];
foreach ($domains->getCurrentPageResults() as $value) {
\assert($value instanceof DomainBlock);
array_push($dtos, $this->serializeDomain($value->domain));
}
return new JsonResponse(
$this->serializePaginated($dtos, $domains),
headers: $headers
);
}
}