text stringlengths 9 39.2M | dir stringlengths 26 295 | lang stringclasses 185
values | created_date timestamp[us] | updated_date timestamp[us] | repo_name stringlengths 1 97 | repo_full_name stringlengths 7 106 | star int64 1k 183k | len_tokens int64 1 13.8M |
|---|---|---|---|---|---|---|---|---|
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Admin\Backups;
use App\Flysystem\ExtendedFilesystemInterface;
use App\Http\Response;
use App\Http\ServerRequest;
use Psr\Http\Message\ResponseInterface;
final class DownloadAction extends AbstractFileAction
{
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
/** @var string $path */
$path = $params['path'];
[$path, $fs] = $this->getFile($path);
/** @var ExtendedFilesystemInterface $fs */
return $response->streamFilesystemFile($fs, $path);
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Admin/Backups/DownloadAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 147 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Admin\CustomAssets;
use App\Assets\AssetTypes;
use App\Container\EnvironmentAwareTrait;
use App\Controller\SingleActionInterface;
use App\Http\Response;
use App\Http\ServerRequest;
use Psr\Http\Message\ResponseInterface;
final class GetCustomAssetAction implements SingleActionInterface
{
use EnvironmentAwareTrait;
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
/** @var string $type */
$type = $params['type'];
$customAsset = AssetTypes::from($type)->createObject($this->environment);
return $response->withJson(
[
'is_uploaded' => $customAsset->isUploaded(),
'url' => $customAsset->getUrl(),
]
);
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Admin/CustomAssets/GetCustomAssetAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 184 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Admin\CustomAssets;
use App\Assets\AssetTypes;
use App\Container\EnvironmentAwareTrait;
use App\Controller\SingleActionInterface;
use App\Entity\Api\Status;
use App\Http\Response;
use App\Http\ServerRequest;
use Psr\Http\Message\ResponseInterface;
final class DeleteCustomAssetAction implements SingleActionInterface
{
use EnvironmentAwareTrait;
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
/** @var string $type */
$type = $params['type'];
$customAsset = AssetTypes::from($type)->createObject($this->environment);
$customAsset->delete();
return $response->withJson(Status::success());
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Admin/CustomAssets/DeleteCustomAssetAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 171 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Admin\Backups;
use App\Controller\SingleActionInterface;
use App\Entity\Enums\StorageLocationTypes;
use App\Entity\Repository\StorageLocationRepository;
use App\Entity\StorageLocation;
use App\Exception\NotFoundException;
use InvalidArgumentException;
abstract class AbstractFileAction implements SingleActionInterface
{
public function __construct(
protected readonly StorageLocationRepository $storageLocationRepo
) {
}
protected function getFile(string $rawPath): array
{
$pathStr = base64_decode($rawPath);
[$storageLocationId, $path] = explode('|', $pathStr);
$storageLocation = $this->storageLocationRepo->findByType(
StorageLocationTypes::Backup,
(int)$storageLocationId
);
if (!($storageLocation instanceof StorageLocation)) {
throw new InvalidArgumentException('Invalid storage location.');
}
$fs = $this->storageLocationRepo->getAdapter($storageLocation)
->getFilesystem();
if (!$fs->fileExists($path)) {
throw NotFoundException::file();
}
return [$path, $fs];
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Admin/Backups/AbstractFileAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 240 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations;
use App\Controller\Api\Traits\HasScheduleDisplay;
use App\Controller\SingleActionInterface;
use App\Entity\ApiGenerator\ScheduleApiGenerator;
use App\Entity\Repository\StationScheduleRepository;
use App\Http\Response;
use App\Http\ServerRequest;
use App\OpenApi;
use App\Radio\AutoDJ\Scheduler;
use App\Utilities\Types;
use Carbon\CarbonImmutable;
use OpenApi\Attributes as OA;
use Psr\Cache\CacheItemPoolInterface;
use Psr\Http\Message\ResponseInterface;
#[OA\Get(
path: '/station/{station_id}/schedule',
operationId: 'getSchedule',
description: 'Return upcoming and currently ongoing schedule entries.',
tags: ['Stations: Schedules'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
new OA\Parameter(
name: 'now',
description: 'The date/time to compare schedule items to. Defaults to the current date and time.',
in: 'query',
required: false,
schema: new OA\Schema(type: 'string')
),
new OA\Parameter(
name: 'rows',
description: 'The number of upcoming/ongoing schedule entries to return. Defaults to 5.',
in: 'query',
required: false,
schema: new OA\Schema(type: 'integer')
),
],
responses: [
new OA\Response(
response: 200,
description: 'Success',
content: new OA\JsonContent(
type: 'array',
items: new OA\Items(ref: '#/components/schemas/Api_StationSchedule')
)
),
new OA\Response(ref: OpenApi::REF_RESPONSE_NOT_FOUND, response: 404),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
)]
final class ScheduleAction implements SingleActionInterface
{
use HasScheduleDisplay;
public function __construct(
private readonly Scheduler $scheduler,
private readonly ScheduleApiGenerator $scheduleApiGenerator,
private readonly StationScheduleRepository $scheduleRepo,
private readonly CacheItemPoolInterface $psr6Cache
) {
}
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
$station = $request->getStation();
$tz = $station->getTimezoneObject();
$queryParams = $request->getQueryParams();
if (isset($queryParams['start'])) {
$dateRange = $this->getDateRange($request, $tz);
$cacheKey = 'api_station_' . $station->getId() . '_schedule_'
. $dateRange->getStart()->format('Ymd') . '-'
. $dateRange->getEnd()->format('Ymd');
$cacheItem = $this->psr6Cache->getItem(urlencode($cacheKey));
if (!$cacheItem->isHit()) {
$nowTz = CarbonImmutable::now($station->getTimezoneObject());
$events = $this->scheduleRepo->getAllScheduledItemsForStation($station);
$cacheItem->set(
$this->getEvents(
$dateRange,
$nowTz,
$this->scheduler,
$events,
[$this->scheduleApiGenerator, '__invoke']
)
);
$cacheItem->expiresAfter(600);
$this->psr6Cache->save($cacheItem);
}
$events = $cacheItem->get();
} else {
if (!empty($queryParams['now'])) {
$now = CarbonImmutable::parse($queryParams['now'], $tz)
->setTimezone($tz);
$cacheKey = 'api_station_' . $station->getId() . '_schedule_' . $now->format('Ymd_gia');
} else {
$now = CarbonImmutable::now($tz);
$cacheKey = 'api_station_' . $station->getId() . '_schedule_upcoming';
}
$cacheItem = $this->psr6Cache->getItem(urlencode($cacheKey));
if (!$cacheItem->isHit()) {
$cacheItem->set($this->scheduleRepo->getUpcomingSchedule($station, $now));
$cacheItem->expiresAfter(60);
$this->psr6Cache->save($cacheItem);
}
$events = $cacheItem->get();
$rows = Types::int($request->getQueryParam('rows'), 5);
$events = array_slice($events, 0, $rows);
}
return $response->withJson($events);
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/ScheduleAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 992 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Admin\CustomAssets;
use App\Assets\AssetTypes;
use App\Container\EnvironmentAwareTrait;
use App\Controller\SingleActionInterface;
use App\Entity\Api\Status;
use App\Http\Response;
use App\Http\ServerRequest;
use App\Media\AlbumArt;
use App\Media\MimeType;
use App\Service\Flow;
use Psr\Http\Message\ResponseInterface;
final class PostCustomAssetAction implements SingleActionInterface
{
use EnvironmentAwareTrait;
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
/** @var string $type */
$type = $params['type'];
$customAsset = AssetTypes::from($type)->createObject($this->environment);
$flowResponse = Flow::process($request, $response);
if ($flowResponse instanceof ResponseInterface) {
return $flowResponse;
}
$imageContents = $flowResponse->readAndDeleteUploadedFile();
$customAsset->upload(
AlbumArt::getImageManager()->read($imageContents),
MimeType::getMimeTypeDetector()->detectMimeTypeFromBuffer($imageContents) ?? 'image/jpeg'
);
return $response->withJson(Status::success());
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Admin/CustomAssets/PostCustomAssetAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 274 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations;
use App\Controller\Api\Traits\CanSearchResults;
use App\Controller\Api\Traits\CanSortResults;
use App\Entity\Repository\StationMountRepository;
use App\Entity\StationMount;
use App\Http\Response;
use App\Http\Router;
use App\Http\ServerRequest;
use App\OpenApi;
use App\Radio\Adapters;
use App\Service\Flow\UploadedFile;
use OpenApi\Attributes as OA;
use Psr\Http\Message\ResponseInterface;
use Symfony\Component\Serializer\Serializer;
use Symfony\Component\Validator\Validator\ValidatorInterface;
/** @extends AbstractStationApiCrudController<StationMount> */
#[
OA\Get(
path: '/station/{station_id}/mounts',
operationId: 'getStationMounts',
description: 'List all current mount points.',
security: OpenApi::API_KEY_SECURITY,
tags: ['Stations: Mount Points'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
],
responses: [
new OA\Response(
response: 200,
description: 'Success',
content: new OA\JsonContent(
type: 'array',
items: new OA\Items(ref: '#/components/schemas/StationMount')
)
),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
),
OA\Post(
path: '/station/{station_id}/mounts',
operationId: 'addMount',
description: 'Create a new mount point.',
security: OpenApi::API_KEY_SECURITY,
requestBody: new OA\RequestBody(
content: new OA\JsonContent(ref: '#/components/schemas/StationMount')
),
tags: ['Stations: Mount Points'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
],
responses: [
new OA\Response(
response: 200,
description: 'Success',
content: new OA\JsonContent(ref: '#/components/schemas/StationMount')
),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
),
OA\Get(
path: '/station/{station_id}/mount/{id}',
operationId: 'getMount',
description: 'Retrieve details for a single mount point.',
security: OpenApi::API_KEY_SECURITY,
tags: ['Stations: Mount Points'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
new OA\Parameter(
name: 'id',
description: 'Streamer ID',
in: 'path',
required: true,
schema: new OA\Schema(type: 'integer', format: 'int64')
),
],
responses: [
new OA\Response(
response: 200,
description: 'Success',
content: new OA\JsonContent(ref: '#/components/schemas/StationMount')
),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_NOT_FOUND, response: 404),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
),
OA\Put(
path: '/station/{station_id}/mount/{id}',
operationId: 'editMount',
description: 'Update details of a single mount point.',
security: OpenApi::API_KEY_SECURITY,
requestBody: new OA\RequestBody(
content: new OA\JsonContent(ref: '#/components/schemas/StationMount')
),
tags: ['Stations: Mount Points'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
new OA\Parameter(
name: 'id',
description: 'Streamer ID',
in: 'path',
required: true,
schema: new OA\Schema(type: 'integer', format: 'int64')
),
],
responses: [
new OA\Response(ref: OpenApi::REF_RESPONSE_SUCCESS, response: 200),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_NOT_FOUND, response: 404),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
),
OA\Delete(
path: '/station/{station_id}/mount/{id}',
operationId: 'deleteMount',
description: 'Delete a single mount point.',
security: OpenApi::API_KEY_SECURITY,
tags: ['Stations: Mount Points'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
new OA\Parameter(
name: 'id',
description: 'StationMount ID',
in: 'path',
required: true,
schema: new OA\Schema(type: 'integer', format: 'int64')
),
],
responses: [
new OA\Response(ref: OpenApi::REF_RESPONSE_SUCCESS, response: 200),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_NOT_FOUND, response: 404),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
)
]
final class MountsController extends AbstractStationApiCrudController
{
use CanSortResults;
use CanSearchResults;
protected string $entityClass = StationMount::class;
protected string $resourceRouteName = 'api:stations:mount';
public function __construct(
Serializer $serializer,
ValidatorInterface $validator,
private readonly StationMountRepository $mountRepo,
private readonly Adapters $adapters,
) {
parent::__construct($serializer, $validator);
}
public function listAction(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
$station = $request->getStation();
$qb = $this->em->createQueryBuilder()
->select('e')
->from(StationMount::class, 'e')
->where('e.station = :station')
->setParameter('station', $station);
$qb = $this->sortQueryBuilder(
$request,
$qb,
[
'display_name' => 'e.display_name',
'enable_autodj' => 'e.enable_autodj',
],
'e.display_name'
);
$qb = $this->searchQueryBuilder(
$request,
$qb,
[
'e.name',
'e.display_name',
]
);
return $this->listPaginatedFromQuery($request, $response, $qb->getQuery());
}
protected function viewRecord(object $record, ServerRequest $request): mixed
{
assert($record instanceof StationMount);
$return = parent::viewRecord($record, $request);
$station = $request->getStation();
$router = $request->getRouter();
$frontend = $this->adapters->getFrontendAdapter($station);
$return['links']['intro'] = $router->fromHere(
routeName: 'api:stations:mounts:intro',
routeParams: ['id' => $record->getId()],
absolute: true
);
if (null !== $frontend) {
$return['links']['listen'] = (string)Router::resolveUri(
$router->getBaseUrl(),
$frontend->getUrlForMount($station, $record),
true
);
}
return $return;
}
protected function createRecord(ServerRequest $request, array $data): object
{
$record = parent::createRecord($request, $data);
if (!empty($data['intro_file'])) {
$station = $request->getStation();
$intro = UploadedFile::fromArray($data['intro_file'], $station->getRadioTempDir());
$this->mountRepo->setIntro($record, $intro);
}
return $record;
}
protected function deleteRecord(object $record): void
{
parent::deleteRecord($record);
$this->mountRepo->destroy($record);
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/MountsController.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 1,812 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations;
use App\Controller\Api\Traits\CanSearchResults;
use App\Controller\Api\Traits\CanSortResults;
use App\Entity\Repository\StationScheduleRepository;
use App\Entity\Repository\StationStreamerRepository;
use App\Entity\StationSchedule;
use App\Entity\StationStreamer;
use App\Http\Response;
use App\Http\ServerRequest;
use App\OpenApi;
use App\Radio\AutoDJ\Scheduler;
use App\Service\Flow\UploadedFile;
use Carbon\CarbonInterface;
use InvalidArgumentException;
use OpenApi\Attributes as OA;
use Psr\Http\Message\ResponseInterface;
use Symfony\Component\Serializer\Serializer;
use Symfony\Component\Validator\Validator\ValidatorInterface;
/** @extends AbstractScheduledEntityController<StationStreamer> */
#[
OA\Get(
path: '/station/{station_id}/streamers',
operationId: 'getStreamers',
description: 'List all current Streamer/DJ accounts for the specified station.',
security: OpenApi::API_KEY_SECURITY,
tags: ['Stations: Streamers/DJs'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
],
responses: [
new OA\Response(
response: 200,
description: 'Success',
content: new OA\JsonContent(
type: 'array',
items: new OA\Items(ref: '#/components/schemas/StationStreamer')
)
),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_NOT_FOUND, response: 404),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
),
OA\Post(
path: '/station/{station_id}/streamers',
operationId: 'addStreamer',
description: 'Create a new Streamer/DJ account.',
security: OpenApi::API_KEY_SECURITY,
requestBody: new OA\RequestBody(
content: new OA\JsonContent(ref: '#/components/schemas/StationStreamer')
),
tags: ['Stations: Streamers/DJs'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
],
responses: [
new OA\Response(
response: 200,
description: 'Success',
content: new OA\JsonContent(ref: '#/components/schemas/StationStreamer')
),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_NOT_FOUND, response: 404),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
),
OA\Get(
path: '/station/{station_id}/streamer/{id}',
operationId: 'getStreamer',
description: 'Retrieve details for a single Streamer/DJ account.',
security: OpenApi::API_KEY_SECURITY,
tags: ['Stations: Streamers/DJs'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
new OA\Parameter(
name: 'id',
description: 'Streamer ID',
in: 'path',
required: true,
schema: new OA\Schema(type: 'integer', format: 'int64')
),
],
responses: [
new OA\Response(
response: 200,
description: 'Success',
content: new OA\JsonContent(ref: '#/components/schemas/StationStreamer')
),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_NOT_FOUND, response: 404),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
),
OA\Put(
path: '/station/{station_id}/streamer/{id}',
operationId: 'editStreamer',
description: 'Update details of a single Streamer/DJ account.',
security: OpenApi::API_KEY_SECURITY,
requestBody: new OA\RequestBody(
content: new OA\JsonContent(ref: '#/components/schemas/StationStreamer')
),
tags: ['Stations: Streamers/DJs'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
new OA\Parameter(
name: 'id',
description: 'Streamer ID',
in: 'path',
required: true,
schema: new OA\Schema(type: 'integer', format: 'int64')
),
],
responses: [
new OA\Response(ref: OpenApi::REF_RESPONSE_SUCCESS, response: 200),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_NOT_FOUND, response: 404),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
),
OA\Delete(
path: '/station/{station_id}/streamer/{id}',
operationId: 'deleteStreamer',
description: 'Delete a single Streamer/DJ account.',
security: OpenApi::API_KEY_SECURITY,
tags: ['Stations: Streamers/DJs'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
new OA\Parameter(
name: 'id',
description: 'StationStreamer ID',
in: 'path',
required: true,
schema: new OA\Schema(type: 'integer', format: 'int64')
),
],
responses: [
new OA\Response(ref: OpenApi::REF_RESPONSE_SUCCESS, response: 200),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_NOT_FOUND, response: 404),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
)
]
final class StreamersController extends AbstractScheduledEntityController
{
use CanSortResults;
use CanSearchResults;
protected string $entityClass = StationStreamer::class;
protected string $resourceRouteName = 'api:stations:streamer';
public function __construct(
private readonly StationStreamerRepository $streamerRepo,
StationScheduleRepository $scheduleRepo,
Scheduler $scheduler,
Serializer $serializer,
ValidatorInterface $validator
) {
parent::__construct($scheduleRepo, $scheduler, $serializer, $validator);
}
public function listAction(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
$station = $request->getStation();
$qb = $this->em->createQueryBuilder()
->select('e')
->from(StationStreamer::class, 'e')
->where('e.station = :station')
->setParameter('station', $station);
$qb = $this->sortQueryBuilder(
$request,
$qb,
[
'display_name' => 'e.display_name',
'streamer_username' => 'e.streamer_username',
],
'e.streamer_username'
);
$qb = $this->searchQueryBuilder(
$request,
$qb,
[
'e.streamer_username',
'e.display_name',
]
);
return $this->listPaginatedFromQuery($request, $response, $qb->getQuery());
}
protected function createRecord(ServerRequest $request, array $data): object
{
$station = $request->getStation();
/** @var StationStreamer $record */
$record = $this->editRecord(
$data,
new StationStreamer($station)
);
if (!empty($data['artwork_file'])) {
$artwork = UploadedFile::fromArray($data['artwork_file'], $station->getRadioTempDir());
$this->streamerRepo->writeArtwork(
$record,
$artwork->readAndDeleteUploadedFile()
);
$this->em->persist($record);
$this->em->flush();
}
return $record;
}
public function scheduleAction(
ServerRequest $request,
Response $response
): ResponseInterface {
$station = $request->getStation();
$scheduleItems = $this->em->createQuery(
<<<'DQL'
SELECT ssc, sst
FROM App\Entity\StationSchedule ssc
LEFT JOIN ssc.streamer sst
WHERE sst.station = :station AND sst.is_active = 1
DQL
)->setParameter('station', $station)
->execute();
return $this->renderEvents(
$request,
$response,
$scheduleItems,
function (
StationSchedule $scheduleItem,
CarbonInterface $start,
CarbonInterface $end
) use (
$request,
$station
) {
/** @var StationStreamer $streamer */
$streamer = $scheduleItem->getStreamer();
return [
'id' => $streamer->getId(),
'title' => $streamer->getDisplayName(),
'start' => $start->toIso8601String(),
'end' => $end->toIso8601String(),
'edit_url' => $request->getRouter()->named(
'api:stations:streamer',
['station_id' => $station->getId(), 'id' => $streamer->getId()]
),
];
}
);
}
protected function viewRecord(object $record, ServerRequest $request): array
{
assert($record instanceof StationStreamer);
$return = parent::viewRecord($record, $request);
$isInternal = $request->isInternal();
$router = $request->getRouter();
$return['has_custom_art'] = (0 !== $record->getArtUpdatedAt());
$routeParams = [
'id' => $record->getIdRequired(),
];
if ($return['has_custom_art']) {
$routeParams['timestamp'] = $record->getArtUpdatedAt();
}
$return['art'] = $router->fromHere(
routeName: 'api:stations:streamer:art',
routeParams: $routeParams,
absolute: !$isInternal
);
$return['links']['broadcasts'] = $router->fromHere(
routeName: 'api:stations:streamer:broadcasts',
routeParams: ['id' => $record->getId()],
absolute: !$isInternal
);
$return['links']['broadcasts_batch'] = $router->fromHere(
routeName: 'api:stations:streamer:broadcasts:batch',
routeParams: ['id' => $record->getId()],
absolute: !$isInternal
);
$return['links']['art'] = $router->fromHere(
routeName: 'api:stations:streamer:art-internal',
routeParams: ['id' => $record->getId()],
absolute: !$isInternal
);
return $return;
}
protected function deleteRecord(object $record): void
{
if (!($record instanceof StationStreamer)) {
throw new InvalidArgumentException(sprintf('Record must be an instance of %s.', $this->entityClass));
}
$this->streamerRepo->delete($record);
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/StreamersController.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 2,442 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations;
use App\Controller\Api\Traits\HasLogViewer;
use App\Controller\SingleActionInterface;
use App\Entity\Station;
use App\Exception;
use App\Http\Response;
use App\Http\ServerRequest;
use App\Radio\Enums\BackendAdapters;
use App\Radio\Enums\FrontendAdapters;
use Psr\Http\Message\ResponseInterface;
final class LogsAction implements SingleActionInterface
{
use HasLogViewer;
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
/** @var string|null $log */
$log = $params['log'] ?? null;
$station = $request->getStation();
$logPaths = $this->getStationLogs($station);
if (null === $log) {
$router = $request->getRouter();
return $response->withJson(
[
'logs' => array_map(
function (string $key, array $row) use ($router, $station) {
$row['key'] = $key;
$row['links'] = [
'self' => $router->named(
'api:stations:log',
[
'station_id' => $station->getIdRequired(),
'log' => $key,
]
),
];
return $row;
},
array_keys($logPaths),
array_values($logPaths)
),
]
);
}
if (!isset($logPaths[$log])) {
throw new Exception('Invalid log file specified.');
}
$frontendConfig = $station->getFrontendConfig();
$filteredTerms = [
$station->getAdapterApiKey(),
$frontendConfig->getAdminPassword(),
$frontendConfig->getRelayPassword(),
$frontendConfig->getSourcePassword(),
$frontendConfig->getStreamerPassword(),
];
return $this->streamLogToResponse(
$request,
$response,
$logPaths[$log]['path'],
$logPaths[$log]['tail'] ?? true,
$filteredTerms
);
}
private function getStationLogs(Station $station): array
{
$logPaths = [];
$stationConfigDir = $station->getRadioConfigDir();
$logPaths['station_nginx'] = [
'name' => __('Station Nginx Configuration'),
'path' => $stationConfigDir . '/nginx.conf',
'tail' => false,
];
if (BackendAdapters::Liquidsoap === $station->getBackendType()) {
$logPaths['liquidsoap_log'] = [
'name' => __('Liquidsoap Log'),
'path' => $stationConfigDir . '/liquidsoap.log',
'tail' => true,
];
$logPaths['liquidsoap_liq'] = [
'name' => __('Liquidsoap Configuration'),
'path' => $stationConfigDir . '/liquidsoap.liq',
'tail' => false,
];
}
switch ($station->getFrontendType()) {
case FrontendAdapters::Icecast:
$logPaths['icecast_access_log'] = [
'name' => __('Icecast Access Log'),
'path' => $stationConfigDir . '/icecast_access.log',
'tail' => true,
];
$logPaths['icecast_error_log'] = [
'name' => __('Icecast Error Log'),
'path' => $stationConfigDir . '/icecast.log',
'tail' => true,
];
$logPaths['icecast_xml'] = [
'name' => __('Icecast Configuration'),
'path' => $stationConfigDir . '/icecast.xml',
'tail' => false,
];
break;
case FrontendAdapters::Shoutcast:
$logPaths['shoutcast_log'] = [
'name' => __('Shoutcast Log'),
'path' => $stationConfigDir . '/shoutcast.log',
'tail' => true,
];
$logPaths['shoutcast_conf'] = [
'name' => __('Shoutcast Configuration'),
'path' => $stationConfigDir . '/sc_serv.conf',
'tail' => false,
];
break;
case FrontendAdapters::Remote:
// Noop
break;
}
return $logPaths;
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/LogsAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 953 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations;
use App\Container\EntityManagerAwareTrait;
use App\Entity\ApiGenerator\StationApiGenerator;
use App\Entity\Station;
use App\Http\Response;
use App\Http\ServerRequest;
use App\OpenApi;
use OpenApi\Attributes as OA;
use Psr\Http\Message\ResponseInterface;
#[
OA\Get(
path: '/stations',
operationId: 'getStations',
description: 'Returns a list of stations.',
tags: ['Stations: General'],
parameters: [],
responses: [
new OA\Response(
response: 200,
description: 'Success',
content: new OA\JsonContent(
type: 'array',
items: new OA\Items(ref: '#/components/schemas/Api_NowPlaying_Station')
)
),
]
),
OA\Get(
path: '/station/{station_id}',
operationId: 'getStation',
description: 'Return information about a single station.',
tags: ['Stations: General'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
],
responses: [
new OA\Response(
response: 200,
description: 'Success',
content: new OA\JsonContent(ref: '#/components/schemas/Api_NowPlaying_Station')
),
new OA\Response(ref: OpenApi::REF_RESPONSE_NOT_FOUND, response: 404),
]
)
]
final class IndexController
{
use EntityManagerAwareTrait;
public function __construct(
private readonly StationApiGenerator $stationApiGenerator
) {
}
public function indexAction(
ServerRequest $request,
Response $response
): ResponseInterface {
$station = $request->getStation();
$apiResponse = ($this->stationApiGenerator)($station);
$apiResponse->resolveUrls($request->getRouter()->getBaseUrl());
return $response->withJson($apiResponse);
}
public function listAction(
ServerRequest $request,
Response $response
): ResponseInterface {
$stationsRaw = $this->em->getRepository(Station::class)
->findBy(['is_enabled' => 1]);
$stations = [];
foreach ($stationsRaw as $row) {
/** @var Station $row */
$apiRow = ($this->stationApiGenerator)($row);
$apiRow->resolveUrls($request->getRouter()->getBaseUrl());
if ($apiRow->is_public) {
$stations[] = $apiRow;
}
}
return $response->withJson($stations);
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/IndexController.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 567 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations;
use App\Controller\Api\Traits\CanSearchResults;
use App\Controller\Api\Traits\CanSortResults;
use App\Entity\StationWebhook;
use App\Http\Response;
use App\Http\ServerRequest;
use App\OpenApi;
use OpenApi\Attributes as OA;
use Psr\Http\Message\ResponseInterface;
/** @extends AbstractStationApiCrudController<StationWebhook> */
#[
OA\Get(
path: '/station/{station_id}/webhooks',
operationId: 'getWebhooks',
description: 'List all current web hooks.',
security: OpenApi::API_KEY_SECURITY,
tags: ['Stations: Web Hooks'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
],
responses: [
new OA\Response(
response: 200,
description: 'Success',
content: new OA\JsonContent(
type: 'array',
items: new OA\Items(ref: '#/components/schemas/StationWebhook')
)
),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_NOT_FOUND, response: 404),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
),
OA\Post(
path: '/station/{station_id}/webhooks',
operationId: 'addWebhook',
description: 'Create a new web hook.',
security: OpenApi::API_KEY_SECURITY,
requestBody: new OA\RequestBody(
content: new OA\JsonContent(ref: '#/components/schemas/StationWebhook')
),
tags: ['Stations: Web Hooks'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
],
responses: [
new OA\Response(
response: 200,
description: 'Success',
content: new OA\JsonContent(ref: '#/components/schemas/StationWebhook')
),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_NOT_FOUND, response: 404),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
),
OA\Get(
path: '/station/{station_id}/webhook/{id}',
operationId: 'getWebhook',
description: 'Retrieve details for a single web hook.',
security: OpenApi::API_KEY_SECURITY,
tags: ['Stations: Web Hooks'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
new OA\Parameter(
name: 'id',
description: 'Web Hook ID',
in: 'path',
required: true,
schema: new OA\Schema(type: 'integer', format: 'int64')
),
],
responses: [
new OA\Response(
response: 200,
description: 'Success',
content: new OA\JsonContent(ref: '#/components/schemas/StationWebhook')
),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_NOT_FOUND, response: 404),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
),
OA\Put(
path: '/station/{station_id}/webhook/{id}',
operationId: 'editWebhook',
description: 'Update details of a single web hook.',
security: OpenApi::API_KEY_SECURITY,
requestBody: new OA\RequestBody(
content: new OA\JsonContent(ref: '#/components/schemas/StationWebhook')
),
tags: ['Stations: Web Hooks'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
new OA\Parameter(
name: 'id',
description: 'Web Hook ID',
in: 'path',
required: true,
schema: new OA\Schema(type: 'integer', format: 'int64')
),
],
responses: [
new OA\Response(ref: OpenApi::REF_RESPONSE_SUCCESS, response: 200),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_NOT_FOUND, response: 404),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
),
OA\Delete(
path: '/station/{station_id}/webhook/{id}',
operationId: 'deleteWebhook',
description: 'Delete a single web hook relay.',
security: OpenApi::API_KEY_SECURITY,
tags: ['Stations: Web Hooks'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
new OA\Parameter(
name: 'id',
description: 'Web Hook ID',
in: 'path',
required: true,
schema: new OA\Schema(type: 'integer', format: 'int64')
),
],
responses: [
new OA\Response(ref: OpenApi::REF_RESPONSE_SUCCESS, response: 200),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_NOT_FOUND, response: 404),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
)
]
final class WebhooksController extends AbstractStationApiCrudController
{
use CanSortResults;
use CanSearchResults;
protected string $entityClass = StationWebhook::class;
protected string $resourceRouteName = 'api:stations:webhook';
/**
* @param ServerRequest $request
* @param Response $response
*/
public function listAction(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
$station = $request->getStation();
$qb = $this->em->createQueryBuilder()
->select('e')
->from(StationWebhook::class, 'e')
->where('e.station = :station')
->setParameter('station', $station);
$qb = $this->sortQueryBuilder(
$request,
$qb,
[
'name' => 'e.name',
],
'e.name'
);
$qb = $this->searchQueryBuilder(
$request,
$qb,
[
'e.name',
]
);
return $this->listPaginatedFromQuery($request, $response, $qb->getQuery());
}
protected function viewRecord(object $record, ServerRequest $request): mixed
{
assert($record instanceof StationWebhook);
$return = $this->toArray($record);
$isInternal = $request->isInternal();
$router = $request->getRouter();
$return['links'] = [
'self' => $router->fromHere(
routeName: $this->resourceRouteName,
routeParams: ['id' => $record->getIdRequired()],
absolute: !$isInternal
),
'toggle' => $router->fromHere(
routeName: 'api:stations:webhook:toggle',
routeParams: ['id' => $record->getIdRequired()],
absolute: !$isInternal
),
'test' => $router->fromHere(
routeName: 'api:stations:webhook:test',
routeParams: ['id' => $record->getIdRequired()],
absolute: !$isInternal
),
];
return $return;
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/WebhooksController.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 1,663 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations;
use App\Controller\Api\Traits\CanSearchResults;
use App\Controller\Api\Traits\CanSortResults;
use App\Entity\Enums\PlaylistOrders;
use App\Entity\Enums\PlaylistSources;
use App\Entity\StationPlaylist;
use App\Entity\StationSchedule;
use App\Http\Response;
use App\Http\ServerRequest;
use App\OpenApi;
use Carbon\CarbonInterface;
use Doctrine\ORM\AbstractQuery;
use OpenApi\Attributes as OA;
use Psr\Http\Message\ResponseInterface;
use Symfony\Component\Serializer\Normalizer\AbstractNormalizer;
/** @extends AbstractScheduledEntityController<StationPlaylist> */
#[
OA\Get(
path: '/station/{station_id}/playlists',
operationId: 'getPlaylists',
description: 'List all current playlists.',
security: OpenApi::API_KEY_SECURITY,
tags: ['Stations: Playlists'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
],
responses: [
new OA\Response(
response: 200,
description: 'Success',
content: new OA\JsonContent(
type: 'array',
items: new OA\Items(ref: '#/components/schemas/StationPlaylist')
)
),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
),
OA\Post(
path: '/station/{station_id}/playlists',
operationId: 'addPlaylist',
description: 'Create a new playlist.',
security: OpenApi::API_KEY_SECURITY,
requestBody: new OA\RequestBody(
content: new OA\JsonContent(ref: '#/components/schemas/StationPlaylist')
),
tags: ['Stations: Playlists'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
],
responses: [
new OA\Response(
response: 200,
description: 'Success',
content: new OA\JsonContent(ref: '#/components/schemas/StationPlaylist')
),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
),
OA\Get(
path: '/station/{station_id}/playlist/{id}',
operationId: 'getPlaylist',
description: 'Retrieve details for a single playlist.',
security: OpenApi::API_KEY_SECURITY,
tags: ['Stations: Playlists'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
new OA\Parameter(
name: 'id',
description: 'Playlist ID',
in: 'path',
required: true,
schema: new OA\Schema(type: 'integer', format: 'int64')
),
],
responses: [
new OA\Response(
response: 200,
description: 'Success',
content: new OA\JsonContent(ref: '#/components/schemas/StationPlaylist')
),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_NOT_FOUND, response: 404),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
),
OA\Put(
path: '/station/{station_id}/playlist/{id}',
operationId: 'editPlaylist',
description: 'Update details of a single playlist.',
security: OpenApi::API_KEY_SECURITY,
requestBody: new OA\RequestBody(
content: new OA\JsonContent(ref: '#/components/schemas/StationPlaylist')
),
tags: ['Stations: Playlists'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
new OA\Parameter(
name: 'id',
description: 'Playlist ID',
in: 'path',
required: true,
schema: new OA\Schema(type: 'integer', format: 'int64')
),
],
responses: [
new OA\Response(ref: OpenApi::REF_RESPONSE_SUCCESS, response: 200),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_NOT_FOUND, response: 404),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
),
OA\Delete(
path: '/station/{station_id}/playlist/{id}',
operationId: 'deletePlaylist',
description: 'Delete a single playlist relay.',
security: OpenApi::API_KEY_SECURITY,
tags: ['Stations: Playlists'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
new OA\Parameter(
name: 'id',
description: 'Playlist ID',
in: 'path',
required: true,
schema: new OA\Schema(type: 'integer', format: 'int64')
),
],
responses: [
new OA\Response(ref: OpenApi::REF_RESPONSE_SUCCESS, response: 200),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_NOT_FOUND, response: 404),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
)
]
final class PlaylistsController extends AbstractScheduledEntityController
{
use CanSortResults;
use CanSearchResults;
protected string $entityClass = StationPlaylist::class;
protected string $resourceRouteName = 'api:stations:playlist';
public function listAction(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
$station = $request->getStation();
$qb = $this->em->createQueryBuilder()
->select('sp, spc')
->from(StationPlaylist::class, 'sp')
->leftJoin('sp.schedule_items', 'spc')
->where('sp.station = :station')
->setParameter('station', $station);
$qb = $this->sortQueryBuilder(
$request,
$qb,
[
'name' => 'sp.name',
],
'sp.name'
);
$qb = $this->searchQueryBuilder(
$request,
$qb,
[
'sp.name',
]
);
return $this->listPaginatedFromQuery($request, $response, $qb->getQuery());
}
/**
* Controller used to respond to AJAX requests from the playlist "Schedule View".
*
* @param ServerRequest $request
* @param Response $response
*/
public function scheduleAction(
ServerRequest $request,
Response $response
): ResponseInterface {
$station = $request->getStation();
$scheduleItems = $this->em->createQuery(
<<<'DQL'
SELECT ssc, sp
FROM App\Entity\StationSchedule ssc
JOIN ssc.playlist sp
WHERE sp.station = :station AND sp.is_jingle = 0 AND sp.is_enabled = 1
DQL
)->setParameter('station', $station)
->execute();
return $this->renderEvents(
$request,
$response,
$scheduleItems,
function (
StationSchedule $scheduleItem,
CarbonInterface $start,
CarbonInterface $end
) use (
$request,
$station
) {
/** @var StationPlaylist $playlist */
$playlist = $scheduleItem->getPlaylist();
return [
'id' => $playlist->getId(),
'title' => $playlist->getName(),
'start' => $start->toIso8601String(),
'end' => $end->toIso8601String(),
'edit_url' => $request->getRouter()->named(
'api:stations:playlist',
['station_id' => $station->getId(), 'id' => $playlist->getId()]
),
];
}
);
}
/**
* @return mixed[]
*/
protected function viewRecord(object $record, ServerRequest $request): array
{
assert($record instanceof StationPlaylist);
$return = $this->toArray($record);
/** @var array{num_songs: int, total_length: string} $songTotals */
$songTotals = $this->em->createQuery(
<<<'DQL'
SELECT count(sm.id) AS num_songs, sum(sm.length) AS total_length
FROM App\Entity\StationMedia sm
JOIN sm.playlists spm
WHERE spm.playlist = :playlist
DQL
)->setParameter('playlist', $record)
->getSingleResult(AbstractQuery::HYDRATE_SCALAR);
$return['short_name'] = StationPlaylist::generateShortName($return['name']);
$return['num_songs'] = $songTotals['num_songs'];
$return['total_length'] = round((float)$songTotals['total_length']);
$isInternal = $request->isInternal();
$router = $request->getRouter();
$return['links'] = [
'self' => $router->fromHere(
routeName: $this->resourceRouteName,
routeParams: ['id' => $record->getId()],
absolute: !$isInternal
),
'toggle' => $router->fromHere(
routeName: 'api:stations:playlist:toggle',
routeParams: ['id' => $record->getId()],
absolute: !$isInternal
),
'clone' => $router->fromHere(
routeName: 'api:stations:playlist:clone',
routeParams: ['id' => $record->getId()],
absolute: !$isInternal
),
];
if (PlaylistSources::Songs === $record->getSource()) {
if (PlaylistOrders::Sequential === $record->getOrder()) {
$return['links']['order'] = $router->fromHere(
routeName: 'api:stations:playlist:order',
routeParams: ['id' => $record->getId()],
absolute: !$isInternal
);
}
if (PlaylistOrders::Random !== $record->getOrder()) {
$return['links']['queue'] = $router->fromHere(
routeName: 'api:stations:playlist:queue',
routeParams: ['id' => $record->getId()],
absolute: !$isInternal
);
}
$return['links']['import'] = $router->fromHere(
routeName: 'api:stations:playlist:import',
routeParams: ['id' => $record->getId()],
absolute: !$isInternal
);
$return['links']['reshuffle'] = $router->fromHere(
routeName: 'api:stations:playlist:reshuffle',
routeParams: ['id' => $record->getId()],
absolute: !$isInternal
);
$return['links']['applyto'] = $router->fromHere(
routeName: 'api:stations:playlist:applyto',
routeParams: ['id' => $record->getId()],
absolute: !$isInternal
);
$return['links']['empty'] = $router->fromHere(
routeName: 'api:stations:playlist:empty',
routeParams: ['id' => $record->getId()],
absolute: !$isInternal
);
}
foreach (['pls', 'm3u'] as $format) {
$return['links']['export'][$format] = $router->fromHere(
routeName: 'api:stations:playlist:export',
routeParams: ['id' => $record->getId(), 'format' => $format],
absolute: !$isInternal
);
}
return $return;
}
/**
* @return mixed[]
*/
protected function toArray(object $record, array $context = []): array
{
return parent::toArray(
$record,
array_merge(
$context,
[
AbstractNormalizer::IGNORED_ATTRIBUTES => ['queue'],
]
)
);
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/PlaylistsController.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 2,647 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations;
use App\Controller\Api\AbstractApiCrudController;
use App\Entity\Station;
use App\Http\Response;
use App\Http\ServerRequest;
use Psr\Http\Message\ResponseInterface;
use Symfony\Component\Serializer\Normalizer\AbstractNormalizer;
/**
* @template TEntity as object
* @extends AbstractApiCrudController<TEntity>
*/
abstract class AbstractStationApiCrudController extends AbstractApiCrudController
{
public function listAction(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
$station = $this->getStation($request);
$query = $this->em->createQuery(
'SELECT e
FROM ' . $this->entityClass . ' e
WHERE e.station = :station'
)
->setParameter('station', $station);
return $this->listPaginatedFromQuery($request, $response, $query);
}
/**
* @return TEntity
*/
protected function createRecord(ServerRequest $request, array $data): object
{
return $this->editRecord(
$data,
null,
[
AbstractNormalizer::DEFAULT_CONSTRUCTOR_ARGUMENTS => [
$this->entityClass => [
'station' => $request->getStation(),
],
],
]
);
}
/**
* @return TEntity
*/
protected function getRecord(
ServerRequest $request,
array $params
): ?object {
$station = $request->getStation();
/** @var int|string $id */
$id = $params['id'];
return $this->em->getRepository($this->entityClass)->findOneBy(
[
'station' => $station,
'id' => $id,
]
);
}
/**
* A placeholder function to retrieve the current station that some controllers can
* override to verify that the station can perform the specified task.
*
* @param ServerRequest $request
*/
protected function getStation(ServerRequest $request): Station
{
return $request->getStation();
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/AbstractStationApiCrudController.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 460 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations;
use App\Controller\Api\Traits\CanSearchResults;
use App\Controller\Api\Traits\CanSortResults;
use App\Entity\Api\StationRemote as ApiStationRemote;
use App\Entity\StationRemote;
use App\Exception\Http\PermissionDeniedException;
use App\Http\Response;
use App\Http\ServerRequest;
use App\OpenApi;
use OpenApi\Attributes as OA;
use Psr\Http\Message\ResponseInterface;
/** @extends AbstractStationApiCrudController<StationRemote> */
#[
OA\Get(
path: '/station/{station_id}/remotes',
operationId: 'getRelays',
description: 'List all current remote relays.',
security: OpenApi::API_KEY_SECURITY,
tags: ['Stations: Remote Relays'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
],
responses: [
new OA\Response(
response: 200,
description: 'Success',
content: new OA\JsonContent(
type: 'array',
items: new OA\Items(ref: '#/components/schemas/Api_StationRemote')
)
),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_NOT_FOUND, response: 404),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
),
OA\Post(
path: '/station/{station_id}/remotes',
operationId: 'addRelay',
description: 'Create a new remote relay.',
security: OpenApi::API_KEY_SECURITY,
requestBody: new OA\RequestBody(
content: new OA\JsonContent(ref: '#/components/schemas/Api_StationRemote')
),
tags: ['Stations: Remote Relays'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
],
responses: [
new OA\Response(
response: 200,
description: 'Success',
content: new OA\JsonContent(ref: '#/components/schemas/Api_StationRemote')
),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_NOT_FOUND, response: 404),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
),
OA\Get(
path: '/station/{station_id}/remote/{id}',
operationId: 'getRelay',
description: 'Retrieve details for a single remote relay.',
security: OpenApi::API_KEY_SECURITY,
tags: ['Stations: Remote Relays'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
new OA\Parameter(
name: 'id',
description: 'Remote Relay ID',
in: 'path',
required: true,
schema: new OA\Schema(type: 'integer', format: 'int64')
),
],
responses: [
new OA\Response(
response: 200,
description: 'Success',
content: new OA\JsonContent(ref: '#/components/schemas/Api_StationRemote')
),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_NOT_FOUND, response: 404),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
),
OA\Put(
path: '/station/{station_id}/remote/{id}',
operationId: 'editRelay',
description: 'Update details of a single remote relay.',
security: OpenApi::API_KEY_SECURITY,
requestBody: new OA\RequestBody(
content: new OA\JsonContent(ref: '#/components/schemas/Api_StationRemote')
),
tags: ['Stations: Remote Relays'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
new OA\Parameter(
name: 'id',
description: 'Remote Relay ID',
in: 'path',
required: true,
schema: new OA\Schema(type: 'integer', format: 'int64')
),
],
responses: [
new OA\Response(ref: OpenApi::REF_RESPONSE_SUCCESS, response: 200),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_NOT_FOUND, response: 404),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
),
OA\Delete(
path: '/station/{station_id}/remote/{id}',
operationId: 'deleteRelay',
description: 'Delete a single remote relay.',
security: OpenApi::API_KEY_SECURITY,
tags: ['Stations: Remote Relays'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
new OA\Parameter(
name: 'id',
description: 'Remote Relay ID',
in: 'path',
required: true,
schema: new OA\Schema(type: 'integer', format: 'int64')
),
],
responses: [
new OA\Response(ref: OpenApi::REF_RESPONSE_SUCCESS, response: 200),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_NOT_FOUND, response: 404),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
)
]
final class RemotesController extends AbstractStationApiCrudController
{
use CanSortResults;
use CanSearchResults;
protected string $entityClass = StationRemote::class;
protected string $resourceRouteName = 'api:stations:remote';
public function listAction(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
$station = $request->getStation();
$qb = $this->em->createQueryBuilder()
->select('e')
->from(StationRemote::class, 'e')
->where('e.station = :station')
->setParameter('station', $station);
$qb = $this->sortQueryBuilder(
$request,
$qb,
[
'display_name' => 'e.display_name',
'enable_autodj' => 'e.enable_autodj',
],
'e.display_name'
);
$qb = $this->searchQueryBuilder(
$request,
$qb,
[
'e.display_name',
]
);
return $this->listPaginatedFromQuery($request, $response, $qb->getQuery());
}
protected function viewRecord(object $record, ServerRequest $request): ApiStationRemote
{
assert($record instanceof StationRemote);
$returnArray = $this->toArray($record);
$return = new ApiStationRemote();
$return->fromParentObject($returnArray);
$isInternal = $request->isInternal();
$router = $request->getRouter();
$return->is_editable = $record->isEditable();
$return->links = [
'self' => $router->fromHere(
routeName: $this->resourceRouteName,
routeParams: ['id' => $record->getIdRequired()],
absolute: !$isInternal
),
];
return $return;
}
protected function getRecord(ServerRequest $request, array $params): ?object
{
$record = parent::getRecord($request, $params);
if ($record instanceof StationRemote && !$record->isEditable()) {
throw PermissionDeniedException::create($request);
}
return $record;
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/RemotesController.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 1,691 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations;
use App\Container\EntityManagerAwareTrait;
use App\Controller\SingleActionInterface;
use App\Entity\Enums\StorageLocationTypes;
use App\Entity\Station;
use App\Http\Response;
use App\Http\ServerRequest;
use Psr\Http\Message\ResponseInterface;
final class GetQuotaAction implements SingleActionInterface
{
use EntityManagerAwareTrait;
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
/** @var string|null $type */
$type = $params['type'] ?? null;
$typeEnum = StorageLocationTypes::tryFrom($type ?? '')
?? StorageLocationTypes::StationMedia;
$station = $request->getStation();
$storageLocation = $station->getStorageLocation($typeEnum);
$numFiles = match ($typeEnum) {
StorageLocationTypes::StationMedia => $this->getNumStationMedia($station),
StorageLocationTypes::StationPodcasts => $this->getNumStationPodcastMedia($station),
default => null,
};
return $response->withJson([
'used' => $storageLocation->getStorageUsed(),
'used_bytes' => (string)$storageLocation->getStorageUsedBytes(),
'used_percent' => $storageLocation->getStorageUsePercentage(),
'available' => $storageLocation->getStorageAvailable(),
'available_bytes' => (string)$storageLocation->getStorageAvailableBytes(),
'quota' => $storageLocation->getStorageQuota(),
'quota_bytes' => (string)$storageLocation->getStorageQuotaBytes(),
'is_full' => $storageLocation->isStorageFull(),
'num_files' => $numFiles,
]);
}
private function getNumStationMedia(Station $station): int
{
return (int)$this->em->createQuery(
<<<'DQL'
SELECT COUNT(sm.id) FROM App\Entity\StationMedia sm
WHERE sm.storage_location = :storageLocation
DQL
)->setParameter('storageLocation', $station->getMediaStorageLocation())
->getSingleScalarResult();
}
private function getNumStationPodcastMedia(Station $station): int
{
return (int)$this->em->createQuery(
<<<'DQL'
SELECT COUNT(pm.id) FROM App\Entity\PodcastMedia pm
WHERE pm.storage_location = :storageLocation
DQL
)->setParameter('storageLocation', $station->getPodcastsStorageLocation())
->getSingleScalarResult();
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/GetQuotaAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 556 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations;
use App\Container\EntityManagerAwareTrait;
use App\Container\EnvironmentAwareTrait;
use App\Controller\Api\Traits\AcceptsDateRange;
use App\Controller\SingleActionInterface;
use App\Doctrine\ReadOnlyBatchIteratorAggregate;
use App\Entity\ApiGenerator\SongHistoryApiGenerator;
use App\Entity\SongHistory;
use App\Entity\Station;
use App\Http\Response;
use App\Http\ServerRequest;
use App\OpenApi;
use App\Paginator;
use App\Utilities\Types;
use Carbon\CarbonImmutable;
use Doctrine\ORM\Query;
use League\Csv\Writer;
use OpenApi\Attributes as OA;
use Psr\Http\Message\ResponseInterface;
use RuntimeException;
#[
OA\Get(
path: '/station/{station_id}/history',
operationId: 'getStationHistory',
description: 'Return song playback history items for a given station.',
security: OpenApi::API_KEY_SECURITY,
tags: ['Stations: History'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
new OA\Parameter(
name: 'start',
description: 'The start date for records, in PHP-supported date/time format.'
. ' (path_to_url
in: 'query',
required: false,
schema: new OA\Schema(type: 'string')
),
new OA\Parameter(
name: 'end',
description: 'The end date for records, in PHP-supported date/time format.'
. ' (path_to_url
in: 'query',
required: false,
schema: new OA\Schema(type: 'string')
),
],
responses: [
new OA\Response(
response: 200,
description: 'Success',
content: new OA\JsonContent(
type: 'array',
items: new OA\Items(ref: '#/components/schemas/Api_DetailedSongHistory')
)
),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_NOT_FOUND, response: 404),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
)
]
final class HistoryAction implements SingleActionInterface
{
use AcceptsDateRange;
use EntityManagerAwareTrait;
use EnvironmentAwareTrait;
public function __construct(
private readonly SongHistoryApiGenerator $songHistoryApiGenerator
) {
}
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
set_time_limit($this->environment->getSyncLongExecutionTime());
$station = $request->getStation();
$stationTz = $station->getTimezoneObject();
$dateRange = $this->getDateRange($request, $stationTz);
$start = $dateRange->getStart();
$end = $dateRange->getEnd();
$qb = $this->em->createQueryBuilder();
$qb->select('sh, sr, sp, ss')
->from(SongHistory::class, 'sh')
->leftJoin('sh.request', 'sr')
->leftJoin('sh.playlist', 'sp')
->leftJoin('sh.streamer', 'ss')
->where('sh.station_id = :station_id')
->andWhere('sh.timestamp_start >= :start AND sh.timestamp_start <= :end')
->andWhere('sh.listeners_start IS NOT NULL')
->setParameter('station_id', $station->getId())
->setParameter('start', $start->getTimestamp())
->setParameter('end', $end->getTimestamp());
$format = $request->getQueryParam('format', 'json');
if ('csv' === $format) {
$csvFilename = sprintf(
'%s_timeline_%s_to_%s.csv',
$station->getShortName(),
$start->format('Y-m-d_H-i-s'),
$end->format('Y-m-d_H-i-s')
);
return $this->exportReportAsCsv(
$response,
$station,
$qb->getQuery(),
$csvFilename
);
}
$searchPhrase = Types::stringOrNull($request->getQueryParam('searchPhrase'), true);
if (null !== $searchPhrase) {
$qb->andWhere('(sh.title LIKE :query OR sh.artist LIKE :query)')
->setParameter('query', '%' . $searchPhrase . '%');
}
$qb->orderBy('sh.timestamp_start', 'DESC');
$paginator = Paginator::fromQueryBuilder($qb, $request);
$router = $request->getRouter();
$paginator->setPostprocessor(
function ($shRow) use ($router) {
/** @var SongHistory $shRow */
$row = $this->songHistoryApiGenerator->detailed($shRow);
$row->resolveUrls($router->getBaseUrl());
return $row;
}
);
return $paginator->write($response);
}
private function exportReportAsCsv(
Response $response,
Station $station,
Query $query,
string $filename
): ResponseInterface {
if (!($tempFile = tmpfile())) {
throw new RuntimeException('Could not create temp file.');
}
$csv = Writer::createFromStream($tempFile);
$csv->insertOne([
'Date',
'Time',
'Listeners',
'Delta',
'Track',
'Artist',
'Playlist',
'Streamer',
]);
/** @var SongHistory $sh */
foreach (ReadOnlyBatchIteratorAggregate::fromQuery($query, 100) as $sh) {
$datetime = CarbonImmutable::createFromTimestamp(
$sh->getTimestampStart(),
$station->getTimezoneObject()
);
$playlist = $sh->getPlaylist();
$playlistName = (null !== $playlist)
? $playlist->getName()
: '';
$streamer = $sh->getStreamer();
$streamerName = (null !== $streamer)
? $streamer->getDisplayName()
: '';
$csv->insertOne([
$datetime->format('Y-m-d'),
$datetime->format('g:ia'),
$sh->getListenersStart(),
$sh->getDeltaTotal(),
$sh->getTitle() ?: $sh->getText(),
$sh->getArtist(),
$playlistName,
$streamerName,
]);
}
return $response->withFileDownload($tempFile, $filename, 'text/csv');
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/HistoryAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 1,406 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations;
use App\Controller\Api\Admin\StationsController;
use App\Entity\Api\Status;
use App\Entity\Interfaces\EntityGroupsInterface;
use App\Enums\GlobalPermissions;
use App\Http\Response;
use App\Http\ServerRequest;
use Psr\Http\Message\ResponseInterface;
use Symfony\Component\Serializer\Normalizer\AbstractNormalizer;
/**
* This controller handles the specific "Edit Profile" function on a station's profile, which has different permissions
* and possible actions than the Admin Station Edit function.
*/
final class ProfileEditController extends StationsController
{
public function getProfileAction(
ServerRequest $request,
Response $response
): ResponseInterface {
$station = $request->getStation();
return $response->withJson(
$this->toArray($station, $this->getContext($request))
);
}
public function putProfileAction(
ServerRequest $request,
Response $response
): ResponseInterface {
$station = $request->getStation();
$this->editRecord((array)$request->getParsedBody(), $station, $this->getContext($request));
return $response->withJson(Status::updated());
}
private function getContext(ServerRequest $request): array
{
$context = [
AbstractNormalizer::GROUPS => [
EntityGroupsInterface::GROUP_ID,
EntityGroupsInterface::GROUP_GENERAL,
],
];
if ($request->getAcl()->isAllowed(GlobalPermissions::Stations)) {
$context[AbstractNormalizer::GROUPS][] = EntityGroupsInterface::GROUP_ALL;
}
return $context;
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/ProfileEditController.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 353 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations;
use App\Entity\StationHlsStream;
use App\OpenApi;
use OpenApi\Attributes as OA;
/** @extends AbstractStationApiCrudController<StationHlsStream> */
#[
OA\Get(
path: '/station/{station_id}/hls_streams',
operationId: 'getHlsStreams',
description: 'List all current HLS streams.',
security: OpenApi::API_KEY_SECURITY,
tags: ['Stations: HLS Streams'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
],
responses: [
new OA\Response(
response: 200,
description: 'Success',
content: new OA\JsonContent(
type: 'array',
items: new OA\Items(ref: '#/components/schemas/StationMount')
)
),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
),
OA\Post(
path: '/station/{station_id}/hls_streams',
operationId: 'addHlsStream',
description: 'Create a new HLS stream.',
security: OpenApi::API_KEY_SECURITY,
requestBody: new OA\RequestBody(
content: new OA\JsonContent(ref: '#/components/schemas/StationMount')
),
tags: ['Stations: HLS Streams'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
],
responses: [
new OA\Response(
response: 200,
description: 'Success',
content: new OA\JsonContent(ref: '#/components/schemas/StationMount')
),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
),
OA\Get(
path: '/station/{station_id}/hls_stream/{id}',
operationId: 'getHlsStream',
description: 'Retrieve details for a single HLS stream.',
security: OpenApi::API_KEY_SECURITY,
tags: ['Stations: HLS Streams'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
new OA\Parameter(
name: 'id',
description: 'HLS Stream ID',
in: 'path',
required: true,
schema: new OA\Schema(type: 'integer', format: 'int64')
),
],
responses: [
new OA\Response(
response: 200,
description: 'Success',
content: new OA\JsonContent(ref: '#/components/schemas/StationMount')
),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_NOT_FOUND, response: 404),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
),
OA\Put(
path: '/station/{station_id}/hls_stream/{id}',
operationId: 'editHlsStream',
description: 'Update details of a single HLS stream.',
security: OpenApi::API_KEY_SECURITY,
requestBody: new OA\RequestBody(
content: new OA\JsonContent(ref: '#/components/schemas/StationMount')
),
tags: ['Stations: HLS Streams'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
new OA\Parameter(
name: 'id',
description: 'HLS Stream ID',
in: 'path',
required: true,
schema: new OA\Schema(type: 'integer', format: 'int64')
),
],
responses: [
new OA\Response(ref: OpenApi::REF_RESPONSE_SUCCESS, response: 200),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_NOT_FOUND, response: 404),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
),
OA\Delete(
path: '/station/{station_id}/hls_stream/{id}',
operationId: 'deleteHlsStream',
description: 'Delete a single HLS stream.',
security: OpenApi::API_KEY_SECURITY,
tags: ['Stations: HLS Streams'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
new OA\Parameter(
name: 'id',
description: 'HLS Stream ID',
in: 'path',
required: true,
schema: new OA\Schema(type: 'integer', format: 'int64')
),
],
responses: [
new OA\Response(ref: OpenApi::REF_RESPONSE_SUCCESS, response: 200),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_NOT_FOUND, response: 404),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
)
]
final class HlsStreamsController extends AbstractStationApiCrudController
{
protected string $entityClass = StationHlsStream::class;
protected string $resourceRouteName = 'api:stations:hls_stream';
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/HlsStreamsController.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 1,172 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations;
use App\Entity\Api\StationQueueDetailed;
use App\Entity\Api\Status;
use App\Entity\ApiGenerator\StationQueueApiGenerator;
use App\Entity\Repository\StationQueueRepository;
use App\Entity\StationQueue;
use App\Http\Response;
use App\Http\ServerRequest;
use App\OpenApi;
use App\Radio\AutoDJ\Queue;
use App\Utilities\Types;
use OpenApi\Attributes as OA;
use Psr\Http\Message\ResponseInterface;
use Symfony\Component\Serializer\Serializer;
use Symfony\Component\Validator\Validator\ValidatorInterface;
/** @extends AbstractStationApiCrudController<StationQueue> */
#[
OA\Get(
path: '/station/{station_id}/queue',
operationId: 'getQueue',
description: 'Return information about the upcoming song playback queue.',
security: OpenApi::API_KEY_SECURITY,
tags: ['Stations: Queue'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
],
responses: [
new OA\Response(
response: 200,
description: 'Success',
content: new OA\JsonContent(
type: 'array',
items: new OA\Items(ref: '#/components/schemas/Api_StationQueueDetailed')
)
),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_NOT_FOUND, response: 404),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
),
OA\Get(
path: '/station/{station_id}/queue/{id}',
operationId: 'getQueueItem',
description: 'Retrieve details of a single queued item.',
security: OpenApi::API_KEY_SECURITY,
tags: ['Stations: Queue'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
new OA\Parameter(
name: 'id',
description: 'Queue Item ID',
in: 'path',
required: true,
schema: new OA\Schema(type: 'integer', format: 'int64')
),
],
responses: [
new OA\Response(
response: 200,
description: 'Success',
content: new OA\JsonContent(ref: '#/components/schemas/Api_StationQueueDetailed')
),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_NOT_FOUND, response: 404),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
),
OA\Delete(
path: '/station/{station_id}/queue/{id}',
operationId: 'deleteQueueItem',
description: 'Delete a single queued item.',
security: OpenApi::API_KEY_SECURITY,
tags: ['Stations: Queue'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
new OA\Parameter(
name: 'id',
description: 'Queue Item ID',
in: 'path',
required: true,
schema: new OA\Schema(type: 'integer', format: 'int64')
),
],
responses: [
new OA\Response(ref: OpenApi::REF_RESPONSE_SUCCESS, response: 200),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_NOT_FOUND, response: 404),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
)
]
final class QueueController extends AbstractStationApiCrudController
{
protected string $entityClass = StationQueue::class;
protected string $resourceRouteName = 'api:stations:queue:record';
public function __construct(
private readonly StationQueueApiGenerator $queueApiGenerator,
private readonly StationQueueRepository $queueRepo,
private readonly Queue $queue,
Serializer $serializer,
ValidatorInterface $validator
) {
parent::__construct($serializer, $validator);
}
public function listAction(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
$station = $request->getStation();
$qb = $this->queueRepo->getUnplayedBaseQuery($station);
$searchPhrase = Types::stringOrNull($request->getQueryParam('searchPhrase'), true);
if (null !== $searchPhrase) {
$qb->andWhere('(sm.title LIKE :query OR sm.artist LIKE :query OR sm.text LIKE :query)')
->setParameter('query', '%' . $searchPhrase . '%');
}
return $this->listPaginatedFromQuery(
$request,
$response,
$qb->getQuery()
);
}
/**
* @param object $record
* @param ServerRequest $request
*/
protected function viewRecord(object $record, ServerRequest $request): StationQueueDetailed
{
assert($record instanceof StationQueue);
$isInternal = $request->isInternal();
$router = $request->getRouter();
$row = ($this->queueApiGenerator)($record);
$row->resolveUrls($router->getBaseUrl());
$apiResponse = new StationQueueDetailed();
$apiResponse->fromParentObject($row);
$apiResponse->sent_to_autodj = $record->getSentToAutodj();
$apiResponse->is_played = $record->getIsPlayed();
$apiResponse->autodj_custom_uri = $record->getAutodjCustomUri();
$apiResponse->log = $this->queue->getQueueRowLog($record);
$apiResponse->links = [
'self' => $router->fromHere(
$this->resourceRouteName,
['id' => $record->getId()],
[],
!$isInternal
),
];
return $apiResponse;
}
public function clearAction(
ServerRequest $request,
Response $response
): ResponseInterface {
$station = $request->getStation();
$this->queueRepo->clearUpcomingQueue($station);
return $response->withJson(Status::deleted());
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/QueueController.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 1,353 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations;
use App\Controller\Api\Traits\CanSearchResults;
use App\Controller\Api\Traits\CanSortResults;
use App\Entity\Api\Error;
use App\Entity\Api\StationMedia as ApiStationMedia;
use App\Entity\Api\Status;
use App\Entity\Api\UploadFile;
use App\Entity\Repository\CustomFieldRepository;
use App\Entity\Repository\StationMediaRepository;
use App\Entity\Repository\StationPlaylistMediaRepository;
use App\Entity\StationMedia;
use App\Entity\StationPlaylist;
use App\Exception\ValidationException;
use App\Flysystem\StationFilesystems;
use App\Http\Response;
use App\Http\ServerRequest;
use App\Media\MediaProcessor;
use App\Message\WritePlaylistFileMessage;
use App\OpenApi;
use App\Radio\Adapters;
use App\Radio\Backend\Liquidsoap;
use InvalidArgumentException;
use OpenApi\Attributes as OA;
use Psr\Http\Message\ResponseInterface;
use Symfony\Component\Messenger\MessageBus;
use Symfony\Component\Serializer\Normalizer\AbstractNormalizer;
use Symfony\Component\Serializer\Serializer;
use Symfony\Component\Validator\Validator\ValidatorInterface;
/** @extends AbstractStationApiCrudController<StationMedia> */
#[
OA\Get(
path: '/station/{station_id}/files',
operationId: 'getFiles',
description: 'List all current uploaded files.',
security: OpenApi::API_KEY_SECURITY,
tags: ['Stations: Media'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
],
responses: [
new OA\Response(
response: 200,
description: 'Success',
content: new OA\JsonContent(
type: 'array',
items: new OA\Items(ref: '#/components/schemas/Api_StationMedia')
)
),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
),
OA\Post(
path: '/station/{station_id}/files',
operationId: 'addFile',
description: 'Upload a new file.',
security: OpenApi::API_KEY_SECURITY,
requestBody: new OA\RequestBody(
content: new OA\JsonContent(ref: '#/components/schemas/Api_UploadFile')
),
tags: ['Stations: Media'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
],
responses: [
new OA\Response(
response: 200,
description: 'Success',
content: new OA\JsonContent(ref: '#/components/schemas/Api_StationMedia')
),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
),
OA\Get(
path: '/station/{station_id}/file/{id}',
operationId: 'getFile',
description: 'Retrieve details for a single file.',
security: OpenApi::API_KEY_SECURITY,
tags: ['Stations: Media'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
new OA\Parameter(
name: 'id',
description: 'Media ID',
in: 'path',
required: true,
schema: new OA\Schema(type: 'integer', format: 'int64')
),
],
responses: [
new OA\Response(
response: 200,
description: 'Success',
content: new OA\JsonContent(ref: '#/components/schemas/Api_StationMedia')
),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_NOT_FOUND, response: 404),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
),
OA\Put(
path: '/station/{station_id}/file/{id}',
operationId: 'editFile',
description: 'Update details of a single file.',
security: OpenApi::API_KEY_SECURITY,
requestBody: new OA\RequestBody(
content: new OA\JsonContent(ref: '#/components/schemas/Api_StationMedia')
),
tags: ['Stations: Media'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
new OA\Parameter(
name: 'id',
description: 'Media ID',
in: 'path',
required: true,
schema: new OA\Schema(type: 'integer', format: 'int64')
),
],
responses: [
new OA\Response(ref: OpenApi::REF_RESPONSE_SUCCESS, response: 200),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_NOT_FOUND, response: 404),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
),
OA\Delete(
path: '/station/{station_id}/file/{id}',
operationId: 'deleteFile',
description: 'Delete a single file.',
security: OpenApi::API_KEY_SECURITY,
tags: ['Stations: Media'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
new OA\Parameter(
name: 'id',
description: 'Media ID',
in: 'path',
required: true,
schema: new OA\Schema(type: 'integer', format: 'int64')
),
],
responses: [
new OA\Response(ref: OpenApi::REF_RESPONSE_SUCCESS, response: 200),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_NOT_FOUND, response: 404),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
)
]
final class FilesController extends AbstractStationApiCrudController
{
use CanSortResults;
use CanSearchResults;
protected string $entityClass = StationMedia::class;
protected string $resourceRouteName = 'api:stations:file';
public function __construct(
private readonly Adapters $adapters,
private readonly MessageBus $messageBus,
private readonly CustomFieldRepository $customFieldsRepo,
private readonly StationMediaRepository $mediaRepo,
private readonly StationPlaylistMediaRepository $playlistMediaRepo,
private readonly MediaProcessor $mediaProcessor,
private readonly StationFilesystems $stationFilesystems,
Serializer $serializer,
ValidatorInterface $validator
) {
parent::__construct($serializer, $validator);
}
public function listAction(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
$storageLocation = $this->getStation($request)->getMediaStorageLocation();
$qb = $this->em->createQueryBuilder()
->select('e')
->from(StationMedia::class, 'e')
->where('e.storage_location = :storageLocation')
->setParameter('storageLocation', $storageLocation);
$qb = $this->sortQueryBuilder(
$request,
$qb,
[
'path' => 'e.path',
'title' => 'e.title',
'artist' => 'e.artist',
'album' => 'e.album',
'genre' => 'e.genre',
'length' => 'e.length',
'mtime' => 'e.mtime',
],
'e.path'
);
$qb = $this->searchQueryBuilder(
$request,
$qb,
[
'e.title',
'e.artist',
'e.path',
]
);
return $this->listPaginatedFromQuery($request, $response, $qb->getQuery());
}
protected function viewRecord(object $record, ServerRequest $request): ApiStationMedia
{
assert($record instanceof StationMedia);
$returnArray = $this->toArray($record);
$return = ApiStationMedia::fromArray(
$returnArray,
$record->getExtraMetadata()->toArray(),
$this->customFieldsRepo->getCustomFields($record),
ApiStationMedia::aggregatePlaylists($returnArray['playlists'] ?? []),
);
$isInternal = $request->isInternal();
$router = $request->getRouter();
$routeParams = [
'media_id' => $record->getUniqueId(),
];
if (0 !== $record->getArtUpdatedAt()) {
$routeParams['timestamp'] = $record->getArtUpdatedAt();
}
$return->art = $router->fromHere(
'api:stations:media:art',
routeParams: $routeParams,
absolute: !$isInternal
);
$return->links = [
'self' => $router->fromHere(
routeName: $this->resourceRouteName,
routeParams: ['id' => $record->getIdRequired()],
absolute: !$isInternal
),
'play' => $router->fromHere(
'api:stations:files:play',
['id' => $record->getIdRequired()],
absolute: true
),
'art' => $router->fromHere(
'api:stations:media:art',
['media_id' => $record->getIdRequired()],
absolute: !$isInternal
),
'waveform' => $router->fromHere(
'api:stations:media:waveform',
[
'media_id' => $record->getUniqueId(),
'timestamp' => $record->getArtUpdatedAt(),
],
absolute: !$isInternal
),
'waveform_cache' => $router->fromHere(
'api:stations:media:waveform-cache',
[
'media_id' => $record->getUniqueId(),
],
absolute: !$isInternal
),
];
return $return;
}
public function createAction(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
$station = $this->getStation($request);
$mediaStorage = $station->getMediaStorageLocation();
if ($mediaStorage->isStorageFull()) {
return $response->withStatus(500)
->withJson(new Error(500, __('This station is out of available storage space.')));
}
$request->getParsedBody();
// Convert the body into an UploadFile API entity first.
/** @var UploadFile $apiRecord */
$apiRecord = $this->serializer->denormalize($request->getParsedBody(), UploadFile::class, null, []);
// Validate the UploadFile API record.
$errors = $this->validator->validate($apiRecord);
if (count($errors) > 0) {
throw ValidationException::fromValidationErrors($errors);
}
// Write file to temp path.
$tempPath = $station->getRadioTempDir() . '/' . $apiRecord->getSanitizedFilename();
file_put_contents($tempPath, $apiRecord->getFileContents());
// Process temp path as regular media record.
$record = $this->mediaProcessor->processAndUpload(
$mediaStorage,
$apiRecord->getSanitizedPath(),
$tempPath
);
$return = (null !== $record)
? $this->viewRecord($record, $request)
: Status::success();
return $response->withJson($return);
}
public function editAction(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
$station = $this->getStation($request);
$record = $this->getRecord($request, $params);
if (null === $record) {
return $response->withStatus(404)
->withJson(Error::notFound());
}
$data = $request->getParsedBody();
if (!is_array($data)) {
throw new InvalidArgumentException('Could not parse input data.');
}
$customFields = $data['custom_fields'] ?? null;
$playlists = $data['playlists'] ?? null;
unset($data['custom_fields'], $data['playlists']);
$fsMedia = $this->stationFilesystems->getMediaFilesystem($station);
$oldPath = $record->getPath();
$isRenamed = (isset($data['path']) && $data['path'] !== $oldPath);
$record = $this->fromArray($data, $record);
if ($isRenamed) {
$fsMedia->move($oldPath, $record->getPath());
}
$errors = $this->validator->validate($record);
if (count($errors) > 0) {
throw ValidationException::fromValidationErrors($errors);
}
if ($record instanceof StationMedia) {
$this->mediaRepo->writeToFile($record);
$this->em->persist($record);
$this->em->flush();
if (null !== $customFields) {
$this->customFieldsRepo->setCustomFields($record, $customFields);
}
if (null !== $playlists) {
$playlistsToAssign = [];
foreach ($playlists as $newPlaylist) {
if (is_array($newPlaylist)) {
$playlistsToAssign[(int)$newPlaylist['id']] = $newPlaylist['weight'] ?? 0;
} else {
$playlistsToAssign[(int)$newPlaylist] = 0;
}
}
$affectedPlaylistIds = $this->playlistMediaRepo->setPlaylistsForMedia(
$record,
$station,
$playlistsToAssign
);
// Handle playlist changes.
$backend = $this->adapters->getBackendAdapter($station);
if ($backend instanceof Liquidsoap) {
foreach ($affectedPlaylistIds as $playlistId => $playlistRow) {
// Instruct the message queue to start a new "write playlist to file" task.
$message = new WritePlaylistFileMessage();
$message->playlist_id = $playlistId;
$this->messageBus->dispatch($message);
}
}
}
}
return $response->withJson(Status::updated());
}
protected function createRecord(ServerRequest $request, array $data): object
{
$station = $request->getStation();
$mediaStorage = $station->getMediaStorageLocation();
return $this->editRecord(
$data,
null,
[
AbstractNormalizer::DEFAULT_CONSTRUCTOR_ARGUMENTS => [
$this->entityClass => [
'station' => $station,
'storageLocation' => $mediaStorage,
],
],
]
);
}
protected function getRecord(ServerRequest $request, array $params): ?object
{
/** @var string $id */
$id = $params['id'];
$station = $request->getStation();
$mediaStorage = $station->getMediaStorageLocation();
$repo = $this->em->getRepository($this->entityClass);
foreach (['id', 'unique_id', 'song_id'] as $field) {
$record = $repo->findOneBy(
[
'storage_location' => $mediaStorage,
$field => $id,
]
);
if ($record instanceof $this->entityClass) {
return $record;
}
}
return null;
}
/** @inheritDoc */
protected function toArray(object $record, array $context = []): array
{
$row = parent::toArray($record, $context);
if ($record instanceof StationMedia) {
$row['custom_fields'] = $this->customFieldsRepo->getCustomFields($record);
}
return $row;
}
/**
* @inheritDoc
*/
protected function deleteRecord(object $record): void
{
if (!($record instanceof StationMedia)) {
throw new InvalidArgumentException(sprintf('Record must be an instance of %s.', $this->entityClass));
}
// Delete the media file off the filesystem.
// Write new PLS playlist configuration.
foreach ($this->mediaRepo->remove($record, true) as $playlistId => $playlistRecord) {
$playlist = $this->em->find(StationPlaylist::class, $playlistId);
if (!($playlist instanceof StationPlaylist)) {
continue;
}
$backend = $this->adapters->getBackendAdapter($playlist->getStation());
if ($backend instanceof Liquidsoap) {
// Instruct the message queue to start a new "write playlist to file" task.
$message = new WritePlaylistFileMessage();
$message->playlist_id = $playlistId;
$this->messageBus->dispatch($message);
}
}
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/FilesController.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 3,650 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations;
use App\Container\EntityManagerAwareTrait;
use App\Controller\Api\Traits\AcceptsDateRange;
use App\Controller\SingleActionInterface;
use App\Entity\Api\Listener as ApiListener;
use App\Entity\Listener;
use App\Entity\Repository\ListenerRepository;
use App\Entity\Repository\StationHlsStreamRepository;
use App\Entity\Repository\StationMountRepository;
use App\Entity\Repository\StationRemoteRepository;
use App\Entity\Station;
use App\Http\Response;
use App\Http\ServerRequest;
use App\OpenApi;
use Carbon\CarbonImmutable;
use Doctrine\ORM\AbstractQuery;
use League\Csv\Writer;
use OpenApi\Attributes as OA;
use Psr\Http\Message\ResponseInterface;
use RuntimeException;
#[
OA\Get(
path: '/station/{station_id}/listeners',
operationId: 'getStationListeners',
description: 'Return detailed information about current listeners.',
security: OpenApi::API_KEY_SECURITY,
tags: ['Stations: Listeners'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
],
responses: [
new OA\Response(
response: 200,
description: 'Success',
content: new OA\JsonContent(
type: 'array',
items: new OA\Items(ref: '#/components/schemas/Api_Listener')
)
),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_NOT_FOUND, response: 404),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
)
]
final class ListenersAction implements SingleActionInterface
{
use AcceptsDateRange;
use EntityManagerAwareTrait;
public function __construct(
private readonly ListenerRepository $listenerRepo,
private readonly StationMountRepository $mountRepo,
private readonly StationRemoteRepository $remoteRepo,
private readonly StationHlsStreamRepository $hlsStreamRepo,
) {
}
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
$station = $request->getStation();
$stationTz = $station->getTimezoneObject();
$queryParams = $request->getQueryParams();
$isLive = empty($queryParams['start']);
$now = CarbonImmutable::now($stationTz);
if ($isLive) {
$range = 'live';
$startTimestamp = $now->getTimestamp();
$endTimestamp = $now->getTimestamp();
$listenersIterator = $this->listenerRepo->iterateLiveListenersArray($station);
} else {
$dateRange = $this->getDateRange($request, $stationTz);
$start = $dateRange->getStart();
$startTimestamp = $start->getTimestamp();
$end = $dateRange->getEnd();
$endTimestamp = $end->getTimestamp();
$range = $start->format('Y-m-d_H-i-s') . '_to_' . $end->format('Y-m-d_H-i-s');
$listenersIterator = $this->em->createQuery(
<<<'DQL'
SELECT l
FROM App\Entity\Listener l
WHERE l.station = :station
AND l.timestamp_start < :time_end
AND (l.timestamp_end = 0 OR l.timestamp_end > :time_start)
ORDER BY l.timestamp_start ASC
DQL
)->setParameter('station', $station)
->setParameter('time_start', $startTimestamp)
->setParameter('time_end', $endTimestamp)
->toIterable([], AbstractQuery::HYDRATE_ARRAY);
}
$mountNames = $this->mountRepo->getDisplayNames($station);
$remoteNames = $this->remoteRepo->getDisplayNames($station);
$hlsStreamNames = $this->hlsStreamRepo->getDisplayNames($station);
/** @var ApiListener[] $listeners */
$listeners = [];
$listenersByHash = [];
$groupByUnique = ('false' !== ($queryParams['unique'] ?? 'true'));
$nowTimestamp = $now->getTimestamp();
foreach ($listenersIterator as $listener) {
$listenerStart = $listener['timestamp_start'];
if ($isLive) {
$listenerEnd = $nowTimestamp;
} else {
if ($listenerStart < $startTimestamp) {
$listenerStart = $startTimestamp;
}
$listenerEnd = $listener['timestamp_end'];
if (0 === $listenerEnd || $listenerEnd > $endTimestamp) {
$listenerEnd = $endTimestamp;
}
}
$hash = $listener['listener_hash'];
if ($groupByUnique && isset($listenersByHash[$hash])) {
$listenersByHash[$hash]['intervals'][] = [
'start' => $listenerStart,
'end' => $listenerEnd,
];
continue;
}
$api = ApiListener::fromArray($listener);
if (null !== $listener['mount_id']) {
$api->mount_is_local = true;
$api->mount_name = $mountNames[$listener['mount_id']];
} elseif (null !== $listener['hls_stream_id']) {
$api->mount_is_local = true;
$api->mount_name = $hlsStreamNames[$listener['hls_stream_id']];
} elseif (null !== $listener['remote_id']) {
$api->mount_is_local = false;
$api->mount_name = $remoteNames[$listener['remote_id']];
}
if ($groupByUnique) {
$listenersByHash[$hash] = [
'api' => $api,
'intervals' => [
[
'start' => $listenerStart,
'end' => $listenerEnd,
],
],
];
} else {
$api->connected_on = $listenerStart;
$api->connected_until = $listenerEnd;
$api->connected_time = $listenerEnd - $listenerStart;
$listeners[] = $api;
}
}
if ($groupByUnique) {
foreach ($listenersByHash as $listenerInfo) {
$intervals = (array)$listenerInfo['intervals'];
$startTime = $nowTimestamp;
$endTime = 0;
foreach ($intervals as $interval) {
$startTime = min($interval['start'], $startTime);
$endTime = max($interval['end'], $endTime);
}
/** @var ApiListener $api */
$api = $listenerInfo['api'];
$api->connected_on = $startTime;
$api->connected_until = $endTime;
$api->connected_time = Listener::getListenerSeconds($intervals);
$listeners[] = $api;
}
}
$format = $queryParams['format'] ?? 'json';
if ('csv' === $format) {
return $this->exportReportAsCsv(
$response,
$station,
$listeners,
$station->getShortName() . '_listeners_' . $range . '.csv'
);
}
return $response->withJson($listeners);
}
/**
* @param Response $response
* @param Station $station
* @param ApiListener[] $listeners
* @param string $filename
*/
private function exportReportAsCsv(
Response $response,
Station $station,
array $listeners,
string $filename
): ResponseInterface {
if (!($tempFile = tmpfile())) {
throw new RuntimeException('Could not create temp file.');
}
$csv = Writer::createFromStream($tempFile);
$tz = $station->getTimezoneObject();
$csv->insertOne(
[
'IP',
'Start Time',
'End Time',
'Seconds Connected',
'User Agent',
'Mount Type',
'Mount Name',
'Device: Client',
'Device: Is Mobile',
'Device: Is Browser',
'Device: Is Bot',
'Device: Browser Family',
'Device: OS Family',
'Location: Description',
'Location: Country',
'Location: Region',
'Location: City',
'Location: Latitude',
'Location: Longitude',
]
);
foreach ($listeners as $listener) {
$startTime = CarbonImmutable::createFromTimestamp($listener->connected_on, $tz);
$endTime = CarbonImmutable::createFromTimestamp($listener->connected_until, $tz);
$exportRow = [
$listener->ip,
$startTime->toIso8601String(),
$endTime->toIso8601String(),
$listener->connected_time,
$listener->user_agent,
($listener->mount_is_local) ? 'Local' : 'Remote',
$listener->mount_name,
$listener->device->client,
$listener->device->is_mobile ? 'True' : 'False',
$listener->device->is_browser ? 'True' : 'False',
$listener->device->is_bot ? 'True' : 'False',
$listener->device->browser_family,
$listener->device->os_family,
$listener->location->description,
$listener->location->country,
$listener->location->region,
$listener->location->city,
$listener->location->lat,
$listener->location->lon,
];
$csv->insertOne($exportRow);
}
return $response->withFileDownload($tempFile, $filename, 'text/csv');
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/ListenersAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 2,062 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations;
use App\Controller\Api\AbstractApiCrudController;
use App\Controller\Api\Traits\CanSearchResults;
use App\Entity\Api\Podcast as ApiPodcast;
use App\Entity\ApiGenerator\PodcastApiGenerator;
use App\Entity\Podcast;
use App\Entity\PodcastCategory;
use App\Entity\Repository\PodcastRepository;
use App\Http\Response;
use App\Http\ServerRequest;
use App\OpenApi;
use App\Service\Flow\UploadedFile;
use App\Utilities\Types;
use OpenApi\Attributes as OA;
use Psr\Http\Message\ResponseInterface;
use Symfony\Component\Serializer\Serializer;
use Symfony\Component\Validator\Validator\ValidatorInterface;
/** @extends AbstractApiCrudController<Podcast> */
#[
OA\Get(
path: '/station/{station_id}/podcasts',
operationId: 'getPodcasts',
description: 'List all current podcasts.',
security: OpenApi::API_KEY_SECURITY,
tags: ['Stations: Podcasts'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
],
responses: [
new OA\Response(
response: 200,
description: 'Success',
content: new OA\JsonContent(
type: 'array',
items: new OA\Items(ref: '#/components/schemas/Api_Podcast')
)
),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_NOT_FOUND, response: 404),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
),
OA\Post(
path: '/station/{station_id}/podcasts',
operationId: 'addPodcast',
description: 'Create a new podcast.',
security: OpenApi::API_KEY_SECURITY,
requestBody: new OA\RequestBody(
content: new OA\JsonContent(ref: '#/components/schemas/Api_Podcast')
),
tags: ['Stations: Podcasts'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
],
responses: [
new OA\Response(
response: 200,
description: 'Success',
content: new OA\JsonContent(ref: '#/components/schemas/Api_Podcast')
),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_NOT_FOUND, response: 404),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
),
OA\Get(
path: '/station/{station_id}/podcast/{id}',
operationId: 'getPodcast',
description: 'Retrieve details for a single podcast.',
security: OpenApi::API_KEY_SECURITY,
tags: ['Stations: Podcasts'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
new OA\Parameter(
name: 'id',
description: 'Podcast ID',
in: 'path',
required: true,
schema: new OA\Schema(type: 'string')
),
],
responses: [
new OA\Response(
response: 200,
description: 'Success',
content: new OA\JsonContent(ref: '#/components/schemas/Api_Podcast')
),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_NOT_FOUND, response: 404),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
),
OA\Put(
path: '/station/{station_id}/podcast/{id}',
operationId: 'editPodcast',
description: 'Update details of a single podcast.',
security: OpenApi::API_KEY_SECURITY,
requestBody: new OA\RequestBody(
content: new OA\JsonContent(ref: '#/components/schemas/Api_Podcast')
),
tags: ['Stations: Podcasts'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
new OA\Parameter(
name: 'id',
description: 'Podcast ID',
in: 'path',
required: true,
schema: new OA\Schema(type: 'string')
),
],
responses: [
new OA\Response(ref: OpenApi::REF_RESPONSE_SUCCESS, response: 200),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_NOT_FOUND, response: 404),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
),
OA\Delete(
path: '/station/{station_id}/podcast/{id}',
operationId: 'deletePodcast',
description: 'Delete a single podcast.',
security: OpenApi::API_KEY_SECURITY,
tags: ['Stations: Podcasts'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
new OA\Parameter(
name: 'id',
description: 'Podcast ID',
in: 'path',
required: true,
schema: new OA\Schema(type: 'string')
),
],
responses: [
new OA\Response(ref: OpenApi::REF_RESPONSE_SUCCESS, response: 200),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_NOT_FOUND, response: 404),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
)
]
final class PodcastsController extends AbstractApiCrudController
{
use CanSearchResults;
protected string $entityClass = Podcast::class;
protected string $resourceRouteName = 'api:stations:podcast';
public function __construct(
private readonly PodcastRepository $podcastRepository,
private readonly PodcastApiGenerator $podcastApiGen,
Serializer $serializer,
ValidatorInterface $validator,
) {
parent::__construct($serializer, $validator);
}
public function listAction(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
$station = $request->getStation();
$queryBuilder = $this->em->createQueryBuilder()
->select('p, pc')
->from(Podcast::class, 'p')
->leftJoin('p.categories', 'pc')
->where('p.storage_location = :storageLocation')
->orderBy('p.title', 'ASC')
->setParameter('storageLocation', $station->getPodcastsStorageLocation());
$queryBuilder = $this->searchQueryBuilder(
$request,
$queryBuilder,
[
'p.title',
]
);
return $this->listPaginatedFromQuery($request, $response, $queryBuilder->getQuery());
}
protected function getRecord(ServerRequest $request, array $params): ?object
{
/** @var string $id */
$id = $params['podcast_id'];
return $this->podcastRepository->fetchPodcastForStation(
$request->getStation(),
$id
);
}
protected function createRecord(ServerRequest $request, array $data): object
{
$station = $request->getStation();
/** @var Podcast $record */
$record = $this->editRecord(
$data,
new Podcast($station->getPodcastsStorageLocation())
);
if (!empty($data['artwork_file'])) {
$artwork = UploadedFile::fromArray($data['artwork_file'], $station->getRadioTempDir());
$this->podcastRepository->writePodcastArt(
$record,
$artwork->readAndDeleteUploadedFile()
);
$this->em->persist($record);
$this->em->flush();
}
return $record;
}
protected function deleteRecord(object $record): void
{
$this->podcastRepository->delete($record);
}
protected function viewRecord(object $record, ServerRequest $request): ApiPodcast
{
assert($record instanceof Podcast);
$isInternal = $request->isInternal();
$router = $request->getRouter();
$return = $this->podcastApiGen->__invoke($record, $request);
$baseRouteParams = [
'station_id' => $request->getStation()->getIdRequired(),
'podcast_id' => $record->getIdRequired(),
];
$artRouteParams = $baseRouteParams;
if (0 !== $return->art_updated_at) {
$artRouteParams['timestamp'] = $return->art_updated_at;
}
$return->art = $router->named(
routeName: 'api:stations:podcast:art',
routeParams: $artRouteParams,
absolute: !$isInternal
);
$return->links = [
...$return->links,
'self' => $router->named(
routeName: $this->resourceRouteName,
routeParams: $baseRouteParams,
absolute: !$isInternal
),
'art' => $router->named(
routeName: 'api:stations:podcast:art',
routeParams: $baseRouteParams,
absolute: !$isInternal
),
'episodes' => $router->named(
routeName: 'api:stations:podcast:episodes',
routeParams: $baseRouteParams,
absolute: !$isInternal
),
'episode_new_art' => $router->named(
routeName: 'api:stations:podcast:episodes:new-art',
routeParams: $baseRouteParams,
absolute: !$isInternal
),
'episode_new_media' => $router->named(
routeName: 'api:stations:podcast:episodes:new-media',
routeParams: $baseRouteParams,
absolute: !$isInternal
),
'batch' => $router->named(
routeName: 'api:stations:podcast:batch',
routeParams: $baseRouteParams,
absolute: !$isInternal
),
];
return $return;
}
/**
* @param mixed[] $data
* @param Podcast|null $record
* @param array $context
*
* @return Podcast
*/
protected function fromArray($data, $record = null, array $context = []): object
{
/** @var null|string[] $newCategories */
$newCategories = null;
if (isset($data['categories'])) {
$newCategories = Types::arrayOrNull($data['categories']);
unset($data['categories']);
}
if (isset($data['playlist_id'])) {
$data['playlist'] = $data['playlist_id'];
unset($data['playlist_id']);
}
$record = parent::fromArray($data, $record, $context);
if (null !== $newCategories) {
$categories = $record->getCategories();
if ($categories->count() > 0) {
foreach ($categories as $existingCategories) {
$this->em->remove($existingCategories);
}
$categories->clear();
}
foreach ($newCategories as $category) {
$podcastCategory = new PodcastCategory($record, $category);
$this->em->persist($podcastCategory);
$categories->add($podcastCategory);
}
}
return $record;
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/PodcastsController.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 2,519 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations;
use App\Controller\SingleActionInterface;
use App\Entity\Api\Status;
use App\Http\Response;
use App\Http\ServerRequest;
use App\Radio\Adapters;
use Psr\Http\Message\ResponseInterface;
use const ARRAY_FILTER_USE_KEY;
final class UpdateMetadataAction implements SingleActionInterface
{
public function __construct(
private readonly Adapters $adapters,
) {
}
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
$station = $request->getStation();
$backend = $this->adapters->requireBackendAdapter($station);
$allowedMetaFields = [
'title',
'artist',
'duration',
'song_id',
'media_id',
'liq_amplify',
'liq_cross_duration',
'liq_fade_in',
'liq_fade_out',
'liq_cue_in',
'liq_cue_out',
];
$metadata = array_filter(
$request->getParams(),
static function ($key) use ($allowedMetaFields) {
return in_array($key, $allowedMetaFields, true);
},
ARRAY_FILTER_USE_KEY
);
$output = $backend->updateMetadata($station, $metadata);
return $response->withJson(
new Status(true, 'Metadata updated successfully: ' . implode(', ', $output))
);
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/UpdateMetadataAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 326 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations;
use App\Entity\SftpUser;
use App\OpenApi;
use OpenApi\Attributes as OA;
/** @extends AbstractStationApiCrudController<SftpUser> */
#[
OA\Get(
path: '/station/{station_id}/sftp-users',
operationId: 'getSftpUsers',
description: 'List all current SFTP users.',
security: OpenApi::API_KEY_SECURITY,
tags: ['Stations: SFTP Users'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
],
responses: [
new OA\Response(
response: 200,
description: 'Success',
content: new OA\JsonContent(
type: 'array',
items: new OA\Items(ref: '#/components/schemas/SftpUser')
)
),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_NOT_FOUND, response: 404),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
),
OA\Post(
path: '/station/{station_id}/sftp-users',
operationId: 'addSftpUser',
description: 'Create a new SFTP user.',
security: OpenApi::API_KEY_SECURITY,
requestBody: new OA\RequestBody(
content: new OA\JsonContent(ref: '#/components/schemas/SftpUser')
),
tags: ['Stations: SFTP Users'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
],
responses: [
new OA\Response(
response: 200,
description: 'Success',
content: new OA\JsonContent(ref: '#/components/schemas/SftpUser')
),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_NOT_FOUND, response: 404),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
),
OA\Get(
path: '/station/{station_id}/sftp-user/{id}',
operationId: 'getSftpUser',
description: 'Retrieve details for a single SFTP user.',
security: OpenApi::API_KEY_SECURITY,
tags: ['Stations: SFTP Users'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
new OA\Parameter(
name: 'id',
description: 'SFTP User ID',
in: 'path',
required: true,
schema: new OA\Schema(type: 'integer', format: 'int64')
),
],
responses: [
new OA\Response(
response: 200,
description: 'Success',
content: new OA\JsonContent(ref: '#/components/schemas/SftpUser')
),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_NOT_FOUND, response: 404),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
),
OA\Put(
path: '/station/{station_id}/sftp-user/{id}',
operationId: 'editSftpUser',
description: 'Update details of a single SFTP user.',
security: OpenApi::API_KEY_SECURITY,
requestBody: new OA\RequestBody(
content: new OA\JsonContent(ref: '#/components/schemas/SftpUser')
),
tags: ['Stations: SFTP Users'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
new OA\Parameter(
name: 'id',
description: 'Remote Relay ID',
in: 'path',
required: true,
schema: new OA\Schema(type: 'integer', format: 'int64')
),
],
responses: [
new OA\Response(ref: OpenApi::REF_RESPONSE_SUCCESS, response: 200),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_NOT_FOUND, response: 404),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
),
OA\Delete(
path: '/station/{station_id}/sftp-user/{id}',
operationId: 'deleteSftpUser',
description: 'Delete a single remote relay.',
security: OpenApi::API_KEY_SECURITY,
tags: ['Stations: SFTP Users'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
new OA\Parameter(
name: 'id',
description: 'Remote Relay ID',
in: 'path',
required: true,
schema: new OA\Schema(type: 'integer', format: 'int64')
),
],
responses: [
new OA\Response(ref: OpenApi::REF_RESPONSE_SUCCESS, response: 200),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_NOT_FOUND, response: 404),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
)
]
final class SftpUsersController extends AbstractStationApiCrudController
{
protected string $entityClass = SftpUser::class;
protected string $resourceRouteName = 'api:stations:sftp-user';
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/SftpUsersController.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 1,212 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations;
use App\Controller\SingleActionInterface;
use App\Entity\Api\StationProfile;
use App\Entity\Api\StationServiceStatus;
use App\Entity\ApiGenerator\StationApiGenerator;
use App\Entity\Repository\StationScheduleRepository;
use App\Http\Response;
use App\Http\ServerRequest;
use App\Radio\Adapters;
use GuzzleHttp\Psr7\Uri;
use Psr\Http\Message\ResponseInterface;
final class ProfileAction implements SingleActionInterface
{
public function __construct(
private readonly StationScheduleRepository $scheduleRepo,
private readonly StationApiGenerator $stationApiGenerator,
private readonly Adapters $adapters,
) {
}
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
$station = $request->getStation();
$backend = $this->adapters->getBackendAdapter($station);
$frontend = $this->adapters->getFrontendAdapter($station);
$baseUri = new Uri('');
$apiResponse = new StationProfile();
$apiResponse->station = ($this->stationApiGenerator)($station, $baseUri, true);
$apiResponse->services = new StationServiceStatus(
null !== $backend && $backend->isRunning($station),
null !== $frontend && $frontend->isRunning($station),
$station->getHasStarted(),
$station->getNeedsRestart()
);
$apiResponse->schedule = $this->scheduleRepo->getUpcomingSchedule($station);
$apiResponse->resolveUrls($request->getRouter()->getBaseUrl());
return $response->withJson($apiResponse);
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/ProfileAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 367 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations;
use App\Controller\SingleActionInterface;
use App\Http\Response;
use App\Http\ServerRequest;
use Psr\Http\Message\ResponseInterface;
final class GetRestartStatusAction implements SingleActionInterface
{
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
$station = $request->getStation();
return $response->withJson([
'has_started' => $station->getHasStarted(),
'needs_restart' => $station->getNeedsRestart(),
]);
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/GetRestartStatusAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 133 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations;
use App\Container\EntityManagerAwareTrait;
use App\Controller\SingleActionInterface;
use App\Entity\ApiGenerator\SongApiGenerator;
use App\Entity\StationMedia;
use App\Http\ServerRequest;
use App\Paginator;
use Psr\Cache\CacheItemPoolInterface;
abstract class AbstractSearchableListAction implements SingleActionInterface
{
use EntityManagerAwareTrait;
public function __construct(
protected readonly SongApiGenerator $songApiGenerator,
protected readonly CacheItemPoolInterface $psr6Cache,
) {
}
/**
* @param int[] $playlists
* @return Paginator<int, array>
*/
protected function getPaginator(
ServerRequest $request,
array $playlists
): Paginator {
$station = $request->getStation();
$queryParams = $request->getQueryParams();
$searchPhrase = trim($queryParams['searchPhrase'] ?? '');
$sortField = (string)($queryParams['sort'] ?? '');
$sortDirection = strtolower($queryParams['sortOrder'] ?? 'asc');
$qb = $this->em->createQueryBuilder();
$qb->select('sm, spm, sp')
->from(StationMedia::class, 'sm')
->leftJoin('sm.playlists', 'spm')
->leftJoin('spm.playlist', 'sp')
->where('sm.storage_location = :storageLocation')
->andWhere('sp.id IN (:playlistIds)')
->setParameter('storageLocation', $station->getMediaStorageLocation())
->setParameter('playlistIds', $playlists);
if (!empty($sortField)) {
match ($sortField) {
'name', 'title' => $qb->addOrderBy('sm.title', $sortDirection),
'artist' => $qb->addOrderBy('sm.artist', $sortDirection),
'album' => $qb->addOrderBy('sm.album', $sortDirection),
'genre' => $qb->addOrderBy('sm.genre', $sortDirection),
default => null,
};
} else {
$qb->orderBy('sm.artist', 'ASC')
->addOrderBy('sm.title', 'ASC');
}
if (!empty($searchPhrase)) {
$qb->andWhere('(sm.title LIKE :query OR sm.artist LIKE :query OR sm.album LIKE :query)')
->setParameter('query', '%' . $searchPhrase . '%');
}
return Paginator::fromQueryBuilder($qb, $request);
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/AbstractSearchableListAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 532 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations;
use App\Controller\Api\AbstractApiCrudController;
use App\Controller\Api\Traits\CanSearchResults;
use App\Controller\Api\Traits\CanSortResults;
use App\Entity\Api\PodcastEpisode as ApiPodcastEpisode;
use App\Entity\ApiGenerator\PodcastEpisodeApiGenerator;
use App\Entity\PodcastEpisode;
use App\Entity\Repository\PodcastEpisodeRepository;
use App\Http\Response;
use App\Http\ServerRequest;
use App\OpenApi;
use App\Service\Flow\UploadedFile;
use Doctrine\Common\Collections\Order;
use OpenApi\Attributes as OA;
use Psr\Http\Message\ResponseInterface;
use Symfony\Component\Serializer\Serializer;
use Symfony\Component\Validator\Validator\ValidatorInterface;
/** @extends AbstractApiCrudController<PodcastEpisode> */
#[
OA\Get(
path: '/station/{station_id}/podcast/{podcast_id}/episodes',
operationId: 'getEpisodes',
description: 'List all current episodes for a given podcast ID.',
security: OpenApi::API_KEY_SECURITY,
tags: ['Stations: Podcasts'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
new OA\Parameter(
name: 'podcast_id',
description: 'Podcast ID',
in: 'path',
required: true,
schema: new OA\Schema(type: 'string')
),
],
responses: [
new OA\Response(
response: 200,
description: 'Success',
content: new OA\JsonContent(
type: 'array',
items: new OA\Items(ref: '#/components/schemas/Api_PodcastEpisode')
)
),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_NOT_FOUND, response: 404),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
),
OA\Post(
path: '/station/{station_id}/podcast/{podcast_id}/episodes',
operationId: 'addEpisode',
description: 'Create a new podcast episode.',
security: OpenApi::API_KEY_SECURITY,
requestBody: new OA\RequestBody(
content: new OA\JsonContent(ref: '#/components/schemas/Api_PodcastEpisode')
),
tags: ['Stations: Podcasts'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
new OA\Parameter(
name: 'podcast_id',
description: 'Podcast ID',
in: 'path',
required: true,
schema: new OA\Schema(type: 'string')
),
],
responses: [
new OA\Response(
response: 200,
description: 'Success',
content: new OA\JsonContent(ref: '#/components/schemas/Api_PodcastEpisode')
),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_NOT_FOUND, response: 404),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
),
OA\Get(
path: '/station/{station_id}/podcast/{podcast_id}/episode/{id}',
operationId: 'getEpisode',
description: 'Retrieve details for a single podcast episode.',
security: OpenApi::API_KEY_SECURITY,
tags: ['Stations: Podcasts'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
new OA\Parameter(
name: 'podcast_id',
description: 'Podcast ID',
in: 'path',
required: true,
schema: new OA\Schema(type: 'string')
),
new OA\Parameter(
name: 'id',
description: 'Podcast Episode ID',
in: 'path',
required: true,
schema: new OA\Schema(type: 'string')
),
],
responses: [
new OA\Response(
response: 200,
description: 'Success',
content: new OA\JsonContent(ref: '#/components/schemas/Api_PodcastEpisode')
),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_NOT_FOUND, response: 404),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
),
OA\Put(
path: '/station/{station_id}/podcast/{podcast_id}/episode/{id}',
operationId: 'editEpisode',
description: 'Update details of a single podcast episode.',
security: OpenApi::API_KEY_SECURITY,
requestBody: new OA\RequestBody(
content: new OA\JsonContent(ref: '#/components/schemas/Api_PodcastEpisode')
),
tags: ['Stations: Podcasts'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
new OA\Parameter(
name: 'podcast_id',
description: 'Podcast ID',
in: 'path',
required: true,
schema: new OA\Schema(type: 'string')
),
new OA\Parameter(
name: 'id',
description: 'Podcast Episode ID',
in: 'path',
required: true,
schema: new OA\Schema(type: 'string')
),
],
responses: [
new OA\Response(ref: OpenApi::REF_RESPONSE_SUCCESS, response: 200),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_NOT_FOUND, response: 404),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
),
OA\Delete(
path: '/station/{station_id}/podcast/{podcast_id}/episode/{id}',
operationId: 'deleteEpisode',
description: 'Delete a single podcast episode.',
security: OpenApi::API_KEY_SECURITY,
tags: ['Stations: Podcasts'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
new OA\Parameter(
name: 'podcast_id',
description: 'Podcast ID',
in: 'path',
required: true,
schema: new OA\Schema(type: 'string')
),
new OA\Parameter(
name: 'id',
description: 'Podcast Episode ID',
in: 'path',
required: true,
schema: new OA\Schema(type: 'string')
),
],
responses: [
new OA\Response(ref: OpenApi::REF_RESPONSE_SUCCESS, response: 200),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_NOT_FOUND, response: 404),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
)
]
class PodcastEpisodesController extends AbstractApiCrudController
{
use CanSearchResults;
use CanSortResults;
protected string $entityClass = PodcastEpisode::class;
protected string $resourceRouteName = 'api:stations:podcast:episode';
public function __construct(
protected readonly PodcastEpisodeRepository $episodeRepository,
protected readonly PodcastEpisodeApiGenerator $episodeApiGen,
Serializer $serializer,
ValidatorInterface $validator,
) {
parent::__construct($serializer, $validator);
}
public function listAction(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
$podcast = $request->getPodcast();
$queryBuilder = $this->em->createQueryBuilder()
->select('e, p, pm')
->from(PodcastEpisode::class, 'e')
->join('e.podcast', 'p')
->leftJoin('e.media', 'pm')
->where('e.podcast = :podcast')
->setParameter('podcast', $podcast);
$queryBuilder = $this->searchQueryBuilder(
$request,
$queryBuilder,
[
'e.title',
]
);
$queryBuilder = $this->sortQueryBuilder(
$request,
$queryBuilder,
[
'publish_at' => 'e.publish_at',
'is_explicit' => 'e.is_explicit',
],
'e.publish_at',
Order::Descending
);
return $this->listPaginatedFromQuery($request, $response, $queryBuilder->getQuery());
}
/**
* @return PodcastEpisode|null
*/
protected function getRecord(ServerRequest $request, array $params): ?object
{
/** @var string $id */
$id = $params['episode_id'];
return $this->episodeRepository->fetchEpisodeForPodcast(
$request->getPodcast(),
$id
);
}
protected function createRecord(ServerRequest $request, array $data): object
{
$station = $request->getStation();
$podcast = $request->getPodcast();
$record = $this->editRecord(
$data,
new PodcastEpisode($podcast)
);
if (!empty($data['artwork_file'])) {
$artwork = UploadedFile::fromArray($data['artwork_file'], $station->getRadioTempDir());
$this->episodeRepository->writeEpisodeArt(
$record,
$artwork->readAndDeleteUploadedFile()
);
$this->em->persist($record);
$this->em->flush();
}
if (!empty($data['media_file'])) {
$media = UploadedFile::fromArray($data['media_file'], $station->getRadioTempDir());
$this->episodeRepository->uploadMedia(
$record,
$media->getClientFilename(),
$media->getUploadedPath()
);
}
return $record;
}
protected function deleteRecord(object $record): void
{
$this->episodeRepository->delete($record);
}
/**
* @inheritDoc
*/
protected function viewRecord(object $record, ServerRequest $request): ApiPodcastEpisode
{
assert($record instanceof PodcastEpisode);
$isInternal = $request->isInternal();
$router = $request->getRouter();
$return = $this->episodeApiGen->__invoke($record, $request);
$baseRouteParams = [
'station_id' => $request->getStation()->getIdRequired(),
'podcast_id' => $record->getPodcast()->getIdRequired(),
'episode_id' => $record->getIdRequired(),
];
$artRouteParams = $baseRouteParams;
if (0 !== $return->art_updated_at) {
$artRouteParams['timestamp'] = $return->art_updated_at;
}
$return->art = $router->named(
routeName: 'api:stations:podcast:episode:art',
routeParams: $artRouteParams,
absolute: !$isInternal
);
$return->links = [
...$return->links,
'self' => $router->fromHere(
routeName: $this->resourceRouteName,
routeParams: $baseRouteParams,
absolute: !$isInternal
),
'art' => $router->named(
routeName: 'api:stations:podcast:episode:art',
routeParams: $baseRouteParams,
absolute: !$isInternal
),
'media' => $router->fromHere(
routeName: 'api:stations:podcast:episode:media',
routeParams: $baseRouteParams,
absolute: !$isInternal
),
];
return $return;
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/PodcastEpisodesController.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 2,559 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations;
use App\Controller\Api\Traits\HasScheduleDisplay;
use App\Entity\Repository\StationScheduleRepository;
use App\Entity\StationPlaylist;
use App\Entity\StationStreamer;
use App\Exception\ValidationException;
use App\Http\Response;
use App\Http\ServerRequest;
use App\Radio\AutoDJ\Scheduler;
use Carbon\CarbonImmutable;
use InvalidArgumentException;
use Psr\Http\Message\ResponseInterface;
use Symfony\Component\Serializer\Serializer;
use Symfony\Component\Validator\Validator\ValidatorInterface;
/**
* @template TEntity as StationPlaylist|StationStreamer
* @extends AbstractStationApiCrudController<TEntity>
*/
abstract class AbstractScheduledEntityController extends AbstractStationApiCrudController
{
use HasScheduleDisplay;
public function __construct(
protected StationScheduleRepository $scheduleRepo,
protected Scheduler $scheduler,
Serializer $serializer,
ValidatorInterface $validator,
) {
parent::__construct($serializer, $validator);
}
protected function renderEvents(
ServerRequest $request,
Response $response,
array $scheduleItems,
callable $rowRender
): ResponseInterface {
$station = $request->getStation();
$tz = $station->getTimezoneObject();
$dateRange = $this->getDateRange($request, $tz);
$now = CarbonImmutable::now($tz);
$events = $this->getEvents($dateRange, $now, $this->scheduler, $scheduleItems, $rowRender);
return $response->withJson($events);
}
protected function editRecord(?array $data, object $record = null, array $context = []): object
{
if (null === $data) {
throw new InvalidArgumentException('Could not parse input data.');
}
$scheduleItems = $data['schedule_items'] ?? null;
unset($data['schedule_items']);
$record = $this->fromArray($data, $record, $context);
$errors = $this->validator->validate($record);
if (count($errors) > 0) {
throw ValidationException::fromValidationErrors($errors);
}
$this->em->persist($record);
$this->em->flush();
if (null !== $scheduleItems) {
$this->scheduleRepo->setScheduleItems($record, $scheduleItems);
}
return $record;
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/AbstractScheduledEntityController.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 503 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations\LiquidsoapConfig;
use App\Controller\SingleActionInterface;
use App\Entity\StationBackendConfiguration;
use App\Event\Radio\WriteLiquidsoapConfiguration;
use App\Http\Response;
use App\Http\ServerRequest;
use App\Radio\Backend\Liquidsoap\ConfigWriter;
use Psr\EventDispatcher\EventDispatcherInterface;
use Psr\Http\Message\ResponseInterface;
final class GetAction implements SingleActionInterface
{
public function __construct(
private readonly EventDispatcherInterface $eventDispatcher,
) {
}
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
$station = $request->getStation();
$configSections = StationBackendConfiguration::getCustomConfigurationSections();
$tokens = ConfigWriter::getDividerString();
$event = new WriteLiquidsoapConfiguration($station, true, false);
$this->eventDispatcher->dispatch($event);
$config = $event->buildConfiguration();
$areas = [];
$tok = strtok($config, $tokens);
while ($tok !== false) {
$tok = trim($tok);
if (in_array($tok, $configSections, true)) {
$areas[] = [
'is_field' => true,
'field_name' => $tok,
];
} elseif (!empty($tok)) {
$areas[] = [
'is_field' => false,
'markup' => $tok,
];
}
$tok = strtok($tokens);
}
$backendConfig = $request->getStation()->getBackendConfig();
$contents = [];
foreach ($configSections as $field) {
$contents[$field] = $backendConfig->getCustomConfigurationSection($field);
}
return $response->withJson([
'config' => $areas,
'sections' => $configSections,
'contents' => $contents,
]);
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/LiquidsoapConfig/GetAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 422 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations\LiquidsoapConfig;
use App\Container\EntityManagerAwareTrait;
use App\Controller\SingleActionInterface;
use App\Entity\Api\Error;
use App\Entity\Api\Status;
use App\Entity\StationBackendConfiguration;
use App\Event\Radio\WriteLiquidsoapConfiguration;
use App\Http\Response;
use App\Http\ServerRequest;
use App\Radio\Backend\Liquidsoap;
use Psr\EventDispatcher\EventDispatcherInterface;
use Psr\Http\Message\ResponseInterface;
use Throwable;
final class PutAction implements SingleActionInterface
{
use EntityManagerAwareTrait;
public function __construct(
private readonly EventDispatcherInterface $eventDispatcher,
private readonly Liquidsoap $liquidsoap,
) {
}
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
$body = (array)$request->getParsedBody();
$station = $this->em->refetch($request->getStation());
$backendConfig = $station->getBackendConfig();
foreach (StationBackendConfiguration::getCustomConfigurationSections() as $field) {
if (isset($body[$field])) {
$backendConfig->setCustomConfigurationSection($field, $body[$field]);
}
}
$station->setBackendConfig($backendConfig);
$this->em->persist($station);
$this->em->flush();
try {
$event = new WriteLiquidsoapConfiguration($station, false, false);
$this->eventDispatcher->dispatch($event);
$config = $event->buildConfiguration();
$this->liquidsoap->verifyConfig($config);
} catch (Throwable $e) {
return $response->withStatus(500)->withJson(Error::fromException($e));
}
return $response->withJson(Status::updated());
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/LiquidsoapConfig/PutAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 398 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations\Mounts\Intro;
use App\Controller\SingleActionInterface;
use App\Entity\Api\Status;
use App\Entity\Repository\StationMountRepository;
use App\Http\Response;
use App\Http\ServerRequest;
use App\OpenApi;
use OpenApi\Attributes as OA;
use Psr\Http\Message\ResponseInterface;
#[OA\Delete(
path: '/station/{station_id}/mount/{id}/intro',
operationId: 'deleteMountIntro',
description: 'Removes the intro track for a mount point.',
security: OpenApi::API_KEY_SECURITY,
tags: ['Stations: Mount Points'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
new OA\Parameter(
name: 'id',
description: 'Mount Point ID',
in: 'path',
required: true,
schema: new OA\Schema(type: 'integer', format: 'int64')
),
],
responses: [
new OA\Response(ref: OpenApi::REF_RESPONSE_SUCCESS, response: 200),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_NOT_FOUND, response: 404),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
)]
final class DeleteIntroAction implements SingleActionInterface
{
public function __construct(
private readonly StationMountRepository $mountRepo,
) {
}
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
/** @var string $id */
$id = $params['id'];
$station = $request->getStation();
$mount = $this->mountRepo->requireForStation($id, $station);
$this->mountRepo->clearIntro($mount);
return $response->withJson(Status::deleted());
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/Mounts/Intro/DeleteIntroAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 428 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations\Mounts\Intro;
use App\Controller\SingleActionInterface;
use App\Entity\Api\Error;
use App\Entity\Repository\StationMountRepository;
use App\Entity\StationMount;
use App\Flysystem\StationFilesystems;
use App\Http\Response;
use App\Http\ServerRequest;
use App\OpenApi;
use OpenApi\Attributes as OA;
use Psr\Http\Message\ResponseInterface;
#[OA\Get(
path: '/station/{station_id}/mount/{id}/intro',
operationId: 'getMountIntro',
description: 'Get the intro track for a mount point.',
security: OpenApi::API_KEY_SECURITY,
tags: ['Stations: Mount Points'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
new OA\Parameter(
name: 'id',
description: 'Mount Point ID',
in: 'path',
required: true,
schema: new OA\Schema(type: 'integer', format: 'int64')
),
],
responses: [
new OA\Response(
response: 200,
description: 'Success'
),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_NOT_FOUND, response: 404),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
)]
final class GetIntroAction implements SingleActionInterface
{
public function __construct(
private readonly StationMountRepository $mountRepo,
) {
}
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
set_time_limit(600);
/** @var string $id */
$id = $params['id'];
$station = $request->getStation();
$mount = $this->mountRepo->findForStation($id, $station);
if ($mount instanceof StationMount) {
$introPath = $mount->getIntroPath();
if (!empty($introPath)) {
$fsConfig = StationFilesystems::buildConfigFilesystem($station);
if ($fsConfig->fileExists($introPath)) {
return $response->streamFilesystemFile(
$fsConfig,
$introPath,
basename($introPath)
);
}
}
}
return $response->withStatus(404)
->withJson(Error::notFound());
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/Mounts/Intro/GetIntroAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 541 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations;
use App\Container\EntityManagerAwareTrait;
use App\Entity\Api\StationServiceStatus;
use App\Entity\Api\Status;
use App\Entity\Station;
use App\Exception\Supervisor\NotRunningException;
use App\Http\Response;
use App\Http\ServerRequest;
use App\Nginx\Nginx;
use App\OpenApi;
use App\Radio\Adapters;
use App\Radio\Configuration;
use OpenApi\Attributes as OA;
use Psr\Http\Message\ResponseInterface;
#[
OA\Get(
path: '/station/{station_id}/status',
operationId: 'getServiceStatus',
description: 'Retrieve the current status of all serivces associated with the radio broadcast.',
security: OpenApi::API_KEY_SECURITY,
tags: ['Stations: Service Control'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
],
responses: [
new OA\Response(
response: 200,
description: 'Success',
content: new OA\JsonContent(
ref: '#/components/schemas/Api_StationServiceStatus'
)
),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_NOT_FOUND, response: 404),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
),
OA\Post(
path: '/station/{station_id}/restart',
operationId: 'restartServices',
description: 'Restart all services associated with the radio broadcast.',
security: OpenApi::API_KEY_SECURITY,
tags: ['Stations: Service Control'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
],
responses: [
new OA\Response(ref: OpenApi::REF_RESPONSE_SUCCESS, response: 200),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_NOT_FOUND, response: 404),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
),
OA\Post(
path: '/station/{station_id}/frontend/{action}',
operationId: 'doFrontendServiceAction',
description: 'Perform service control actions on the radio frontend (Icecast, Shoutcast, etc.)',
security: OpenApi::API_KEY_SECURITY,
tags: ['Stations: Service Control'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
new OA\Parameter(
name: 'action',
description: 'The action to perform (start, stop, restart)',
in: 'path',
required: true,
schema: new OA\Schema(type: 'string', default: 'restart')
),
],
responses: [
new OA\Response(ref: OpenApi::REF_RESPONSE_SUCCESS, response: 200),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_NOT_FOUND, response: 404),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
),
OA\Post(
path: '/station/{station_id}/backend/{action}',
operationId: 'doBackendServiceAction',
description: 'Perform service control actions on the radio backend (Liquidsoap)',
security: OpenApi::API_KEY_SECURITY,
tags: ['Stations: Service Control'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
new OA\Parameter(
name: 'action',
description: 'The action to perform (for all: start, stop, restart, skip, disconnect)',
in: 'path',
required: true,
schema: new OA\Schema(type: 'string', default: 'restart')
),
],
responses: [
new OA\Response(ref: OpenApi::REF_RESPONSE_SUCCESS, response: 200),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_NOT_FOUND, response: 404),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
)
]
final class ServicesController
{
use EntityManagerAwareTrait;
public function __construct(
private readonly Configuration $configuration,
private readonly Nginx $nginx,
private readonly Adapters $adapters,
) {
}
public function statusAction(
ServerRequest $request,
Response $response
): ResponseInterface {
$station = $request->getStation();
$backend = $this->adapters->getBackendAdapter($station);
$frontend = $this->adapters->getFrontendAdapter($station);
return $response->withJson(
new StationServiceStatus(
null !== $backend && $backend->isRunning($station),
null !== $frontend && $frontend->isRunning($station),
$station->getHasStarted(),
$station->getNeedsRestart()
)
);
}
public function reloadAction(
ServerRequest $request,
Response $response
): ResponseInterface {
$this->reloadOrRestartStation($request->getStation(), true);
return $response->withJson(new Status(true, __('Station reloaded.')));
}
public function restartAction(
ServerRequest $request,
Response $response
): ResponseInterface {
$this->reloadOrRestartStation($request->getStation(), false);
return $response->withJson(new Status(true, __('Station restarted.')));
}
protected function reloadOrRestartStation(
Station $station,
bool $attemptReload
): void {
$station->setHasStarted(true);
$this->em->persist($station);
$this->em->flush();
$this->configuration->writeConfiguration(
station: $station,
forceRestart: true,
attemptReload: $attemptReload
);
$this->nginx->writeConfiguration($station);
}
public function frontendAction(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
/** @var string $do */
$do = $params['do'] ?? 'restart';
$station = $request->getStation();
$frontend = $this->adapters->requireFrontendAdapter($station);
switch ($do) {
case 'stop':
$frontend->stop($station);
return $response->withJson(new Status(true, __('Service stopped.')));
case 'start':
$frontend->start($station);
return $response->withJson(new Status(true, __('Service started.')));
case 'reload':
$frontend->write($station);
$frontend->reload($station);
return $response->withJson(new Status(true, __('Service reloaded.')));
case 'restart':
default:
try {
$frontend->stop($station);
} catch (NotRunningException) {
}
$frontend->write($station);
$frontend->start($station);
return $response->withJson(new Status(true, __('Service restarted.')));
}
}
public function backendAction(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
/** @var string $do */
$do = $params['do'] ?? 'restart';
$station = $request->getStation();
$backend = $this->adapters->requireBackendAdapter($station);
switch ($do) {
case 'skip':
$backend->skip($station);
return $response->withJson(new Status(true, __('Song skipped.')));
case 'disconnect':
$backend->disconnectStreamer($station);
return $response->withJson(new Status(true, __('Streamer disconnected.')));
case 'stop':
$backend->stop($station);
return $response->withJson(new Status(true, __('Service stopped.')));
case 'start':
$backend->start($station);
return $response->withJson(new Status(true, __('Service started.')));
case 'reload':
$backend->write($station);
$backend->reload($station);
return $response->withJson(new Status(true, __('Service reloaded.')));
case 'restart':
default:
try {
$backend->stop($station);
} catch (NotRunningException) {
}
$backend->write($station);
$backend->start($station);
return $response->withJson(new Status(true, __('Service restarted.')));
}
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/ServicesController.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 1,867 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations\Mounts\Intro;
use App\Controller\SingleActionInterface;
use App\Entity\Api\Status;
use App\Entity\Repository\StationMountRepository;
use App\Http\Response;
use App\Http\ServerRequest;
use App\OpenApi;
use App\Service\Flow;
use OpenApi\Attributes as OA;
use Psr\Http\Message\ResponseInterface;
#[OA\Post(
path: '/station/{station_id}/mount/{id}/intro',
operationId: 'postMountIntro',
description: 'Update the intro track for a mount point.',
security: OpenApi::API_KEY_SECURITY,
tags: ['Stations: Mount Points'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
new OA\Parameter(
name: 'id',
description: 'Mount Point ID',
in: 'path',
required: true,
schema: new OA\Schema(type: 'integer', format: 'int64')
),
],
responses: [
new OA\Response(ref: OpenApi::REF_RESPONSE_SUCCESS, response: 200),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_NOT_FOUND, response: 404),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
)]
final class PostIntroAction implements SingleActionInterface
{
public function __construct(
private readonly StationMountRepository $mountRepo,
) {
}
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
/** @var string|null $id */
$id = $params['id'] ?? null;
$station = $request->getStation();
$flowResponse = Flow::process($request, $response, $station->getRadioTempDir());
if ($flowResponse instanceof ResponseInterface) {
return $flowResponse;
}
if (null !== $id) {
$mount = $this->mountRepo->requireForStation($id, $station);
$this->mountRepo->setIntro($mount, $flowResponse);
return $response->withJson(Status::updated());
}
return $response->withJson($flowResponse);
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/Mounts/Intro/PostIntroAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 502 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations\Fallback;
use App\Controller\SingleActionInterface;
use App\Entity\Api\Status;
use App\Entity\Repository\StationRepository;
use App\Http\Response;
use App\Http\ServerRequest;
use App\OpenApi;
use App\Service\Flow;
use OpenApi\Attributes as OA;
use Psr\Http\Message\ResponseInterface;
#[OA\Post(
path: '/station/{station_id}/fallback',
operationId: 'postStationFallback',
description: 'Update the custom fallback track for the station.',
security: OpenApi::API_KEY_SECURITY,
tags: ['Stations: General'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
],
responses: [
new OA\Response(ref: OpenApi::REF_RESPONSE_SUCCESS, response: 200),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_NOT_FOUND, response: 404),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
)]
final class PostFallbackAction implements SingleActionInterface
{
public function __construct(
private readonly StationRepository $stationRepo
) {
}
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
$station = $request->getStation();
$flowResponse = Flow::process($request, $response, $station->getRadioTempDir());
if ($flowResponse instanceof ResponseInterface) {
return $flowResponse;
}
$this->stationRepo->setFallback($station, $flowResponse);
return $response->withJson(Status::updated());
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/Fallback/PostFallbackAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 380 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations\Fallback;
use App\Controller\SingleActionInterface;
use App\Entity\Api\Status;
use App\Entity\Repository\StationRepository;
use App\Http\Response;
use App\Http\ServerRequest;
use App\OpenApi;
use OpenApi\Attributes as OA;
use Psr\Http\Message\ResponseInterface;
#[OA\Delete(
path: '/station/{station_id}/fallback',
operationId: 'deleteStationFallback',
description: 'Removes the custom fallback track for a station.',
security: OpenApi::API_KEY_SECURITY,
tags: ['Stations: General'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
],
responses: [
new OA\Response(ref: OpenApi::REF_RESPONSE_SUCCESS, response: 200),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_NOT_FOUND, response: 404),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
)]
final class DeleteFallbackAction implements SingleActionInterface
{
public function __construct(
private readonly StationRepository $stationRepo,
) {
}
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
$station = $request->getStation();
$this->stationRepo->clearFallback($station);
return $response->withJson(Status::deleted());
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/Fallback/DeleteFallbackAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 332 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations\Fallback;
use App\Controller\SingleActionInterface;
use App\Entity\Api\Error;
use App\Flysystem\StationFilesystems;
use App\Http\Response;
use App\Http\ServerRequest;
use App\OpenApi;
use OpenApi\Attributes as OA;
use Psr\Http\Message\ResponseInterface;
#[OA\Get(
path: '/station/{station_id}/fallback',
operationId: 'getStationFallback',
description: 'Get the custom fallback track for a station.',
security: OpenApi::API_KEY_SECURITY,
tags: ['Stations: General'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
],
responses: [
new OA\Response(
response: 200,
description: 'Success'
),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_NOT_FOUND, response: 404),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
)]
final class GetFallbackAction implements SingleActionInterface
{
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
$station = $request->getStation();
$router = $request->getRouter();
$download = ($params['do'] ?? null) === 'download';
$fallbackPath = $station->getFallbackPath();
if (!empty($fallbackPath)) {
$fsConfig = StationFilesystems::buildConfigFilesystem($station);
if ($fsConfig->fileExists($fallbackPath)) {
if ($download) {
set_time_limit(600);
return $response->streamFilesystemFile(
$fsConfig,
$fallbackPath,
basename($fallbackPath)
);
}
return $response->withJson([
'hasRecord' => true,
'links' => [
'download' => $router->fromHere(
routeParams: ['do' => 'download']
),
],
]);
}
}
if ($download) {
return $response->withStatus(404)
->withJson(Error::notFound());
}
return $response->withJson([
'hasRecord' => false,
'links' => [
'download' => null,
],
]);
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/Fallback/GetFallbackAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 524 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations\BulkMedia;
use App\Container\EntityManagerAwareTrait;
use App\Controller\SingleActionInterface;
use App\Entity\Api\StationPlaylistImportResult;
use App\Entity\Repository\CustomFieldRepository;
use App\Entity\Repository\StationPlaylistMediaRepository;
use App\Entity\Repository\StationPlaylistRepository;
use App\Entity\Station;
use App\Entity\StationMedia;
use App\Entity\StationMediaMetadata;
use App\Entity\StationPlaylist;
use App\Exception\ValidationException;
use App\Http\Response;
use App\Http\ServerRequest;
use App\Service\Flow;
use League\Csv\Reader;
use Psr\Http\Message\ResponseInterface;
use Symfony\Component\Serializer\Normalizer\AbstractNormalizer;
use Symfony\Component\Serializer\Serializer;
use Symfony\Component\Validator\Validator\ValidatorInterface;
use Throwable;
use function count;
use function str_starts_with;
final class UploadAction implements SingleActionInterface
{
use EntityManagerAwareTrait;
private const array ALLOWED_MEDIA_FIELDS = [
'title',
'artist',
'album',
'genre',
'lyrics',
'isrc',
'amplify',
'fade_overlap',
'fade_in',
'fade_out',
'cue_in',
'cue_out',
];
public function __construct(
private readonly CustomFieldRepository $customFieldRepo,
private readonly StationPlaylistRepository $playlistRepo,
private readonly StationPlaylistMediaRepository $spmRepo,
private readonly Serializer $serializer,
private readonly ValidatorInterface $validator,
) {
}
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
$station = $request->getStation();
// Handle Flow upload.
$flowResponse = Flow::process($request, $response, $station->getRadioTempDir());
if ($flowResponse instanceof ResponseInterface) {
return $flowResponse;
}
// Lookup tables for later.
$mediaStorage = $station->getMediaStorageLocation();
$mediaByPath = [];
$mediaByUniqueId = [];
$mediaInStorageLocation = $this->em->createQuery(
<<<DQL
SELECT sm.id, sm.unique_id, sm.path
FROM App\Entity\StationMedia sm
WHERE sm.storage_location = :storageLocation
DQL
)->setParameter('storageLocation', $mediaStorage)
->getArrayResult();
foreach ($mediaInStorageLocation as $mediaRow) {
$mediaByPath[md5($mediaRow['path'])] = $mediaRow['id'];
$mediaByUniqueId[$mediaRow['unique_id']] = $mediaRow['id'];
}
$extraMetadataFieldNames = StationMediaMetadata::getFields();
$customFieldShortNames = [];
foreach ($this->customFieldRepo->fetchArray() as $row) {
$customFieldShortNames[$row['short_name']] = $row['id'];
}
$playlistsByName = [];
foreach ($this->playlistRepo->getAllForStation($station) as $playlist) {
$shortName = StationPlaylist::generateShortName($playlist->getName());
$playlistsByName[$shortName] = $playlist->getIdRequired();
}
// Read and process CSV.
$csvPath = $flowResponse->getUploadedPath();
$reader = Reader::createFromPath($csvPath);
$reader->setHeaderOffset(0);
$processed = 0;
$importResults = [];
$i = 0;
$batchSize = 50;
foreach ($reader->getRecords() as $row) {
$row = (array)$row;
if (isset($row['id'], $mediaByUniqueId[$row['id']])) {
$mediaId = $mediaByUniqueId[$row['id']];
} elseif (isset($row['path'], $mediaByPath[md5($row['path'])])) {
$mediaId = $mediaByPath[md5($row['path'])];
} else {
continue;
}
$record = $this->em->find(StationMedia::class, $mediaId);
if (!($record instanceof StationMedia)) {
continue;
}
unset($row['id'], $row['path']);
$importResult = [
'id' => $record->getIdRequired(),
'title' => $record->getTitle(),
'artist' => $record->getArtist(),
'success' => false,
'error' => null,
];
try {
$rowResult = $this->processRow(
$record,
$station,
$row,
$extraMetadataFieldNames,
$customFieldShortNames,
$playlistsByName
);
$importResult['success'] = $rowResult;
if ($rowResult) {
$processed++;
}
} catch (Throwable $e) {
$importResult['success'] = false;
$importResult['error'] = $e->getMessage();
}
$importResults[] = $importResult;
$i++;
if (0 === $i % $batchSize) {
$this->clearMemory();
}
}
$this->clearMemory();
@unlink($csvPath);
return $response->withJson(
new StationPlaylistImportResult(
message: sprintf(__('%d files processed.'), $processed),
importResults: $importResults
)
);
}
private function processRow(
StationMedia $record,
Station $station,
array $row,
array $extraMetadataFieldNames,
array $customFieldShortNames,
array $playlistsByName
): bool {
$mediaRow = [];
$extraMetadata = [];
$hasCustomFields = false;
$customFields = [];
$hasPlaylists = false;
$playlists = [];
foreach ($row as $key => $value) {
if ('' === $value) {
$value = null;
}
if (in_array($key, self::ALLOWED_MEDIA_FIELDS, true)) {
$mediaRow[$key] = $value;
} elseif (in_array($key, $extraMetadataFieldNames, true)) {
$extraMetadata[$key] = $value;
} elseif (str_starts_with($key, 'custom_field_')) {
$fieldName = str_replace('custom_field_', '', $key);
if (isset($customFieldShortNames[$fieldName])) {
$hasCustomFields = true;
$customFields[$customFieldShortNames[$fieldName]] = $value;
}
} elseif ('playlists' === $key) {
$hasPlaylists = true;
if (null !== $value) {
foreach (explode(',', $value) as $playlistName) {
$playlistShortName = StationPlaylist::generateShortName($playlistName);
if (isset($playlistsByName[$playlistShortName])) {
/** @var int $playlistId */
$playlistId = $playlistsByName[$playlistShortName];
$playlists[$playlistId] = 0;
}
}
}
}
}
if (!empty($extraMetadata)) {
$mediaRow['extra_metadata'] = $extraMetadata;
}
if (empty($mediaRow) && !$hasPlaylists && !$hasCustomFields) {
return false;
}
if (!empty($mediaRow)) {
$this->serializer->denormalize(
$mediaRow,
StationMedia::class,
context: [
AbstractNormalizer::OBJECT_TO_POPULATE => $record,
]
);
$errors = $this->validator->validate($record);
if (count($errors) > 0) {
throw ValidationException::fromValidationErrors($errors);
}
$this->em->persist($record);
$this->em->flush();
}
if ($hasPlaylists) {
$this->spmRepo->setPlaylistsForMedia(
$record,
$station,
$playlists
);
}
if ($hasCustomFields) {
$customFields = array_filter($customFields);
$this->customFieldRepo->setCustomFields($record, $customFields);
}
return true;
}
private function clearMemory(): void
{
$this->em->clear();
gc_collect_cycles();
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/BulkMedia/UploadAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 1,799 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations\BulkMedia;
use App\Container\EntityManagerAwareTrait;
use App\Controller\SingleActionInterface;
use App\Entity\Repository\CustomFieldRepository;
use App\Entity\Repository\StationPlaylistRepository;
use App\Entity\StationMediaMetadata;
use App\Http\Response;
use App\Http\ServerRequest;
use League\Csv\Writer;
use Psr\Http\Message\ResponseInterface;
use RuntimeException;
final class DownloadAction implements SingleActionInterface
{
use EntityManagerAwareTrait;
public function __construct(
private readonly CustomFieldRepository $customFieldRepo,
private readonly StationPlaylistRepository $playlistRepo,
) {
}
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
$station = $request->getStation();
$customFields = [];
foreach ($this->customFieldRepo->fetchArray() as $row) {
$customFields[$row['id']] = $row['short_name'];
}
$playlistsById = [];
foreach ($this->playlistRepo->getAllForStation($station) as $playlist) {
$playlistsById[$playlist->getIdRequired()] = $playlist->getName();
}
$query = $this->em->createQuery(
<<<DQL
SELECT sm, spm, smcf
FROM App\Entity\StationMedia sm
LEFT JOIN sm.playlists spm
LEFT JOIN sm.custom_fields smcf
WHERE sm.storage_location = :storageLocation
DQL
)->setParameter('storageLocation', $station->getMediaStorageLocation());
$filename = $station->getShortName() . '_all_media.csv';
if (!($tempFile = tmpfile())) {
throw new RuntimeException('Could not create temp file.');
}
$csv = Writer::createFromStream($tempFile);
$extraMetadataFields = StationMediaMetadata::getFields();
/*
* NOTE: These field names should correspond with DB property names when converted into short_names.
* i.e. Fade Overlap -> fade_overlap
*/
$headerRow = [
'id',
'path',
'title',
'artist',
'album',
'genre',
'lyrics',
'isrc',
'playlists',
...$extraMetadataFields,
];
foreach ($customFields as $customField) {
$headerRow[] = 'custom_field_' . $customField;
}
$csv->insertOne($headerRow);
/** @var array $row */
foreach ($query->getArrayResult() as $row) {
$extraMetadata = [];
foreach ($extraMetadataFields as $fieldName) {
$extraMetadata[] = $row['extra_metadata'][$fieldName] ?? '';
}
$customFieldsById = [];
foreach ($row['custom_fields'] ?? [] as $rowCustomField) {
$customFieldsById[$rowCustomField['field_id']] = $rowCustomField['value'];
}
$playlists = [];
foreach ($row['playlists'] ?? [] as $rowPlaylistMedia) {
if (isset($playlistsById[$rowPlaylistMedia['playlist_id']])) {
$playlists[] = $playlistsById[$rowPlaylistMedia['playlist_id']];
}
}
$bodyRow = [
$row['unique_id'] ?? '',
$row['path'] ?? '',
$row['title'] ?? '',
$row['artist'] ?? '',
$row['album'] ?? '',
$row['genre'] ?? '',
$row['lyrics'] ?? '',
$row['isrc'] ?? '',
implode(', ', $playlists),
...$extraMetadata,
];
foreach ($customFields as $customFieldId => $customField) {
$bodyRow[] = $customFieldsById[$customFieldId] ?? '';
}
$csv->insertOne($bodyRow);
}
return $response->withFileDownload($tempFile, $filename, 'text/csv');
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/BulkMedia/DownloadAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 863 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations\StereoTool;
use App\Controller\SingleActionInterface;
use App\Entity\Api\Status;
use App\Entity\Repository\StationRepository;
use App\Http\Response;
use App\Http\ServerRequest;
use App\OpenApi;
use App\Service\Flow;
use OpenApi\Attributes as OA;
use Psr\Http\Message\ResponseInterface;
#[OA\Post(
path: '/station/{station_id}/stereo-tool-configuration',
operationId: 'postStereoToolConfiguration',
description: 'Update the Stereo Tool configuration file for a station.',
security: OpenApi::API_KEY_SECURITY,
tags: ['Stations: Broadcasting'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
],
responses: [
new OA\Response(ref: OpenApi::REF_RESPONSE_SUCCESS, response: 200),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_NOT_FOUND, response: 404),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
)]
final class PostStereoToolConfigurationAction implements SingleActionInterface
{
public function __construct(
private readonly StationRepository $stationRepo
) {
}
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
$station = $request->getStation();
$flowResponse = Flow::process($request, $response, $station->getRadioTempDir());
if ($flowResponse instanceof ResponseInterface) {
return $flowResponse;
}
$this->stationRepo->setStereoToolConfiguration($station, $flowResponse);
return $response->withJson(Status::updated());
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/StereoTool/PostStereoToolConfigurationAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 395 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations\StereoTool;
use App\Controller\SingleActionInterface;
use App\Entity\Api\Error;
use App\Flysystem\StationFilesystems;
use App\Http\Response;
use App\Http\ServerRequest;
use App\OpenApi;
use OpenApi\Attributes as OA;
use Psr\Http\Message\ResponseInterface;
#[OA\Get(
path: '/station/{station_id}/stereo-tool-configuration',
operationId: 'getStereoToolConfiguration',
description: 'Get the Stereo Tool configuration file for a station.',
security: OpenApi::API_KEY_SECURITY,
tags: ['Stations: Broadcasting'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
],
responses: [
new OA\Response(
response: 200,
description: 'Success'
),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_NOT_FOUND, response: 404),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
)]
final class GetStereoToolConfigurationAction implements SingleActionInterface
{
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
$router = $request->getRouter();
$station = $request->getStation();
$download = ($params['do'] ?? null) === 'download';
$stereoToolConfigurationPath = $station->getBackendConfig()->getStereoToolConfigurationPath();
if (!empty($stereoToolConfigurationPath)) {
$fsConfig = StationFilesystems::buildConfigFilesystem($station);
if ($fsConfig->fileExists($stereoToolConfigurationPath)) {
if ($download) {
set_time_limit(600);
return $response->streamFilesystemFile(
$fsConfig,
$stereoToolConfigurationPath,
basename($stereoToolConfigurationPath)
);
}
return $response->withJson([
'hasRecord' => true,
'links' => [
'download' => $router->fromHere(routeParams: ['do' => 'download']),
],
]);
}
}
if ($download) {
return $response->withStatus(404)
->withJson(Error::notFound());
}
return $response->withJson([
'hasRecord' => false,
'links' => [
'download' => null,
],
]);
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/StereoTool/GetStereoToolConfigurationAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 554 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations\Vue;
use App\Container\EntityManagerAwareTrait;
use App\Controller\SingleActionInterface;
use App\Entity\Enums\PlaylistSources;
use App\Entity\Repository\CustomFieldRepository;
use App\Enums\StationFeatures;
use App\Http\Response;
use App\Http\ServerRequest;
use App\Media\MimeType;
use Psr\Http\Message\ResponseInterface;
final class FilesAction implements SingleActionInterface
{
use EntityManagerAwareTrait;
public function __construct(
private readonly CustomFieldRepository $customFieldRepo
) {
}
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
$station = $request->getStation();
$playlists = $this->em->createQuery(
<<<'DQL'
SELECT sp.id, sp.name
FROM App\Entity\StationPlaylist sp
WHERE sp.station_id = :station_id AND sp.source = :source
ORDER BY sp.name ASC
DQL
)->setParameter('station_id', $station->getId())
->setParameter('source', PlaylistSources::Songs->value)
->getArrayResult();
$backendEnum = $station->getBackendType();
return $response->withJson([
'initialPlaylists' => $playlists,
'customFields' => $this->customFieldRepo->fetchArray(),
'validMimeTypes' => MimeType::getProcessableTypes(),
'showSftp' => StationFeatures::Sftp->supportedForStation($station),
'supportsImmediateQueue' => $backendEnum->isEnabled(),
]);
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/Vue/FilesAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 356 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations\Vue;
use App\Container\SettingsAwareTrait;
use App\Controller\SingleActionInterface;
use App\Http\Response;
use App\Http\ServerRequest;
use App\Service\AzuraCastCentral;
use Psr\Http\Message\ResponseInterface;
final class StreamersAction implements SingleActionInterface
{
use SettingsAwareTrait;
public function __construct(
private readonly AzuraCastCentral $acCentral,
) {
}
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
$station = $request->getStation();
$settings = $this->readSettings();
$backendConfig = $station->getBackendConfig();
return $response->withJson([
'connectionInfo' => [
'serverUrl' => $settings->getBaseUrl(),
'streamPort' => $backendConfig->getDjPort(),
'ip' => $this->acCentral->getIp(),
'djMountPoint' => $backendConfig->getDjMountPoint(),
],
]);
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/Vue/StreamersAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 242 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations\StereoTool;
use App\Controller\SingleActionInterface;
use App\Entity\Api\Status;
use App\Entity\Repository\StationRepository;
use App\Http\Response;
use App\Http\ServerRequest;
use App\OpenApi;
use OpenApi\Attributes as OA;
use Psr\Http\Message\ResponseInterface;
#[OA\Delete(
path: '/station/{station_id}/stereo-tool-configuration',
operationId: 'deleteStereoToolConfiguration',
description: 'Removes the Stereo Tool configuration file for a station.',
security: OpenApi::API_KEY_SECURITY,
tags: ['Stations: Broadcasting'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
],
responses: [
new OA\Response(ref: OpenApi::REF_RESPONSE_SUCCESS, response: 200),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_NOT_FOUND, response: 404),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
)]
final class DeleteStereoToolConfigurationAction implements SingleActionInterface
{
public function __construct(
private readonly StationRepository $stationRepo
) {
}
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
$station = $request->getStation();
$this->stationRepo->clearStereoToolConfiguration($station);
return $response->withJson(Status::deleted());
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/StereoTool/DeleteStereoToolConfigurationAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 347 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations\Vue;
use App\Container\EnvironmentAwareTrait;
use App\Controller\SingleActionInterface;
use App\Http\Response;
use App\Http\ServerRequest;
use App\Service\AzuraCastCentral;
use Psr\Http\Message\ResponseInterface;
final class SftpUsersAction implements SingleActionInterface
{
use EnvironmentAwareTrait;
public function __construct(
private readonly AzuraCastCentral $acCentral
) {
}
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
$baseUrl = $request->getRouter()->getBaseUrl()
->withScheme('sftp')
->withPort(null);
$port = $this->environment->getSftpPort();
return $response->withJson([
'connectionInfo' => [
'url' => (string)$baseUrl,
'ip' => $this->acCentral->getIp(),
'port' => $port,
],
]);
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/Vue/SftpUsersAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 226 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations\Vue;
use App\Controller\SingleActionInterface;
use App\Http\Response;
use App\Http\ServerRequest;
use Psr\Http\Message\ResponseInterface;
final class RestartAction implements SingleActionInterface
{
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
$station = $request->getStation();
$frontendEnum = $station->getFrontendType();
return $response->withJson([
'canReload' => $frontendEnum->supportsReload(),
]);
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/Vue/RestartAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 133 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations\Vue;
use App\Controller\SingleActionInterface;
use App\Http\Response;
use App\Http\ServerRequest;
use Psr\Http\Message\ResponseInterface;
final class MountsAction implements SingleActionInterface
{
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
$station = $request->getStation();
return $response->withJson([
'stationFrontendType' => $station->getFrontendType()->value,
]);
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/Vue/MountsAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 126 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations\Vue;
use App\Container\EntityManagerAwareTrait;
use App\Controller\SingleActionInterface;
use App\Http\Response;
use App\Http\ServerRequest;
use App\VueComponent\StationFormComponent;
use Psr\Http\Message\ResponseInterface;
final class ProfileEditAction implements SingleActionInterface
{
use EntityManagerAwareTrait;
public function __construct(
private readonly StationFormComponent $stationFormComponent
) {
}
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
$router = $request->getRouter();
return $response->withJson(
array_merge(
$this->stationFormComponent->getProps($request),
[
'editUrl' => $router->fromHere('api:stations:profile:edit'),
]
)
);
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/Vue/ProfileEditAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 197 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations\Vue;
use App\Controller\SingleActionInterface;
use App\Http\Response;
use App\Http\ServerRequest;
use Psr\Http\Message\ResponseInterface;
final class PlaylistsAction implements SingleActionInterface
{
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
$station = $request->getStation();
return $response->withJson([
'useManualAutoDj' => $station->useManualAutoDJ(),
]);
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/Vue/PlaylistsAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 125 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations\Vue;
use App\Controller\SingleActionInterface;
use App\Entity\PodcastCategory;
use App\Http\Response;
use App\Http\ServerRequest;
use Psr\Http\Message\ResponseInterface;
use Symfony\Component\Intl\Languages;
final class PodcastsAction implements SingleActionInterface
{
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
$locale = $request->getCustomization()->getLocale();
$userLocale = $locale->value;
$languageOptions = Languages::getNames($userLocale);
$categoriesOptions = PodcastCategory::getAvailableCategories();
return $response->withJson([
'languageOptions' => $languageOptions,
'categoriesOptions' => $categoriesOptions,
]);
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/Vue/PodcastsAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 182 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations\Vue\Reports;
use App\Container\SettingsAwareTrait;
use App\Controller\SingleActionInterface;
use App\Entity\Enums\AnalyticsLevel;
use App\Http\Response;
use App\Http\ServerRequest;
use Psr\Http\Message\ResponseInterface;
use RuntimeException;
final class OverviewAction implements SingleActionInterface
{
use SettingsAwareTrait;
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
// Get current analytics level.
$settings = $this->readSettings();
if (!$settings->isAnalyticsEnabled()) {
throw new RuntimeException('Analytics are not enabled for this station.');
}
$analyticsLevel = $settings->getAnalytics();
return $response->withJson([
'showFullAnalytics' => AnalyticsLevel::All === $analyticsLevel,
]);
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/Vue/Reports/OverviewAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 194 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations\Vue\Reports;
use App\Controller\SingleActionInterface;
use App\Http\Response;
use App\Http\ServerRequest;
use App\Service\IpGeolocation;
use Psr\Http\Message\ResponseInterface;
final class ListenersAction implements SingleActionInterface
{
public function __construct(
private readonly IpGeolocation $ipGeolocation
) {
}
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
return $response->withJson([
'attribution' => $this->ipGeolocation->getAttribution(),
]);
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/Vue/Reports/ListenersAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 147 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations\Vue;
use App\Container\EntityManagerAwareTrait;
use App\Controller\SingleActionInterface;
use App\Http\Response;
use App\Http\ServerRequest;
use App\Radio\Adapters;
use App\VueComponent\NowPlayingComponent;
use Psr\Http\Message\ResponseInterface;
use RuntimeException;
final class ProfileAction implements SingleActionInterface
{
use EntityManagerAwareTrait;
public function __construct(
private readonly NowPlayingComponent $nowPlayingComponent,
private readonly Adapters $adapters,
) {
}
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
$station = $request->getStation();
if (!$station->getIsEnabled()) {
throw new RuntimeException('The station profile is disabled.');
}
// Statistics about backend playback.
$numSongs = $this->em->createQuery(
<<<'DQL'
SELECT COUNT(sm.id)
FROM App\Entity\StationMedia sm
LEFT JOIN sm.playlists spm
LEFT JOIN spm.playlist sp
WHERE sp.id IS NOT NULL
AND sp.station_id = :station_id
DQL
)->setParameter('station_id', $station->getId())
->getSingleScalarResult();
$numPlaylists = $this->em->createQuery(
<<<'DQL'
SELECT COUNT(sp.id)
FROM App\Entity\StationPlaylist sp
WHERE sp.station_id = :station_id
DQL
)->setParameter('station_id', $station->getId())
->getSingleScalarResult();
$backendEnum = $station->getBackendType();
$frontend = $this->adapters->getFrontendAdapter($station);
$frontendConfig = $station->getFrontendConfig();
$router = $request->getRouter();
return $response->withJson([
...$this->nowPlayingComponent->getDataProps($request),
// Common
'backendType' => $station->getBackendType()->value,
'frontendType' => $station->getFrontendType()->value,
'stationSupportsRequests' => $backendEnum->isEnabled(),
'stationSupportsStreamers' => $backendEnum->isEnabled(),
'enableRequests' => $station->getEnableRequests(),
'enableStreamers' => $station->getEnableStreamers(),
'enablePublicPage' => $station->getEnablePublicPage(),
'enableOnDemand' => $station->getEnableOnDemand(),
'profileApiUri' => $router->fromHere('api:stations:profile'),
'hasStarted' => $station->getHasStarted(),
// Header
'stationName' => $station->getName(),
'stationDescription' => $station->getDescription(),
// Now Playing
'backendSkipSongUri' => $router->fromHere('api:stations:backend', ['do' => 'skip']),
'backendDisconnectStreamerUri' => $router->fromHere(
'api:stations:backend',
['do' => 'disconnect']
),
// Public Pages
'publicPageUri' => $router->named(
routeName: 'public:index',
routeParams: ['station_id' => $station->getShortName()],
absolute: true
),
'publicPageEmbedUri' => $router->named(
routeName: 'public:index',
routeParams: ['station_id' => $station->getShortName(), 'embed' => 'embed'],
absolute: true
),
'publicWebDjUri' => $router->named(
routeName: 'public:dj',
routeParams: ['station_id' => $station->getShortName()],
absolute: true
),
'publicOnDemandUri' => $router->named(
routeName: 'public:ondemand',
routeParams: ['station_id' => $station->getShortName()],
absolute: true
),
'publicPodcastsUri' => $router->named(
routeName: 'public:podcasts',
routeParams: ['station_id' => $station->getShortName()],
absolute: true
),
'publicScheduleUri' => $router->named(
routeName: 'public:schedule',
routeParams: ['station_id' => $station->getShortName()],
absolute: true
),
'publicOnDemandEmbedUri' => $router->named(
routeName: 'public:ondemand',
routeParams: ['station_id' => $station->getShortName(), 'embed' => 'embed'],
absolute: true
),
'publicRequestEmbedUri' => $router->named(
routeName: 'public:embedrequests',
routeParams: ['station_id' => $station->getShortName()],
absolute: true
),
'publicHistoryEmbedUri' => $router->named(
routeName: 'public:history',
routeParams: ['station_id' => $station->getShortName()],
absolute: true
),
'publicScheduleEmbedUri' => $router->named(
routeName: 'public:schedule',
routeParams: ['station_id' => $station->getShortName(), 'embed' => 'embed'],
absolute: true
),
'publicPodcastsEmbedUri' => $router->named(
routeName: 'public:podcasts',
routeParams: ['station_id' => $station->getShortName()],
queryParams: ['embed' => 'true'],
absolute: true
),
// Frontend
'frontendAdminUri' => (string)$frontend?->getAdminUrl($station, $router->getBaseUrl()),
'frontendAdminPassword' => $frontendConfig->getAdminPassword(),
'frontendSourcePassword' => $frontendConfig->getSourcePassword(),
'frontendRelayPassword' => $frontendConfig->getRelayPassword(),
'frontendPort' => $frontendConfig->getPort(),
'frontendRestartUri' => $router->fromHere('api:stations:frontend', ['do' => 'restart']),
'frontendStartUri' => $router->fromHere('api:stations:frontend', ['do' => 'start']),
'frontendStopUri' => $router->fromHere('api:stations:frontend', ['do' => 'stop']),
// Backend
'numSongs' => (int)$numSongs,
'numPlaylists' => (int)$numPlaylists,
'backendRestartUri' => $router->fromHere('api:stations:backend', ['do' => 'restart']),
'backendStartUri' => $router->fromHere('api:stations:backend', ['do' => 'start']),
'backendStopUri' => $router->fromHere('api:stations:backend', ['do' => 'stop']),
]);
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/Vue/ProfileAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 1,482 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations\OnDemand;
use App\Controller\Api\Stations\AbstractSearchableListAction;
use App\Entity\Api\StationOnDemand;
use App\Entity\Station;
use App\Entity\StationMedia;
use App\Exception\StationUnsupportedException;
use App\Http\Response;
use App\Http\ServerRequest;
use Psr\Http\Message\ResponseInterface;
final class ListAction extends AbstractSearchableListAction
{
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
$station = $request->getStation();
$playlists = $this->getPlaylists($station);
if (empty($playlists)) {
throw StationUnsupportedException::onDemand();
}
$paginator = $this->getPaginator($request, $playlists);
$router = $request->getRouter();
$paginator->setPostprocessor(
function (StationMedia $media) use ($station, $router) {
$row = new StationOnDemand();
$row->track_id = $media->getUniqueId();
$row->media = ($this->songApiGenerator)(
song: $media,
station: $station
);
$row->download_url = $router->named(
'api:stations:ondemand:download',
[
'station_id' => $station->getId(),
'media_id' => $media->getUniqueId(),
]
);
$row->resolveUrls($router->getBaseUrl());
return $row;
}
);
return $paginator->write($response);
}
/**
* @param Station $station
* @return int[]
*/
private function getPlaylists(
Station $station
): array {
$item = $this->psr6Cache->getItem(
urlencode(
'station_' . $station->getIdRequired() . '_on_demand_playlists'
)
);
if (!$item->isHit()) {
$playlistIds = $this->em->createQuery(
<<<'DQL'
SELECT sp.id FROM App\Entity\StationPlaylist sp
WHERE sp.station = :station
AND sp.is_enabled = 1 AND sp.include_in_on_demand = 1
DQL
)->setParameter('station', $station)
->getSingleColumnResult();
$item->set($playlistIds);
$item->expiresAfter(600);
$this->psr6Cache->save($item);
}
return $item->get();
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/OnDemand/ListAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 550 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations\OnDemand;
use App\Controller\SingleActionInterface;
use App\Entity\Repository\StationMediaRepository;
use App\Flysystem\StationFilesystems;
use App\Http\Response;
use App\Http\ServerRequest;
use Psr\Http\Message\ResponseInterface;
final class DownloadAction implements SingleActionInterface
{
public function __construct(
private readonly StationMediaRepository $mediaRepo,
private readonly StationFilesystems $stationFilesystems,
) {
}
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
/** @var string $mediaId */
$mediaId = $params['media_id'];
$station = $request->getStation();
$media = $this->mediaRepo->requireByUniqueId($mediaId, $station);
$fsMedia = $this->stationFilesystems->getMediaFilesystem($station);
set_time_limit(600);
return $response->streamFilesystemFile($fsMedia, $media->getPath());
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/OnDemand/DownloadAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 233 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations\Files;
use App\Container\EntityManagerAwareTrait;
use App\Controller\Api\Traits\CanSortResults;
use App\Controller\Api\Traits\HasMediaSearch;
use App\Controller\SingleActionInterface;
use App\Entity\Api\FileList;
use App\Entity\Api\FileListDir;
use App\Entity\Api\StationMedia as ApiStationMedia;
use App\Entity\Enums\FileTypes;
use App\Entity\Station;
use App\Entity\StationMedia;
use App\Flysystem\StationFilesystems;
use App\Http\Response;
use App\Http\RouterInterface;
use App\Http\ServerRequest;
use App\Media\MimeType;
use App\Paginator;
use App\Utilities\Strings;
use App\Utilities\Types;
use Doctrine\Common\Collections\Order;
use Doctrine\ORM\QueryBuilder;
use League\Flysystem\StorageAttributes;
use Psr\Http\Message\ResponseInterface;
use Psr\SimpleCache\CacheInterface;
use Symfony\Component\PropertyAccess\PropertyAccessorInterface;
final class ListAction implements SingleActionInterface
{
use CanSortResults;
use EntityManagerAwareTrait;
use HasMediaSearch;
public function __construct(
private readonly CacheInterface $cache,
private readonly StationFilesystems $stationFilesystems
) {
}
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
$router = $request->getRouter();
$station = $request->getStation();
$storageLocation = $station->getMediaStorageLocation();
$fs = $this->stationFilesystems->getMediaFilesystem($station);
$currentDir = Types::string($request->getParam('currentDirectory'));
$searchPhraseFull = Types::stringOrNull($request->getParam('searchPhrase'), true);
$isSearch = null !== $searchPhraseFull;
[$searchPhrase, $playlist, $special] = $this->parseSearchQuery(
$station,
$searchPhraseFull ?? ''
);
$cacheKeyParts = [
'files_list',
$storageLocation->getIdRequired(),
(!empty($currentDir)) ? 'dir_' . rawurlencode($currentDir) : 'root',
];
if ($isSearch) {
$cacheKeyParts[] = 'search_' . rawurlencode($searchPhraseFull);
}
$cacheKey = implode('.', $cacheKeyParts);
$flushCache = Types::bool($request->getParam('flushCache'), false, true);
if (!$flushCache && $this->cache->has($cacheKey)) {
/** @var array<int, FileList> $result */
$result = $this->cache->get($cacheKey);
} else {
$pathLike = (empty($currentDir))
? '%'
: $currentDir . '/%';
$mediaQueryBuilder = $this->em->createQueryBuilder()
->select('sm')
->from(StationMedia::class, 'sm')
->where('sm.storage_location = :storageLocation')
->andWhere('sm.path LIKE :path')
->setParameter('storageLocation', $station->getMediaStorageLocation())
->setParameter('path', $pathLike);
$foldersInDirQuery = $this->em->createQuery(
<<<'DQL'
SELECT spf, sp
FROM App\Entity\StationPlaylistFolder spf
JOIN spf.playlist sp
WHERE spf.station = :station
AND spf.path LIKE :path
DQL
)->setParameter('station', $station)
->setParameter('path', $pathLike);
$unprocessableMediaQuery = $this->em->createQuery(
<<<'DQL'
SELECT upm
FROM App\Entity\UnprocessableMedia upm
WHERE upm.storage_location = :storageLocation
AND upm.path LIKE :path
DQL
)->setParameter('storageLocation', $storageLocation)
->setParameter('path', $pathLike);
// Apply searching
if ($isSearch) {
if ('unprocessable' === $special) {
$mediaQueryBuilder = null;
$unprocessableMediaRaw = $unprocessableMediaQuery->toIterable(
[],
$unprocessableMediaQuery::HYDRATE_ARRAY
);
} else {
if ('duplicates' === $special) {
$mediaQueryBuilder->andWhere(
$mediaQueryBuilder->expr()->in(
'sm.song_id',
<<<'DQL'
SELECT sm2.song_id FROM
App\Entity\StationMedia sm2
WHERE sm2.storage_location = :storageLocation
GROUP BY sm2.song_id
HAVING COUNT(sm2.id) > 1
DQL
)
);
} elseif ('unassigned' === $special) {
$mediaQueryBuilder->andWhere(
'sm.id NOT IN (SELECT spm2.media_id FROM App\Entity\StationPlaylistMedia spm2)'
);
} elseif (null !== $playlist) {
$mediaQueryBuilder->andWhere(
'sm.id IN (SELECT spm2.media_id FROM App\Entity\StationPlaylistMedia spm2 '
. 'WHERE spm2.playlist = :playlist)'
)->setParameter('playlist', $playlist);
}
if (!empty($searchPhrase)) {
$mediaQueryBuilder->andWhere(
'(sm.title LIKE :query OR sm.artist LIKE :query OR sm.path LIKE :query)'
)->setParameter('query', '%' . $searchPhrase . '%');
}
$unprocessableMediaRaw = [];
}
$foldersInDirRaw = [];
} else {
// Avoid loading subfolder media.
$mediaQueryBuilder->andWhere('sm.path NOT LIKE :pathWithSubfolders')
->setParameter('pathWithSubfolders', $pathLike . '/%');
$foldersInDirRaw = $foldersInDirQuery->getArrayResult();
$unprocessableMediaRaw = $unprocessableMediaQuery->toIterable(
[],
$unprocessableMediaQuery::HYDRATE_ARRAY
);
}
// Process all database results.
$mediaInDir = $this->processMediaInDir($station, $mediaQueryBuilder);
$folderPlaylists = [];
foreach ($foldersInDirRaw as $folderRow) {
if (!isset($folderPlaylists[$folderRow['path']])) {
$folderPlaylists[$folderRow['path']] = [];
}
$folderPlaylists[$folderRow['path']][] = $folderRow['playlist'];
}
/** @var array<string, FileListDir> $foldersInDir */
$foldersInDir = array_map(
function ($playlists) {
$row = new FileListDir();
$row->playlists = ApiStationMedia::aggregatePlaylists($playlists);
return $row;
},
$folderPlaylists
);
$unprocessableMedia = [];
foreach ($unprocessableMediaRaw as $unprocessableRow) {
$unprocessableMedia[$unprocessableRow['path']] = $unprocessableRow['error'];
}
if ($isSearch) {
if ('unprocessable' === $special) {
/** @var string[] $files */
$files = array_keys($unprocessableMedia);
} else {
/** @var string[] $files */
$files = array_keys($mediaInDir);
}
} else {
$files = $fs->listContents($currentDir, false)->filter(
fn(StorageAttributes $attributes) => !StationFilesystems::isDotFile($attributes->path())
);
}
$result = [];
foreach ($files as $file) {
$row = new FileList();
if ($file instanceof StorageAttributes) {
$isDir = $file->isDir();
$row->path = $file->path();
$row->timestamp = $file->lastModified() ?? 0;
$row->size = (!$isDir && method_exists($file, 'fileSize')) ? $file->fileSize() : 0;
} else {
$isDir = false;
$row->path = $file;
$row->timestamp = $fs->lastModified($file);
$row->size = $fs->fileSize($row->path);
}
$shortname = ($isSearch)
? $row->path
: basename($row->path);
$maxLength = 60;
if (mb_strlen($shortname) > $maxLength) {
$shortname = mb_substr($shortname, 0, $maxLength - 15) . '...' . mb_substr($shortname, -12);
}
$row->path_short = $shortname;
if (isset($mediaInDir[$row->path])) {
$row->type = FileTypes::Media;
$row->media = $mediaInDir[$row->path];
$row->text = $row->media->text;
} elseif ($isDir) {
$row->type = FileTypes::Directory;
$row->text = __('Directory');
$row->dir = $foldersInDir[$row->path] ?? new FileListDir();
} elseif (isset($unprocessableMedia[$row->path])) {
$row->type = FileTypes::UnprocessableFile;
$row->text = sprintf(
__('File Not Processed: %s'),
Strings::truncateText($unprocessableMedia[$row->path])
);
} elseif (MimeType::isPathImage($row->path)) {
$row->type = FileTypes::CoverArt;
$row->text = __('Cover Art');
} else {
$row->type = FileTypes::Other;
$row->text = __('File Processing');
}
$result[] = $row;
}
$this->cache->set($cacheKey, $result, 300);
}
// Apply sorting
[$sort, $sortOrder] = $this->getSortFromRequest($request);
$propertyAccessor = self::getPropertyAccessor();
usort(
$result,
static fn(FileList $a, FileList $b) => self::sortRows(
$a,
$b,
$propertyAccessor,
$special,
$sort,
$sortOrder
)
);
$paginator = Paginator::fromArray($result, $request);
// Add processor-intensive data for just this page.
$stationId = $station->getIdRequired();
$paginator->setPostprocessor(
static fn(FileList $row) => self::postProcessRow($row, $router, $stationId)
);
return $paginator->write($response);
}
/**
* @return array<string, ApiStationMedia>
*/
private function processMediaInDir(
Station $station,
?QueryBuilder $qb = null
): array {
if (null === $qb) {
return [];
}
$qb->select(
'sm.id',
'sm.unique_id',
'sm.song_id',
'sm.path',
'sm.artist',
'sm.title',
'sm.album',
'sm.genre',
'sm.isrc',
'sm.length',
'sm.mtime',
'sm.uploaded_at',
'sm.art_updated_at'
);
/** @var array<array{
* id: int,
* unique_id: string,
* song_id: string,
* path: string,
* artist: string | null,
* title: string | null,
* album: string | null,
* genre: string | null,
* isrc: string | null,
* length: string,
* mtime: int,
* uploaded_at: int,
* art_updated_at: int
* }> $mediaInDirRaw
*/
$mediaInDirRaw = $qb->getQuery()->getScalarResult();
$mediaIds = array_column($mediaInDirRaw, 'id');
// Fetch custom fields for all shown media.
$customFieldsRaw = $this->em->createQuery(
<<<'DQL'
SELECT smcf.media_id, cf.short_name, smcf.value
FROM App\Entity\StationMediaCustomField smcf JOIN smcf.field cf
WHERE smcf.media_id IN (:ids)
DQL
)->setParameter('ids', $mediaIds)
->getScalarResult();
$customFields = [];
foreach ($customFieldsRaw as $row) {
$customFields[$row['media_id']] ??= [];
$customFields[$row['media_id']][$row['short_name']] = $row['value'];
}
// Fetch playlists for all shown media.
$allPlaylistsRaw = $this->em->createQuery(
<<<'DQL'
SELECT spm, sp
FROM App\Entity\StationPlaylistMedia spm
JOIN spm.playlist sp
WHERE sp.station = :station AND spm.media_id IN (:ids)
DQL
)->setParameter('station', $station)
->setParameter('ids', $mediaIds)
->getArrayResult();
$allPlaylists = [];
foreach ($allPlaylistsRaw as $row) {
$allPlaylists[$row['media_id']] ??= [];
$allPlaylists[$row['media_id']][] = $row['playlist'];
}
$mediaInDir = [];
foreach ($mediaInDirRaw as $row) {
$id = $row['id'];
$mediaInDir[$row['path']] = ApiStationMedia::fromArray(
$row,
[],
$customFields[$id] ?? [],
ApiStationMedia::aggregatePlaylists($allPlaylists[$id] ?? [])
);
}
return $mediaInDir;
}
private static function sortRows(
FileList $a,
FileList $b,
PropertyAccessorInterface $propertyAccessor,
?string $specialSearchPhrase = null,
?string $sort = null,
Order $sortOrder = Order::Ascending
): int {
if ('duplicates' === $specialSearchPhrase) {
return $a->media?->song_id <=> $b->media?->song_id;
}
$isDirComp = ($b->type === FileTypes::Directory) <=> ($a->type === FileTypes::Directory);
if (0 !== $isDirComp) {
return $isDirComp;
}
if (!$sort) {
$aVal = $a->path;
$bVal = $b->path;
return (Order::Ascending === $sortOrder) ? $aVal <=> $bVal : $bVal <=> $aVal;
}
return self::sortByDotNotation($a, $b, $propertyAccessor, $sort, $sortOrder);
}
private static function postProcessRow(
FileList $row,
RouterInterface $router,
int $stationId
): FileList {
if (null !== $row->media) {
$routeParams = [
'media_id' => $row->media->unique_id,
];
if (0 !== $row->media->art_updated_at) {
$routeParams['timestamp'] = $row->media->art_updated_at;
}
$row->media->art = $router->fromHere(
'api:stations:media:art',
routeParams: $routeParams
);
$row->media->links = [
'self' => $router->fromHere(
'api:stations:file',
['id' => $row->media->id],
),
'play' => $router->fromHere(
'api:stations:files:play',
['id' => $row->media->id],
[],
true
),
'art' => $router->fromHere(
'api:stations:media:art',
[
'media_id' => $row->media->id,
]
),
'waveform' => $router->fromHere(
'api:stations:media:waveform',
[
'media_id' => $row->media->unique_id,
'timestamp' => $row->media->art_updated_at,
]
),
'waveform_cache' => $router->fromHere(
'api:stations:media:waveform-cache',
[
'media_id' => $row->media->unique_id,
]
),
];
}
$row->links = [
'download' => $router->fromHere(
'api:stations:files:download',
queryParams: ['file' => $row->path]
),
'rename' => $router->fromHere(
'api:stations:files:rename',
queryParams: ['file' => $row->path]
),
];
return $row;
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/Files/ListAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 3,604 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations\Files;
use App\Container\EntityManagerAwareTrait;
use App\Controller\SingleActionInterface;
use App\Entity\Api\MediaBatchResult;
use App\Entity\Interfaces\PathAwareInterface;
use App\Entity\Repository\StationPlaylistFolderRepository;
use App\Entity\Repository\StationPlaylistMediaRepository;
use App\Entity\Repository\StationQueueRepository;
use App\Entity\Station;
use App\Entity\StationPlaylist;
use App\Entity\StationQueue;
use App\Entity\StationRequest;
use App\Entity\StorageLocation;
use App\Event\Radio\AnnotateNextSong;
use App\Flysystem\ExtendedFilesystemInterface;
use App\Flysystem\StationFilesystems;
use App\Http\Response;
use App\Http\ServerRequest;
use App\Media\BatchUtilities;
use App\Message;
use App\Radio\Adapters;
use App\Radio\Backend\Liquidsoap;
use App\Radio\Enums\BackendAdapters;
use App\Radio\Enums\LiquidsoapQueues;
use App\Utilities\File;
use App\Utilities\Types;
use Exception;
use InvalidArgumentException;
use League\Flysystem\StorageAttributes;
use League\Flysystem\UnableToDeleteDirectory;
use League\Flysystem\UnableToDeleteFile;
use Psr\EventDispatcher\EventDispatcherInterface;
use Psr\Http\Message\ResponseInterface;
use RuntimeException;
use Symfony\Component\Messenger\MessageBus;
use Throwable;
final class BatchAction implements SingleActionInterface
{
use EntityManagerAwareTrait;
public function __construct(
private readonly BatchUtilities $batchUtilities,
private readonly MessageBus $messageBus,
private readonly Adapters $adapters,
private readonly EventDispatcherInterface $eventDispatcher,
private readonly StationPlaylistMediaRepository $playlistMediaRepo,
private readonly StationPlaylistFolderRepository $playlistFolderRepo,
private readonly StationQueueRepository $queueRepo,
private readonly StationFilesystems $stationFilesystems
) {
}
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
$station = $request->getStation();
$storageLocation = $station->getMediaStorageLocation();
$fsMedia = $this->stationFilesystems->getMediaFilesystem($station);
$result = match (Types::string($request->getParam('do'))) {
'delete' => $this->doDelete($request, $station, $storageLocation, $fsMedia),
'playlist' => $this->doPlaylist($request, $station, $storageLocation, $fsMedia),
'move' => $this->doMove($request, $station, $storageLocation, $fsMedia),
'queue' => $this->doQueue($request, $station, $storageLocation, $fsMedia),
'immediate' => $this->doPlayImmediately($request, $station, $storageLocation, $fsMedia),
'reprocess' => $this->doReprocess($request, $station, $storageLocation, $fsMedia),
'clear-extra' => $this->doClearExtra($request, $station, $storageLocation, $fsMedia),
default => throw new InvalidArgumentException('Invalid batch action specified.')
};
if ($this->em->isOpen()) {
$this->em->clear();
}
return $response->withJson($result);
}
private function doDelete(
ServerRequest $request,
Station $station,
StorageLocation $storageLocation,
ExtendedFilesystemInterface $fs
): MediaBatchResult {
$result = $this->parseRequest($request, $fs, true);
$successfulFiles = [];
foreach ($result->files as $file) {
try {
$fs->delete($file);
$successfulFiles[] = $file;
} catch (UnableToDeleteFile $e) {
$result->errors[] = sprintf('%s: %s', $file, $e->reason());
} catch (Throwable $e) {
$result->errors[] = sprintf('%s: %s', $file, $e->getMessage());
}
}
$successfulDirs = [];
foreach ($result->directories as $dir) {
try {
$fs->deleteDirectory($dir);
$successfulDirs[] = $dir;
} catch (UnableToDeleteDirectory $e) {
$result->errors[] = sprintf('%s: %s', $dir, $e->reason());
} catch (Throwable $e) {
$result->errors[] = sprintf('%s: %s', $dir, $e->getMessage());
}
}
$affectedPlaylistIds = $this->batchUtilities->handleDelete(
$successfulFiles,
$successfulDirs,
$storageLocation,
$fs
);
$this->writePlaylistChanges($station, $affectedPlaylistIds);
return $result;
}
private function doPlaylist(
ServerRequest $request,
Station $station,
StorageLocation $storageLocation,
ExtendedFilesystemInterface $fs
): MediaBatchResult {
$result = $this->parseRequest($request, $fs, true);
/** @var array<int, int> $playlists */
$playlists = [];
/** @var array<int, int> $affectedPlaylistIds */
$affectedPlaylistIds = [];
/** @var string[] $requestPlaylists */
$requestPlaylists = Types::array($request->getParam('playlists'));
foreach ($requestPlaylists as $playlistId) {
if ('new' === $playlistId) {
$playlist = new StationPlaylist($station);
$playlist->setName(
Types::string($request->getParam('new_playlist_name'))
);
$this->em->persist($playlist);
$this->em->flush();
$result->responseRecord = [
'id' => $playlist->getIdRequired(),
'name' => $playlist->getName(),
];
$affectedPlaylistIds[$playlist->getIdRequired()] = $playlist->getIdRequired();
$playlists[$playlist->getIdRequired()] = 0;
} else {
$playlist = $this->em->getRepository(StationPlaylist::class)->findOneBy(
[
'station_id' => $station->getIdRequired(),
'id' => (int)$playlistId,
]
);
if ($playlist instanceof StationPlaylist) {
$affectedPlaylistIds[$playlist->getIdRequired()] = $playlist->getIdRequired();
$playlists[$playlist->getIdRequired()] = $this->playlistMediaRepo->getHighestSongWeight($playlist);
}
}
}
/*
* NOTE: This iteration clears the entity manager.
*/
foreach ($this->batchUtilities->iterateMedia($storageLocation, $result->files) as $media) {
try {
$affectedPlaylistIds += $this->playlistMediaRepo->setPlaylistsForMedia(
$media,
$station,
$playlists
);
} catch (Exception $e) {
$result->errors[] = $media->getPath() . ': ' . $e->getMessage();
}
}
/** @var Station $station */
$station = $this->em->refetch($station);
foreach ($result->directories as $dir) {
try {
$this->playlistFolderRepo->setPlaylistsForFolder(
$station,
$dir,
$playlists
);
} catch (Exception $e) {
$result->errors[] = $dir . ': ' . $e->getMessage();
}
}
$this->em->flush();
$this->writePlaylistChanges($station, $affectedPlaylistIds);
return $result;
}
private function doMove(
ServerRequest $request,
Station $station,
StorageLocation $storageLocation,
ExtendedFilesystemInterface $fs
): MediaBatchResult {
$result = $this->parseRequest($request, $fs);
$from = Types::string($request->getParam('currentDirectory'));
$to = Types::string($request->getParam('directory'));
$toMove = [
$this->batchUtilities->iterateMedia($storageLocation, $result->files),
$this->batchUtilities->iterateUnprocessableMedia($storageLocation, $result->files),
];
foreach ($toMove as $iterator) {
foreach ($iterator as $record) {
/** @var PathAwareInterface $record */
$oldPath = $record->getPath();
$newPath = File::renameDirectoryInPath($oldPath, $from, $to, false);
try {
$fs->move($oldPath, $newPath);
$record->setPath($newPath);
$this->em->persist($record);
} catch (Throwable $e) {
$result->errors[] = sprintf('%s: %s', $oldPath, $e->getMessage());
}
}
}
foreach ($result->directories as $dirPath) {
$newDirPath = File::renameDirectoryInPath($dirPath, $from, $to);
try {
$fs->move($dirPath, $newDirPath);
} catch (Throwable $e) {
$result->errors[] = sprintf('%s: %s', $dirPath, $e->getMessage());
continue;
}
$toMove = [
$this->batchUtilities->iterateMediaInDirectory($storageLocation, $dirPath),
$this->batchUtilities->iterateUnprocessableMediaInDirectory($storageLocation, $dirPath),
$this->batchUtilities->iteratePlaylistFoldersInDirectory($storageLocation, $dirPath),
];
foreach ($toMove as $iterator) {
foreach ($iterator as $record) {
/** @var PathAwareInterface $record */
try {
$record->setPath(
File::renameDirectoryInPath($record->getPath(), $from, $to)
);
$this->em->persist($record);
} catch (Throwable $e) {
$result->errors[] = $record->getPath() . ': ' . $e->getMessage();
}
}
}
}
return $result;
}
private function doQueue(
ServerRequest $request,
Station $station,
StorageLocation $storageLocation,
ExtendedFilesystemInterface $fs
): MediaBatchResult {
$result = $this->parseRequest($request, $fs, true);
if ($station->useManualAutoDJ()) {
foreach ($this->batchUtilities->iterateMedia($storageLocation, $result->files) as $media) {
/** @var Station $stationRef */
$stationRef = $this->em->getReference(Station::class, $station->getId());
$newRequest = new StationRequest($stationRef, $media, null, true);
$this->em->persist($newRequest);
}
} else {
$nextCuedItem = $this->queueRepo->getNextToSendToAutoDj($station);
$cuedTimestamp = (null !== $nextCuedItem)
? $nextCuedItem->getTimestampCued() - 10
: time();
foreach ($this->batchUtilities->iterateMedia($storageLocation, $result->files) as $media) {
try {
/** @var Station $stationRef */
$stationRef = $this->em->getReference(Station::class, $station->getId());
$newQueue = StationQueue::fromMedia($stationRef, $media);
$newQueue->setTimestampCued($cuedTimestamp);
$this->em->persist($newQueue);
} catch (Throwable $e) {
$result->errors[] = sprintf('%s: %s', $media->getPath(), $e->getMessage());
}
$cuedTimestamp -= 10;
}
}
return $result;
}
private function doPlayImmediately(
ServerRequest $request,
Station $station,
StorageLocation $storageLocation,
ExtendedFilesystemInterface $fs
): MediaBatchResult {
$result = $this->parseRequest($request, $fs, true);
if (BackendAdapters::Liquidsoap !== $station->getBackendType()) {
throw new RuntimeException('This functionality can only be used on stations that use Liquidsoap.');
}
/** @var Liquidsoap $backend */
$backend = $this->adapters->getBackendAdapter($station);
if ($station->useManualAutoDJ()) {
foreach ($this->batchUtilities->iterateMedia($storageLocation, $result->files) as $media) {
/** @var Station $station */
$station = $this->em->find(Station::class, $station->getIdRequired());
$event = AnnotateNextSong::fromStationMedia($station, $media, true);
$this->eventDispatcher->dispatch($event);
$backend->enqueue(
$station,
LiquidsoapQueues::Interrupting,
$event->buildAnnotations()
);
}
} else {
$cuedTimestamp = time();
foreach ($this->batchUtilities->iterateMedia($storageLocation, $result->files) as $media) {
try {
/** @var Station $station */
$station = $this->em->find(Station::class, $station->getIdRequired());
$newQueue = StationQueue::fromMedia($station, $media);
$newQueue->setTimestampCued($cuedTimestamp);
$newQueue->setIsPlayed();
$this->em->persist($newQueue);
$event = AnnotateNextSong::fromStationQueue($newQueue, true);
$this->eventDispatcher->dispatch($event);
$backend->enqueue(
$station,
LiquidsoapQueues::Interrupting,
$event->buildAnnotations()
);
} catch (Throwable $e) {
$result->errors[] = sprintf('%s: %s', $media->getPath(), $e->getMessage());
}
$cuedTimestamp += 10;
}
}
return $result;
}
private function doReprocess(
ServerRequest $request,
Station $station,
StorageLocation $storageLocation,
ExtendedFilesystemInterface $fs
): MediaBatchResult {
$result = $this->parseRequest($request, $fs, true);
foreach ($this->batchUtilities->iterateMedia($storageLocation, $result->files) as $media) {
$mediaId = (int)$media->getId();
$message = new Message\ReprocessMediaMessage();
$message->storage_location_id = $storageLocation->getIdRequired();
$message->media_id = $mediaId;
$message->force = true;
$this->messageBus->dispatch($message);
}
foreach ($this->batchUtilities->iterateUnprocessableMedia($storageLocation, $result->files) as $unprocessable) {
$message = new Message\AddNewMediaMessage();
$message->storage_location_id = $storageLocation->getIdRequired();
$message->path = $unprocessable->getPath();
$this->messageBus->dispatch($message);
}
return $result;
}
private function doClearExtra(
ServerRequest $request,
Station $station,
StorageLocation $storageLocation,
ExtendedFilesystemInterface $fs
): MediaBatchResult {
$result = $this->parseRequest($request, $fs, true);
foreach ($this->batchUtilities->iterateMedia($storageLocation, $result->files) as $media) {
$media->clearExtraMetadata();
// Always flag for reprocessing to repopulate extra metadata from the file.
$media->setMtime(0);
$this->em->persist($media);
}
return $result;
}
private function parseRequest(
ServerRequest $request,
ExtendedFilesystemInterface $fs,
bool $recursive = false
): MediaBatchResult {
$files = array_values(
Types::array($request->getParam('files', []))
);
$directories = array_values(
Types::array($request->getParam('dirs', []))
);
if ($recursive) {
foreach ($directories as $dir) {
$dirIterator = $fs->listContents($dir, true)->filter(
function (StorageAttributes $attrs) {
return $attrs->isFile();
}
);
foreach ($dirIterator as $subDirMeta) {
$files[] = $subDirMeta['path'];
}
}
}
$result = new MediaBatchResult();
$result->files = $files;
$result->directories = $directories;
return $result;
}
private function writePlaylistChanges(
Station $station,
array $playlists
): void {
// Write new PLS playlist configuration.
if ($station->getBackendType()->isEnabled()) {
foreach ($playlists as $playlistId => $playlistRow) {
// Instruct the message queue to start a new "write playlist to file" task.
$message = new Message\WritePlaylistFileMessage();
$message->playlist_id = $playlistId;
$this->messageBus->dispatch($message);
}
}
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/Files/BatchAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 3,691 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations\Files;
use App\Controller\SingleActionInterface;
use App\Entity\Api\Error;
use App\Entity\Api\Status;
use App\Flysystem\StationFilesystems;
use App\Http\Response;
use App\Http\ServerRequest;
use App\Media\BatchUtilities;
use App\Utilities\Types;
use Psr\Http\Message\ResponseInterface;
final class RenameAction implements SingleActionInterface
{
public function __construct(
private readonly BatchUtilities $batchUtilities,
private readonly StationFilesystems $stationFilesystems,
) {
}
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
$from = Types::string($request->getParam('file'));
if (empty($from)) {
return $response->withStatus(500)
->withJson(new Error(500, __('File not specified.')));
}
$to = Types::string($request->getParam('newPath'));
if (empty($to)) {
return $response->withStatus(500)
->withJson(new Error(500, __('New path not specified.')));
}
// No-op if paths match
if ($from === $to) {
return $response->withJson(Status::updated());
}
$station = $request->getStation();
$storageLocation = $station->getMediaStorageLocation();
$fsMedia = $this->stationFilesystems->getMediaFilesystem($station);
$fsMedia->move($from, $to);
$this->batchUtilities->handleRename($from, $to, $storageLocation, $fsMedia);
return $response->withJson(Status::updated());
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/Files/RenameAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 375 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations\Files;
use App\Controller\SingleActionInterface;
use App\Entity\Api\Error;
use App\Entity\Api\Status;
use App\Flysystem\StationFilesystems;
use App\Http\Response;
use App\Http\ServerRequest;
use App\Utilities\Types;
use League\Flysystem\UnableToCreateDirectory;
use Psr\Http\Message\ResponseInterface;
final class MakeDirectoryAction implements SingleActionInterface
{
public function __construct(
private readonly StationFilesystems $stationFilesystems
) {
}
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
$currentDir = Types::string($request->getParam('currentDirectory'));
$newDirName = Types::string($request->getParam('name'));
if (empty($newDirName)) {
return $response->withStatus(400)
->withJson(new Error(400, __('No directory specified')));
}
$station = $request->getStation();
$fsMedia = $this->stationFilesystems->getMediaFilesystem($station);
$newDir = $currentDir . '/' . $newDirName;
try {
$fsMedia->createDirectory($newDir);
} catch (UnableToCreateDirectory $e) {
return $response->withStatus(400)
->withJson(new Error(400, $e->getMessage()));
}
return $response->withJson(Status::created());
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/Files/MakeDirectoryAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 328 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations\Files;
use App\Container\EntityManagerAwareTrait;
use App\Container\LoggerAwareTrait;
use App\Controller\Api\Traits\HasMediaSearch;
use App\Controller\SingleActionInterface;
use App\Entity\Api\Error;
use App\Entity\Api\Status;
use App\Entity\Repository\StationPlaylistFolderRepository;
use App\Entity\Repository\StationPlaylistMediaRepository;
use App\Entity\StationMedia;
use App\Entity\StationPlaylist;
use App\Exception\CannotProcessMediaException;
use App\Exception\StorageLocationFullException;
use App\Http\Response;
use App\Http\ServerRequest;
use App\Media\MediaProcessor;
use App\Service\Flow;
use App\Utilities\Types;
use Psr\Http\Message\ResponseInterface;
final class FlowUploadAction implements SingleActionInterface
{
use LoggerAwareTrait;
use EntityManagerAwareTrait;
use HasMediaSearch;
public function __construct(
private readonly MediaProcessor $mediaProcessor,
private readonly StationPlaylistMediaRepository $spmRepo,
private readonly StationPlaylistFolderRepository $spfRepo,
) {
}
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
$allParams = $request->getParams();
$station = $request->getStation();
$mediaStorage = $station->getMediaStorageLocation();
$mediaStorage->errorIfFull();
$flowResponse = Flow::process($request, $response, $station->getRadioTempDir());
if ($flowResponse instanceof ResponseInterface) {
return $flowResponse;
}
$currentDir = Types::string($request->getParam('currentDirectory'));
$destPath = $flowResponse->getClientFilename();
if (!empty($currentDir)) {
$destPath = $currentDir . '/' . $destPath;
}
$uploadedSize = $flowResponse->getSize();
if (!$mediaStorage->canHoldFile($uploadedSize)) {
throw new StorageLocationFullException();
}
try {
$tempPath = $flowResponse->getUploadedPath();
$stationMedia = $this->mediaProcessor->processAndUpload(
$mediaStorage,
$destPath,
$tempPath
);
} catch (CannotProcessMediaException $e) {
$this->logger->error(
$e->getMessageWithPath(),
[
'exception' => $e,
]
);
return $response->withJson(Error::fromException($e));
}
if ($stationMedia instanceof StationMedia) {
if (!empty($allParams['searchPhrase'])) {
// If the user is looking at a playlist's contents, add uploaded media to that playlist.
[$searchPhrase, $playlist] = $this->parseSearchQuery(
$station,
$allParams['searchPhrase']
);
if (null !== $playlist) {
$this->spmRepo->addMediaToPlaylist($stationMedia, $playlist);
$this->em->flush();
}
} elseif (!empty($currentDir)) {
// If the user is viewing a regular directory, check for playlists assigned to the directory and assign
// them to this media immediately.
$playlistIds = $this->spfRepo->getPlaylistIdsForFolderAndParents($station, $currentDir);
if (!empty($playlistIds)) {
foreach ($playlistIds as $playlistId) {
$playlist = $this->em->find(StationPlaylist::class, $playlistId);
if (null !== $playlist) {
$this->spmRepo->addMediaToPlaylist($stationMedia, $playlist);
}
}
$this->em->flush();
}
}
}
$mediaStorage->addStorageUsed($uploadedSize);
$this->em->persist($mediaStorage);
$this->em->flush();
return $response->withJson(Status::created());
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/Files/FlowUploadAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 838 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations\Files;
use App\Controller\SingleActionInterface;
use App\Entity\Repository\StationMediaRepository;
use App\Flysystem\StationFilesystems;
use App\Http\Response;
use App\Http\ServerRequest;
use Psr\Http\Message\ResponseInterface;
final class PlayAction implements SingleActionInterface
{
public function __construct(
private readonly StationMediaRepository $mediaRepo,
private readonly StationFilesystems $stationFilesystems
) {
}
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
set_time_limit(600);
/** @var string $id */
$id = $params['id'];
$station = $request->getStation();
$media = $this->mediaRepo->requireForStation($id, $station);
$fsMedia = $this->stationFilesystems->getMediaFilesystem($station);
return $response->streamFilesystemFile($fsMedia, $media->getPath());
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/Files/PlayAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 228 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations\Files;
use App\Controller\SingleActionInterface;
use App\Flysystem\StationFilesystems;
use App\Http\Response;
use App\Http\ServerRequest;
use App\Utilities\Types;
use League\Flysystem\StorageAttributes;
use Psr\Http\Message\ResponseInterface;
final class ListDirectoriesAction implements SingleActionInterface
{
public function __construct(
private readonly StationFilesystems $stationFilesystems
) {
}
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
$station = $request->getStation();
$currentDir = Types::string($request->getParam('currentDirectory', ''));
$fsMedia = $this->stationFilesystems->getMediaFilesystem($station);
$directoriesRaw = $fsMedia->listContents($currentDir, false)->filter(
fn(StorageAttributes $attrs) => $attrs->isDir()
&& !StationFilesystems::isDotFile($attrs->path())
)->sortByPath();
$directories = [];
foreach ($directoriesRaw as $directory) {
/** @var StorageAttributes $directory */
$path = $directory->path();
$directories[] = [
'name' => basename($path),
'path' => $path,
];
}
return $response->withJson(
[
'rows' => $directories,
]
);
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/Files/ListDirectoriesAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 318 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations\Files;
use App\Controller\SingleActionInterface;
use App\Entity\Api\Error;
use App\Flysystem\StationFilesystems;
use App\Http\Response;
use App\Http\ServerRequest;
use App\Utilities\Types;
use Psr\Http\Message\ResponseInterface;
final class DownloadAction implements SingleActionInterface
{
public function __construct(
private readonly StationFilesystems $stationFilesystems
) {
}
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
set_time_limit(600);
$station = $request->getStation();
$fsMedia = $this->stationFilesystems->getMediaFilesystem($station);
$path = Types::string($request->getParam('file'));
if (!$fsMedia->fileExists($path)) {
return $response->withStatus(404)
->withJson(Error::notFound());
}
return $response->streamFilesystemFile($fsMedia, $path);
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/Files/DownloadAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 232 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations\Streamers\Broadcasts;
use App\Controller\Api\Stations\Streamers\BroadcastsController;
use App\Controller\SingleActionInterface;
use App\Doctrine\ReadWriteBatchIteratorAggregate;
use App\Entity\Api\GenericBatchResult;
use App\Entity\StationStreamerBroadcast;
use App\Exception\NotFoundException;
use App\Http\Response;
use App\Http\ServerRequest;
use App\Utilities\Types;
use Doctrine\ORM\Query;
use InvalidArgumentException;
use Psr\Http\Message\ResponseInterface;
use Throwable;
final class BatchAction extends BroadcastsController implements SingleActionInterface
{
private const int BATCH_SIZE = 50;
public function __invoke(ServerRequest $request, Response $response, array $params): ResponseInterface
{
$id = Types::int($params['id'] ?? null);
$station = $request->getStation();
$streamer = $this->getStreamer($station, $id);
if (null === $streamer) {
throw NotFoundException::generic();
}
$parsedBody = (array)$request->getParsedBody();
if (!isset($parsedBody['rows']) || !isset($parsedBody['do'])) {
throw new InvalidArgumentException('No rows and/or action specified.');
}
$rowsQuery = $this->em->createQuery(
<<<'DQL'
SELECT ssb
FROM App\Entity\StationStreamerBroadcast ssb
WHERE ssb.streamer = :streamer
AND ssb.station = :station
AND ssb.id IN (:ids)
ORDER BY ssb.timestampStart DESC
DQL
)->setParameter('station', $station)
->setParameter('streamer', $streamer)
->setParameter('ids', Types::array($parsedBody['rows']));
$result = match (Types::string($parsedBody['do'])) {
'delete' => $this->doDelete($request, $rowsQuery),
default => throw new InvalidArgumentException('Invalid batch action specified.')
};
if ($this->em->isOpen()) {
$this->em->clear();
}
return $response->withJson($result);
}
private function doDelete(
ServerRequest $request,
Query $rowsQuery
): GenericBatchResult {
$result = new GenericBatchResult();
$fsRecordings = $this->stationFilesystems->getRecordingsFilesystem($request->getStation());
/** @var ReadWriteBatchIteratorAggregate<array-key, StationStreamerBroadcast> $rows */
$rows = ReadWriteBatchIteratorAggregate::fromQuery($rowsQuery, self::BATCH_SIZE);
foreach ($rows as $row) {
$id = $row->getIdRequired();
$result->records[] = [
'id' => $id,
'title' => (string)$row,
];
try {
$recordingPath = $row->getRecordingPath();
if (!empty($recordingPath)) {
$fsRecordings->delete($recordingPath);
}
$this->em->remove($row);
} catch (Throwable $e) {
$result->errors[] = sprintf('%s: %s', $row, $e);
}
}
return $result;
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/Streamers/Broadcasts/BatchAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 698 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations\Streamers\Art;
use App\Controller\SingleActionInterface;
use App\Entity\Api\Status;
use App\Entity\Repository\StationStreamerRepository;
use App\Http\Response;
use App\Http\ServerRequest;
use App\Service\Flow;
use Psr\Http\Message\ResponseInterface;
final class PostArtAction implements SingleActionInterface
{
public function __construct(
private readonly StationStreamerRepository $streamerRepo,
) {
}
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
/** @var string|null $id */
$id = $params['id'] ?? null;
$station = $request->getStation();
$flowResponse = Flow::process($request, $response, $station->getRadioTempDir());
if ($flowResponse instanceof ResponseInterface) {
return $flowResponse;
}
if (null !== $id) {
$streamer = $this->streamerRepo->requireForStation($id, $station);
$this->streamerRepo->writeArtwork(
$streamer,
$flowResponse->readAndDeleteUploadedFile()
);
$this->streamerRepo->getEntityManager()
->flush();
return $response->withJson(Status::updated());
}
return $response->withJson($flowResponse);
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/Streamers/Art/PostArtAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 305 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations\Streamers;
use App\Controller\Api\AbstractApiCrudController;
use App\Entity\Api\Error;
use App\Entity\Api\Status;
use App\Entity\Station;
use App\Entity\StationStreamer;
use App\Entity\StationStreamerBroadcast;
use App\Flysystem\StationFilesystems;
use App\Http\Response;
use App\Http\ServerRequest;
use App\Paginator;
use App\Utilities\File;
use App\Utilities\Types;
use Psr\Http\Message\ResponseInterface;
use Symfony\Component\Serializer\Serializer;
use Symfony\Component\Validator\Validator\ValidatorInterface;
/**
* @extends AbstractApiCrudController<StationStreamerBroadcast>
*/
class BroadcastsController extends AbstractApiCrudController
{
protected string $entityClass = StationStreamerBroadcast::class;
public function __construct(
protected readonly StationFilesystems $stationFilesystems,
Serializer $serializer,
ValidatorInterface $validator
) {
parent::__construct($serializer, $validator);
}
public function listAction(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
$id = Types::intOrNull($params['id'] ?? null);
$station = $request->getStation();
if (null !== $id) {
$streamer = $this->getStreamer($station, $id);
if (null === $streamer) {
return $response->withStatus(404)
->withJson(Error::notFound());
}
$query = $this->em->createQuery(
<<<'DQL'
SELECT ssb
FROM App\Entity\StationStreamerBroadcast ssb
WHERE ssb.station = :station AND ssb.streamer = :streamer
ORDER BY ssb.timestampStart DESC
DQL
)->setParameter('station', $station)
->setParameter('streamer', $streamer);
} else {
$query = $this->em->createQuery(
<<<'DQL'
SELECT ssb, ss
FROM App\Entity\StationStreamerBroadcast ssb
JOIN ssb.streamer ss
WHERE ssb.station = :station
ORDER BY ssb.timestampStart DESC
DQL
)->setParameter('station', $station);
}
$paginator = Paginator::fromQuery($query, $request);
$router = $request->getRouter();
$isInternal = $request->isInternal();
$fsRecordings = $this->stationFilesystems->getRecordingsFilesystem($station);
$paginator->setPostprocessor(
function ($row) use ($id, $router, $isInternal, $fsRecordings) {
$return = $this->toArray($row);
unset($return['recordingPath']);
$recordingPath = $row->getRecordingPath();
if (null === $id) {
$streamer = $row->getStreamer();
$return['streamer'] = [
'id' => $streamer->getId(),
'streamer_username' => $streamer->getStreamerUsername(),
'display_name' => $streamer->getDisplayName(),
];
}
$routeParams = [
'broadcast_id' => $row->getId(),
];
if (null === $id) {
$routeParams['id'] = $row->getStreamer()->getId();
}
if (!empty($recordingPath) && $fsRecordings->fileExists($recordingPath)) {
$return['recording'] = [
'path' => $recordingPath,
'size' => $fsRecordings->fileSize($recordingPath),
'links' => [
'download' => $router->fromHere(
routeName: 'api:stations:streamer:broadcast:download',
routeParams: $routeParams,
absolute: !$isInternal
),
],
];
} else {
$return['recording'] = [];
}
$return['links'] = [
'delete' => $router->fromHere(
routeName: 'api:stations:streamer:broadcast:delete',
routeParams: $routeParams,
absolute: !$isInternal
),
];
return $return;
}
);
return $paginator->write($response);
}
public function downloadAction(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
$station = $request->getStation();
$broadcast = $this->getRecord($request, $params);
if (null === $broadcast) {
return $response->withStatus(404)
->withJson(Error::notFound());
}
$recordingPath = $broadcast->getRecordingPath();
if (empty($recordingPath)) {
return $response->withStatus(400)
->withJson(new Error(400, __('No recording available.')));
}
$filename = basename($recordingPath);
$fsRecordings = $this->stationFilesystems->getRecordingsFilesystem($station);
return $response->streamFilesystemFile(
$fsRecordings,
$recordingPath,
File::sanitizeFileName($broadcast->getStreamer()->getDisplayName()) . '_' . $filename
);
}
public function deleteAction(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
$station = $request->getStation();
$broadcast = $this->getRecord($request, $params);
if (null === $broadcast) {
return $response->withStatus(404)
->withJson(Error::notFound());
}
$recordingPath = $broadcast->getRecordingPath();
if (!empty($recordingPath)) {
$fsRecordings = $this->stationFilesystems->getRecordingsFilesystem($station);
$fsRecordings->delete($recordingPath);
}
$this->em->remove($broadcast);
$this->em->flush();
return $response->withJson(Status::deleted());
}
protected function getRecord(ServerRequest $request, array $params): ?object
{
/** @var StationStreamerBroadcast|null $broadcast */
$broadcast = $this->em->getRepository(StationStreamerBroadcast::class)->findOneBy(
[
'id' => (int)$params['broadcast_id'],
'station' => $request->getStation(),
]
);
return $broadcast;
}
protected function getStreamer(Station $station, int|string $id): ?StationStreamer
{
/** @var StationStreamer|null $streamer */
$streamer = $this->em->getRepository(StationStreamer::class)->findOneBy(
[
'id' => (int)$id,
'station' => $station,
]
);
return $streamer;
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/Streamers/BroadcastsController.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 1,469 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations\Streamers\Art;
use App\Controller\SingleActionInterface;
use App\Entity\Api\Status;
use App\Entity\Repository\StationStreamerRepository;
use App\Http\Response;
use App\Http\ServerRequest;
use Psr\Http\Message\ResponseInterface;
final class DeleteArtAction implements SingleActionInterface
{
public function __construct(
private readonly StationStreamerRepository $streamerRepo
) {
}
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
/** @var string $id */
$id = $params['id'];
$station = $request->getStation();
$streamer = $this->streamerRepo->requireForStation($id, $station);
$this->streamerRepo->removeArtwork($streamer);
$this->streamerRepo->getEntityManager()
->flush();
return $response->withJson(Status::deleted());
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/Streamers/Art/DeleteArtAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 218 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations\Streamers\Art;
use App\Controller\SingleActionInterface;
use App\Entity\Repository\StationRepository;
use App\Entity\StationStreamer;
use App\Flysystem\StationFilesystems;
use App\Http\Response;
use App\Http\ServerRequest;
use Psr\Http\Message\ResponseInterface;
final class GetArtAction implements SingleActionInterface
{
public function __construct(
private readonly StationRepository $stationRepo,
) {
}
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
/** @var string $id */
$id = $params['id'];
$station = $request->getStation();
$artworkPath = StationStreamer::getArtworkPath($id);
$fsConfig = StationFilesystems::buildConfigFilesystem($station);
if ($fsConfig->fileExists($artworkPath)) {
return $response->streamFilesystemFile($fsConfig, $artworkPath, null, 'inline', false);
}
return $response->withRedirect(
(string)$this->stationRepo->getDefaultAlbumArtUrl($station),
302
);
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/Streamers/Art/GetArtAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 266 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations\Waveform;
use App\Controller\SingleActionInterface;
use App\Controller\Traits\ResponseHasCacheLifetime;
use App\Entity\Repository\StationMediaRepository;
use App\Entity\StationMedia;
use App\Flysystem\StationFilesystems;
use App\Http\Response;
use App\Http\ServerRequest;
use Psr\Http\Message\ResponseInterface;
final class GetWaveformAction implements SingleActionInterface
{
public function __construct(
private readonly StationMediaRepository $mediaRepo,
private readonly StationFilesystems $stationFilesystems
) {
}
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
/** @var string $mediaId */
$mediaId = $params['media_id'];
$station = $request->getStation();
$fsMedia = $this->stationFilesystems->getMediaFilesystem($station);
if (StationMedia::UNIQUE_ID_LENGTH === strlen($mediaId)) {
$waveformPath = StationMedia::getWaveformPath($mediaId);
if ($fsMedia->fileExists($waveformPath)) {
return $response->streamFilesystemFile($fsMedia, $waveformPath, null, 'inline');
}
}
$media = $this->mediaRepo->requireByUniqueId($mediaId, $station);
$waveformPath = StationMedia::getWaveformPath($media->getUniqueId());
if (!$fsMedia->fileExists($waveformPath)) {
$this->mediaRepo->updateWaveform($media);
}
return $response->streamFilesystemFile($fsMedia, $waveformPath, null, 'inline');
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/Waveform/GetWaveformAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 372 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations\Waveform;
use App\Controller\SingleActionInterface;
use App\Entity\Api\Status;
use App\Entity\Repository\StationMediaRepository;
use App\Http\Response;
use App\Http\ServerRequest;
use App\Utilities\Types;
use InvalidArgumentException;
use Psr\Http\Message\ResponseInterface;
final class PostCacheWaveformAction implements SingleActionInterface
{
public function __construct(
private readonly StationMediaRepository $mediaRepo
) {
}
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
/** @var string $mediaId */
$mediaId = $params['media_id'];
$station = $request->getStation();
$media = $this->mediaRepo->requireByUniqueId($mediaId, $station);
$waveformData = Types::arrayOrNull($request->getParsedBody());
if (empty($waveformData) || empty($waveformData['data'])) {
throw new InvalidArgumentException('No waveform data provided.');
}
$this->mediaRepo->saveWaveformData($media, $waveformData);
return $response->withJson(Status::updated());
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/Waveform/PostCacheWaveformAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 261 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations\Requests;
use App\Container\EntityManagerAwareTrait;
use App\Container\SettingsAwareTrait;
use App\Controller\SingleActionInterface;
use App\Entity\Api\Status;
use App\Entity\Repository\StationMediaRepository;
use App\Entity\Repository\StationRequestRepository;
use App\Entity\StationRequest;
use App\Entity\User;
use App\Enums\StationFeatures;
use App\Exception\Http\CannotCompleteActionException;
use App\Exception\Http\InvalidRequestAttribute;
use App\Http\Response;
use App\Http\ServerRequest;
use App\OpenApi;
use App\Radio\Frontend\Blocklist\BlocklistParser;
use App\Service\DeviceDetector;
use App\Utilities\Types;
use OpenApi\Attributes as OA;
use Psr\Http\Message\ResponseInterface;
#[
OA\Post(
path: '/station/{station_id}/request/{request_id}',
operationId: 'submitSongRequest',
description: 'Submit a song request.',
tags: ['Stations: Song Requests'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
new OA\Parameter(
name: 'request_id',
description: 'The requestable song ID',
in: 'path',
required: true,
schema: new OA\Schema(type: 'string')
),
],
responses: [
new OA\Response(ref: OpenApi::REF_RESPONSE_SUCCESS, response: 200),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_NOT_FOUND, response: 404),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
)
]
final class SubmitAction implements SingleActionInterface
{
use EntityManagerAwareTrait;
use SettingsAwareTrait;
public function __construct(
private readonly StationMediaRepository $mediaRepo,
private readonly StationRequestRepository $requestRepo,
private readonly DeviceDetector $deviceDetector,
private readonly BlocklistParser $blocklistParser
) {
}
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
$trackId = Types::string($params['media_id']);
// Verify that the station supports requests.
$station = $request->getStation();
StationFeatures::Requests->assertSupportedForStation($station);
try {
$user = $request->getUser();
} catch (InvalidRequestAttribute) {
$user = null;
}
$isAuthenticated = ($user instanceof User);
$ip = $this->readSettings()->getIp($request);
$userAgent = $request->getHeaderLine('User-Agent');
// Forbid web crawlers from using this feature.
$dd = $this->deviceDetector->parse($userAgent);
if ($dd->isBot) {
throw CannotCompleteActionException::submitRequest(
$request,
__('Search engine crawlers are not permitted to use this feature.')
);
}
// Check frontend blocklist and apply it to requests.
if (!$this->blocklistParser->isAllowed($station, $ip, $userAgent)) {
throw CannotCompleteActionException::submitRequest(
$request,
__('You are not permitted to submit requests.')
);
}
// Verify that Track ID exists with station.
$mediaItem = $this->mediaRepo->requireByUniqueId($trackId, $station);
if (!$mediaItem->isRequestable()) {
throw CannotCompleteActionException::submitRequest(
$request,
__('This track is not requestable.')
);
}
// Check if the song is already enqueued as a request.
if ($this->requestRepo->isTrackPending($mediaItem, $station)) {
throw CannotCompleteActionException::submitRequest(
$request,
__('This song was already requested and will play soon.')
);
}
// Check the most recent song history.
if ($this->requestRepo->hasPlayedRecently($mediaItem, $station)) {
throw CannotCompleteActionException::submitRequest(
$request,
__('This song or artist has been played too recently. Wait a while before requesting it again.')
);
}
if (!$isAuthenticated) {
// Check for any request (on any station) within the last $threshold_seconds.
$thresholdMins = $station->getRequestDelay() ?? 5;
$thresholdSeconds = $thresholdMins * 60;
// Always have a minimum threshold to avoid flooding.
if ($thresholdSeconds < 60) {
$thresholdSeconds = 15;
}
$recentRequests = (int)$this->em->createQuery(
<<<'DQL'
SELECT COUNT(sr.id) FROM App\Entity\StationRequest sr
WHERE sr.ip = :user_ip
AND sr.timestamp >= :threshold
DQL
)->setParameter('user_ip', $ip)
->setParameter('threshold', time() - $thresholdSeconds)
->getSingleScalarResult();
if ($recentRequests > 0) {
throw CannotCompleteActionException::submitRequest(
$request,
__('You have submitted a request too recently! Please wait before submitting another one.')
);
}
}
// Save request locally.
$record = new StationRequest($station, $mediaItem, $ip);
$this->em->persist($record);
$this->em->flush();
return $response->withJson(
new Status(true, __('Your request has been submitted and will be played soon.'))
);
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/Requests/SubmitAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 1,200 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations\Requests;
use App\Controller\Api\Stations\AbstractSearchableListAction;
use App\Entity\Api\StationRequest;
use App\Entity\ApiGenerator\SongApiGenerator;
use App\Entity\Station;
use App\Entity\StationMedia;
use App\Entity\StationPlaylist;
use App\Exception\StationUnsupportedException;
use App\Http\Response;
use App\Http\ServerRequest;
use App\OpenApi;
use App\Radio\AutoDJ\Scheduler;
use Carbon\CarbonImmutable;
use OpenApi\Attributes as OA;
use Psr\Cache\CacheItemPoolInterface;
use Psr\Http\Message\ResponseInterface;
#[
OA\Get(
path: '/station/{station_id}/requests',
operationId: 'getRequestableSongs',
description: 'Return a list of requestable songs.',
tags: ['Stations: Song Requests'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
],
responses: [
new OA\Response(
response: 200,
description: 'Success',
content: new OA\JsonContent(
type: 'array',
items: new OA\Items(ref: '#/components/schemas/Api_StationRequest')
)
),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_NOT_FOUND, response: 404),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
)
]
final class ListAction extends AbstractSearchableListAction
{
public function __construct(
private readonly Scheduler $scheduler,
SongApiGenerator $songApiGenerator,
CacheItemPoolInterface $psr6Cache,
) {
parent::__construct($songApiGenerator, $psr6Cache);
}
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
$station = $request->getStation();
$playlists = $this->getPlaylists($station);
if (empty($playlists)) {
throw StationUnsupportedException::requests();
}
$paginator = $this->getPaginator($request, $playlists);
$router = $request->getRouter();
$paginator->setPostprocessor(
function (StationMedia $media) use ($station, $router) {
$row = new StationRequest();
$row->song = ($this->songApiGenerator)($media, $station, $router->getBaseUrl());
$row->request_id = $media->getUniqueId();
$row->request_url = $router->named(
'api:requests:submit',
[
'station_id' => $station->getId(),
'media_id' => $media->getUniqueId(),
]
);
$row->resolveUrls($router->getBaseUrl());
return $row;
}
);
return $paginator->write($response);
}
/**
* @param Station $station
* @return int[]
*/
private function getPlaylists(
Station $station
): array {
$item = $this->psr6Cache->getItem('station_' . $station->getIdRequired() . '_requestable_playlists');
if (!$item->isHit()) {
$playlists = $this->em->createQuery(
<<<DQL
SELECT sp FROM App\Entity\StationPlaylist sp
WHERE sp.station = :station
AND sp.is_enabled = 1 AND sp.include_in_requests = 1
DQL
)->setParameter('station', $station)
->toIterable();
$ids = [];
$now = CarbonImmutable::now($station->getTimezoneObject());
/** @var StationPlaylist $playlist */
foreach ($playlists as $playlist) {
if ($this->scheduler->isPlaylistScheduledToPlayNow($playlist, $now, true)) {
$ids[] = $playlist->getIdRequired();
}
}
$item->set($ids);
$item->expiresAfter(600);
$this->psr6Cache->save($item);
}
return $item->get();
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/Requests/ListAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 900 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations\Playlists;
use App\Controller\SingleActionInterface;
use App\Entity\Api\Status;
use App\Entity\Repository\StationPlaylistMediaRepository;
use App\Entity\Repository\StationPlaylistRepository;
use App\Http\Response;
use App\Http\ServerRequest;
use Psr\Http\Message\ResponseInterface;
final class DeleteQueueAction implements SingleActionInterface
{
public function __construct(
private readonly StationPlaylistRepository $playlistRepo,
private readonly StationPlaylistMediaRepository $spmRepo,
) {
}
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
/** @var string $id */
$id = $params['id'];
$record = $this->playlistRepo->requireForStation($id, $request->getStation());
$this->spmRepo->resetQueue($record);
return $response->withJson(
new Status(
true,
__('Playlist queue cleared.')
)
);
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/Playlists/DeleteQueueAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 223 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations\Playlists;
use App\Controller\SingleActionInterface;
use App\Entity\Enums\PlaylistOrders;
use App\Entity\Enums\PlaylistSources;
use App\Entity\Repository\StationPlaylistMediaRepository;
use App\Entity\Repository\StationPlaylistRepository;
use App\Http\Response;
use App\Http\ServerRequest;
use App\Paginator;
use InvalidArgumentException;
use Psr\Http\Message\ResponseInterface;
final class GetQueueAction implements SingleActionInterface
{
public function __construct(
private readonly StationPlaylistRepository $playlistRepo,
private readonly StationPlaylistMediaRepository $spmRepo
) {
}
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
/** @var string $id */
$id = $params['id'];
$record = $this->playlistRepo->requireForStation($id, $request->getStation());
if (PlaylistSources::Songs !== $record->getSource()) {
throw new InvalidArgumentException('This playlist does not have songs as its primary source.');
}
if (PlaylistOrders::Random === $record->getOrder()) {
throw new InvalidArgumentException('This playlist is always shuffled and has no visible queue.');
}
$queue = $this->spmRepo->getQueue($record);
return Paginator::fromArray($queue, $request)->write($response);
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/Playlists/GetQueueAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 301 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations\Playlists;
use App\Container\EntityManagerAwareTrait;
use App\Entity\Repository\StationPlaylistRepository;
use App\Entity\StationPlaylist;
use App\Entity\StationPlaylistFolder;
use App\Entity\StationPlaylistMedia;
use App\Entity\StationSchedule;
use DeepCopy;
use Doctrine\Common\Collections\Collection;
abstract class AbstractClonableAction
{
use EntityManagerAwareTrait;
public function __construct(
protected readonly StationPlaylistRepository $playlistRepo
) {
}
protected function clone(
StationPlaylist $record,
?string $newName = null,
bool $cloneSchedules = true,
bool $cloneMedia = false
): StationPlaylist {
$copier = new DeepCopy\DeepCopy();
$copier->addFilter(
new DeepCopy\Filter\Doctrine\DoctrineProxyFilter(),
new DeepCopy\Matcher\Doctrine\DoctrineProxyMatcher()
);
$copier->addFilter(
new DeepCopy\Filter\SetNullFilter(),
new DeepCopy\Matcher\PropertyNameMatcher('id')
);
$copier->addFilter(
new DeepCopy\Filter\Doctrine\DoctrineEmptyCollectionFilter(),
new DeepCopy\Matcher\PropertyTypeMatcher(Collection::class)
);
$copier->addFilter(
new DeepCopy\Filter\KeepFilter(),
new DeepCopy\Matcher\PropertyNameMatcher('station')
);
$copier->addFilter(
new DeepCopy\Filter\KeepFilter(),
new DeepCopy\Matcher\PropertyMatcher(StationPlaylistMedia::class, 'media')
);
/** @var StationPlaylist $newRecord */
$newRecord = $copier->copy($record);
$newRecord->setName($newName ?? $record->getName() . ' - Copy');
$this->em->persist($newRecord);
if ($cloneSchedules) {
foreach ($record->getScheduleItems() as $oldScheduleItem) {
/** @var StationSchedule $newScheduleItem */
$newScheduleItem = $copier->copy($oldScheduleItem);
$newScheduleItem->setPlaylist($newRecord);
$this->em->persist($newScheduleItem);
}
}
if ($cloneMedia) {
foreach ($record->getFolders() as $oldPlaylistFolder) {
/** @var StationPlaylistFolder $newPlaylistFolder */
$newPlaylistFolder = $copier->copy($oldPlaylistFolder);
$newPlaylistFolder->setPlaylist($newRecord);
$this->em->persist($newPlaylistFolder);
}
foreach ($record->getMediaItems() as $oldMediaItem) {
/** @var StationPlaylistMedia $newMediaItem */
$newMediaItem = $copier->copy($oldMediaItem);
$newMediaItem->setPlaylist($newRecord);
$this->em->persist($newMediaItem);
}
}
$this->em->flush();
return $newRecord;
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/Playlists/AbstractClonableAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 626 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations\Playlists;
use App\Container\EntityManagerAwareTrait;
use App\Controller\SingleActionInterface;
use App\Entity\Api\Error;
use App\Entity\Api\StationPlaylistImportResult;
use App\Entity\Repository\StationPlaylistMediaRepository;
use App\Entity\Repository\StationPlaylistRepository;
use App\Entity\StationMedia;
use App\Http\Response;
use App\Http\ServerRequest;
use App\Radio\PlaylistParser;
use App\Utilities\File;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\UploadedFileInterface;
use Symfony\Component\Filesystem\Path;
final class ImportAction implements SingleActionInterface
{
use EntityManagerAwareTrait;
public function __construct(
private readonly StationPlaylistRepository $playlistRepo,
private readonly StationPlaylistMediaRepository $spmRepo
) {
}
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
/** @var string $id */
$id = $params['id'];
$playlist = $this->playlistRepo->requireForStation($id, $request->getStation());
$files = $request->getUploadedFiles();
if (empty($files['playlist_file'])) {
return $response->withStatus(500)
->withJson(new Error(500, 'No "playlist_file" provided.'));
}
/** @var UploadedFileInterface $file */
$file = $files['playlist_file'];
if (UPLOAD_ERR_OK !== $file->getError()) {
return $response->withStatus(500)
->withJson(Error::fromFileError($file->getError()));
}
$playlistFile = $file->getStream()->getContents();
$paths = PlaylistParser::getSongs($playlistFile);
$totalPaths = count($paths);
$foundPaths = 0;
$importResults = [];
if (!empty($paths)) {
$storageLocation = $request->getStation()->getMediaStorageLocation();
// Assemble list of station media to match against.
$mediaLookup = [];
$basenameLookup = [];
$mediaInfoRaw = $this->em->createQuery(
<<<'DQL'
SELECT sm.id, sm.path
FROM App\Entity\StationMedia sm
WHERE sm.storage_location = :storageLocation
DQL
)->setParameter('storageLocation', $storageLocation)
->getArrayResult();
foreach ($mediaInfoRaw as $row) {
$pathParts = explode('/', $row['path']);
$basename = File::sanitizeFileName(array_pop($pathParts));
$basenameWithoutExt = Path::getFilenameWithoutExtension($basename);
$path = (!empty($pathParts))
? implode('/', $pathParts) . '/' . $basename
: $basename;
$pathWithoutExt = (!empty($pathParts))
? implode('/', $pathParts) . '/' . $basenameWithoutExt
: $basenameWithoutExt;
$mediaLookup[$path] = $row['id'];
$mediaLookup[$pathWithoutExt] = $row['id'];
$basenameLookup[$basename] = $row['id'];
$basenameLookup[$basenameWithoutExt] = $row['id'];
}
// Run all paths against the lookup list of hashes.
$matches = [];
$matchFunction = static function ($pathRaw) use ($mediaLookup, $basenameLookup) {
// De-Windows paths (if applicable)
$pathRaw = str_replace('\\', '/', $pathRaw);
// Work backwards from the basename to try to find matches.
$pathParts = explode('/', $pathRaw);
$basename = File::sanitizeFileName(array_pop($pathParts));
$basenameWithoutExt = Path::getFilenameWithoutExtension($basename);
$pathPartsWithoutExt = $pathParts;
$pathParts[] = $basename;
$pathPartsWithoutExt[] = $basenameWithoutExt;
// Attempt full path matching if possible
if (count($pathParts) >= 2) {
for ($i = 2, $iMax = count($pathParts); $i <= $iMax; $i++) {
$path = implode('/', array_slice($pathParts, 0 - $i));
if (isset($mediaLookup[$path])) {
return [$path, $mediaLookup[$path]];
}
$pathWithoutExt = implode('/', array_slice($pathPartsWithoutExt, 0 - $i));
if (isset($mediaLookup[$pathWithoutExt])) {
return [$pathWithoutExt, $mediaLookup[$pathWithoutExt]];
}
}
}
// Attempt basename-only matching
if (isset($basenameLookup[$basename])) {
return [$basename, $basenameLookup[$basename]];
}
if (isset($basenameLookup[$basenameWithoutExt])) {
return [$basenameWithoutExt, $basenameLookup[$basenameWithoutExt]];
}
return [null, null];
};
foreach ($paths as $pathRaw) {
[$matchedPath, $match] = $matchFunction($pathRaw);
$importResults[] = [
'path' => $pathRaw,
'match' => $matchedPath,
];
if (null !== $match) {
$matches[] = $match;
}
}
// Assign all matched media to the playlist.
if (!empty($matches)) {
$matchedMediaRaw = $this->em->createQuery(
<<<'DQL'
SELECT sm
FROM App\Entity\StationMedia sm
WHERE sm.storage_location = :storageLocation AND sm.id IN (:matched_ids)
DQL
)->setParameter('storageLocation', $storageLocation)
->setParameter('matched_ids', $matches)
->execute();
/** @var StationMedia[] $mediaById */
$mediaById = [];
foreach ($matchedMediaRaw as $row) {
/** @var StationMedia $row */
$mediaById[$row->getId()] = $row;
}
$weight = $this->spmRepo->getHighestSongWeight($playlist);
// Split this process to preserve the order of the imported items.
foreach ($matches as $mediaId) {
$weight++;
$media = $mediaById[$mediaId];
$this->spmRepo->addMediaToPlaylist($media, $playlist, $weight);
$foundPaths++;
}
}
$this->em->flush();
}
return $response->withJson(
new StationPlaylistImportResult(
true,
sprintf(
__('Playlist successfully imported; %d of %d files were successfully matched.'),
$foundPaths,
$totalPaths
),
null,
$importResults
)
);
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/Playlists/ImportAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 1,443 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations\Playlists;
use App\Controller\SingleActionInterface;
use App\Entity\Api\Status;
use App\Entity\Enums\PlaylistSources;
use App\Entity\Repository\StationPlaylistMediaRepository;
use App\Entity\Repository\StationPlaylistRepository;
use App\Exception;
use App\Http\Response;
use App\Http\ServerRequest;
use Psr\Http\Message\ResponseInterface;
final class EmptyAction implements SingleActionInterface
{
public function __construct(
private readonly StationPlaylistRepository $playlistRepo,
private readonly StationPlaylistMediaRepository $spmRepo
) {
}
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
/** @var string $id */
$id = $params['id'];
$record = $this->playlistRepo->requireForStation($id, $request->getStation());
if (PlaylistSources::Songs !== $record->getSource()) {
throw new Exception(__('This playlist is not song-based.'));
}
$this->spmRepo->emptyPlaylist($record);
return $response->withJson(
new Status(
true,
__('Playlist emptied.')
)
);
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/Playlists/EmptyAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 262 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations\Playlists;
use App\Controller\SingleActionInterface;
use App\Entity\Repository\StationPlaylistRepository;
use App\Http\Response;
use App\Http\ServerRequest;
use InvalidArgumentException;
use Psr\Http\Message\ResponseInterface;
final class ExportAction implements SingleActionInterface
{
public function __construct(
private readonly StationPlaylistRepository $playlistRepo
) {
}
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
/** @var string $id */
$id = $params['id'];
/** @var string $format */
$format = $params['format'] ?? 'pls';
$record = $this->playlistRepo->requireForStation($id, $request->getStation());
$exportFileName = 'playlist_' . $record->getShortName() . '.' . $format;
$exportLines = [];
switch (strtolower($format)) {
case 'm3u':
$contentType = 'application/x-mpegURL';
foreach ($record->getMediaItems() as $mediaItem) {
$exportLines[] = $mediaItem->getMedia()->getPath();
}
break;
case 'pls':
$contentType = 'audio/x-scpls';
$exportLines[] = '[playlist]';
$i = 0;
foreach ($record->getMediaItems() as $mediaItem) {
$i++;
$media = $mediaItem->getMedia();
$exportLines[] = 'File' . $i . '=' . $media->getPath();
$exportLines[] = 'Title' . $i . '=' . $media->getArtist() . ' - ' . $media->getTitle();
$exportLines[] = 'Length' . $i . '=' . $media->getLength();
$exportLines[] = '';
}
$exportLines[] = 'NumberOfEntries=' . $i;
$exportLines[] = 'Version=2';
break;
default:
throw new InvalidArgumentException('Invalid format specified.');
}
$response->getBody()->write(implode("\n", $exportLines));
return $response->withHeader('Content-Type', $contentType)
->withHeader('Content-Disposition', 'attachment; filename=' . $exportFileName);
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/Playlists/ExportAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 503 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations\Playlists;
use App\Container\EntityManagerAwareTrait;
use App\Controller\SingleActionInterface;
use App\Entity\Enums\PlaylistOrders;
use App\Entity\Enums\PlaylistSources;
use App\Entity\Repository\StationPlaylistRepository;
use App\Exception;
use App\Http\Response;
use App\Http\ServerRequest;
use Psr\Http\Message\ResponseInterface;
final class GetOrderAction implements SingleActionInterface
{
use EntityManagerAwareTrait;
public function __construct(
private readonly StationPlaylistRepository $playlistRepo,
) {
}
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
/** @var string $id */
$id = $params['id'];
$station = $request->getStation();
$record = $this->playlistRepo->requireForStation($id, $station);
if (
PlaylistSources::Songs !== $record->getSource()
|| PlaylistOrders::Sequential !== $record->getOrder()
) {
throw new Exception(__('This playlist is not a sequential playlist.'));
}
$mediaItems = $this->em->createQuery(
<<<'DQL'
SELECT spm, sm
FROM App\Entity\StationPlaylistMedia spm
JOIN spm.media sm
WHERE spm.playlist_id = :playlist_id
ORDER BY spm.weight ASC
DQL
)->setParameter('playlist_id', $id)
->getArrayResult();
$router = $request->getRouter();
return $response->withJson(
array_map(
static function (array $row) use ($router, $station): array {
$row['media']['links'] = [
'play' => $router->named(
'api:stations:files:play',
['station_id' => $station->getIdRequired(), 'id' => $row['media']['unique_id']],
[],
true
),
];
return $row;
},
$mediaItems
)
);
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/Playlists/GetOrderAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 446 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations\Playlists;
use App\Controller\SingleActionInterface;
use App\Entity\Repository\StationPlaylistRepository;
use App\Flysystem\StationFilesystems;
use App\Http\Response;
use App\Http\ServerRequest;
use League\Flysystem\StorageAttributes;
use Psr\Http\Message\ResponseInterface;
final class GetApplyToAction implements SingleActionInterface
{
public function __construct(
private readonly StationPlaylistRepository $playlistRepo,
private readonly StationFilesystems $stationFilesystems
) {
}
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
/** @var string $id */
$id = $params['id'];
$station = $request->getStation();
$record = $this->playlistRepo->requireForStation($id, $station);
$fsMedia = $this->stationFilesystems->getMediaFilesystem($station);
// Iterate all directories to show them as selectable.
$fsIterator = $fsMedia->listContents('/', true)->filter(
fn(StorageAttributes $attrs) => $attrs->isDir() && !StationFilesystems::isDotFile($attrs->path())
)->sortByPath();
$directories = [
[
'path' => "",
'name' => '/ (' . __('Base Directory') . ')',
],
];
/** @var StorageAttributes $dir */
foreach ($fsIterator->getIterator() as $dir) {
$directories[] = [
'path' => $dir->path(),
'name' => '/' . $dir->path(),
];
}
return $response->withJson(
[
'playlist' => [
'id' => $record->getIdRequired(),
'name' => $record->getName(),
],
'directories' => $directories,
]
);
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/Playlists/GetApplyToAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 413 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations\Playlists;
use App\Controller\SingleActionInterface;
use App\Entity\Api\Status;
use App\Entity\Repository\StationPlaylistMediaRepository;
use App\Entity\Repository\StationPlaylistRepository;
use App\Http\Response;
use App\Http\ServerRequest;
use Psr\Http\Message\ResponseInterface;
final class ReshuffleAction implements SingleActionInterface
{
public function __construct(
private readonly StationPlaylistRepository $playlistRepo,
private readonly StationPlaylistMediaRepository $spmRepo
) {
}
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
/** @var string $id */
$id = $params['id'];
$record = $this->playlistRepo->requireForStation($id, $request->getStation());
$this->spmRepo->resetQueue($record);
return $response->withJson(
new Status(
true,
__('Playlist reshuffled.')
)
);
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/Playlists/ReshuffleAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 224 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations\Playlists;
use App\Controller\SingleActionInterface;
use App\Entity\Api\Status;
use App\Entity\Repository\StationPlaylistRepository;
use App\Http\Response;
use App\Http\ServerRequest;
use Psr\Http\Message\ResponseInterface;
final class ToggleAction implements SingleActionInterface
{
public function __construct(
private readonly StationPlaylistRepository $playlistRepo
) {
}
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
/** @var string $id */
$id = $params['id'];
$record = $this->playlistRepo->requireForStation($id, $request->getStation());
$newValue = !$record->getIsEnabled();
$record->setIsEnabled($newValue);
$em = $this->playlistRepo->getEntityManager();
$em->persist($record);
$em->flush();
$flashMessage = ($newValue)
? __('Playlist enabled.')
: __('Playlist disabled.');
return $response->withJson(new Status(true, $flashMessage));
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/Playlists/ToggleAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 247 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations\Playlists;
use App\Controller\SingleActionInterface;
use App\Entity\Enums\PlaylistOrders;
use App\Entity\Enums\PlaylistSources;
use App\Entity\Repository\StationPlaylistMediaRepository;
use App\Entity\Repository\StationPlaylistRepository;
use App\Exception;
use App\Http\Response;
use App\Http\ServerRequest;
use App\Utilities\Types;
use Psr\Http\Message\ResponseInterface;
final class PutOrderAction implements SingleActionInterface
{
public function __construct(
private readonly StationPlaylistRepository $playlistRepo,
private readonly StationPlaylistMediaRepository $spmRepo
) {
}
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
/** @var string $id */
$id = $params['id'];
$record = $this->playlistRepo->requireForStation($id, $request->getStation());
if (
PlaylistSources::Songs !== $record->getSource()
|| PlaylistOrders::Sequential !== $record->getOrder()
) {
throw new Exception(__('This playlist is not a sequential playlist.'));
}
$order = Types::array($request->getParam('order'));
$this->spmRepo->setMediaOrder($record, $order);
return $response->withJson($order);
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/Playlists/PutOrderAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 293 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations\Playlists;
use App\Controller\SingleActionInterface;
use App\Entity\Api\Status;
use App\Http\Response;
use App\Http\ServerRequest;
use Psr\Http\Message\ResponseInterface;
final class CloneAction extends AbstractClonableAction implements SingleActionInterface
{
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
/** @var string $id */
$id = $params['id'];
$record = $this->playlistRepo->requireForStation($id, $request->getStation());
$data = (array)$request->getParsedBody();
$toClone = $data['clone'] ?? [];
$this->clone(
$record,
$data['name'],
in_array('schedule', $toClone, true),
in_array('media', $toClone, true)
);
$this->em->flush();
return $response->withJson(Status::created());
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/Playlists/CloneAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 226 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations\Playlists;
use App\Controller\SingleActionInterface;
use App\Entity\Api\Status;
use App\Entity\Repository\StationPlaylistFolderRepository;
use App\Entity\Repository\StationPlaylistRepository;
use App\Http\Response;
use App\Http\ServerRequest;
use Psr\Http\Message\ResponseInterface;
final class PutApplyToAction extends AbstractClonableAction implements SingleActionInterface
{
public function __construct(
private readonly StationPlaylistFolderRepository $folderRepo,
StationPlaylistRepository $playlistRepo
) {
parent::__construct($playlistRepo);
}
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
/** @var string $id */
$id = $params['id'];
$station = $request->getStation();
$record = $this->playlistRepo->requireForStation($id, $station);
$data = (array)$request->getParsedBody();
$clone = $data['copyPlaylist'] ?? false;
$directories = (array)($data['directories'] ?? []);
foreach ($directories as $directory) {
if ($clone) {
$playlist = $this->clone(
$record,
$record->getName() . ' - ' . $directory
);
} else {
$playlist = $record;
}
$this->folderRepo->addPlaylistsToFolder(
$station,
$directory,
[
$playlist->getIdRequired() => 0,
]
);
}
return $response->withJson(
new Status(
true,
__('Playlist applied to folders.')
)
);
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/Playlists/PutApplyToAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 369 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations\Podcasts;
use App\Controller\SingleActionInterface;
use App\Entity\ApiGenerator\PodcastApiGenerator;
use App\Http\Response;
use App\Http\ServerRequest;
use Psr\Http\Message\ResponseInterface;
final class GetPodcastAction implements SingleActionInterface
{
public function __construct(
private readonly PodcastApiGenerator $podcastApiGen
) {
}
public function __invoke(ServerRequest $request, Response $response, array $params): ResponseInterface
{
$podcast = $request->getPodcast();
return $response->withJson(
$this->podcastApiGen->__invoke($podcast, $request)
);
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/Podcasts/GetPodcastAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 159 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations\Podcasts;
use App\Container\EntityManagerAwareTrait;
use App\Controller\Api\Traits\CanSearchResults;
use App\Controller\SingleActionInterface;
use App\Entity\ApiGenerator\PodcastApiGenerator;
use App\Entity\Podcast;
use App\Entity\Repository\PodcastRepository;
use App\Http\Response;
use App\Http\ServerRequest;
use App\Paginator;
use Psr\Http\Message\ResponseInterface;
final class ListPodcastsAction implements SingleActionInterface
{
use EntityManagerAwareTrait;
use CanSearchResults;
public function __construct(
private readonly PodcastApiGenerator $podcastApiGen,
private readonly PodcastRepository $podcastRepo
) {
}
public function __invoke(ServerRequest $request, Response $response, array $params): ResponseInterface
{
$station = $request->getStation();
$queryBuilder = $this->em->createQueryBuilder()
->select('p, pc')
->from(Podcast::class, 'p')
->leftJoin('p.categories', 'pc')
->where('p.storage_location = :storageLocation')
->andWhere('p.is_enabled = 1')
->setParameter('storageLocation', $station->getPodcastsStorageLocation())
->andWhere('p.id IN (:podcastIds)')
->setParameter('podcastIds', $this->podcastRepo->getPodcastIdsWithPublishedEpisodes($station))
->orderBy('p.title', 'ASC');
$queryBuilder = $this->searchQueryBuilder(
$request,
$queryBuilder,
[
'p.title',
]
);
$paginator = Paginator::fromQueryBuilder($queryBuilder, $request);
$paginator->setPostprocessor(fn($row) => $this->podcastApiGen->__invoke($row, $request));
return $paginator->write($response);
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/Podcasts/ListPodcastsAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 401 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations\Podcasts;
use App\Container\EntityManagerAwareTrait;
use App\Controller\SingleActionInterface;
use App\Entity\Enums\PlaylistSources;
use App\Http\Response;
use App\Http\ServerRequest;
use Psr\Http\Message\ResponseInterface;
final class PlaylistsAction implements SingleActionInterface
{
use EntityManagerAwareTrait;
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
$playlistsRaw = $this->em->createQuery(
<<<'DQL'
SELECT sp.id, sp.name
FROM App\Entity\StationPlaylist sp
WHERE sp.station = :station
AND sp.source = :sourceSongs
DQL
)->setParameter('station', $request->getStation())
->setParameter('sourceSongs', PlaylistSources::Songs->value)
->getArrayResult();
return $response->withJson(
array_column($playlistsRaw, 'name', 'id')
);
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/Podcasts/PlaylistsAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 225 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations\Podcasts\Episodes;
use App\Controller\SingleActionInterface;
use App\Entity\ApiGenerator\PodcastEpisodeApiGenerator;
use App\Entity\Repository\PodcastEpisodeRepository;
use App\Exception\NotFoundException;
use App\Http\Response;
use App\Http\ServerRequest;
use App\Utilities\Types;
use Psr\Http\Message\ResponseInterface;
final class GetEpisodeAction implements SingleActionInterface
{
public function __construct(
private readonly PodcastEpisodeRepository $episodeRepo,
private readonly PodcastEpisodeApiGenerator $episodeApiGen
) {
}
public function __invoke(ServerRequest $request, Response $response, array $params): ResponseInterface
{
$episodeId = Types::string($params['episode_id'] ?? null);
$episode = $this->episodeRepo->fetchEpisodeForPodcast(
$request->getPodcast(),
$episodeId
);
if (null === $episode) {
throw NotFoundException::podcast();
}
return $response->withJson(
$this->episodeApiGen->__invoke($episode, $request)
);
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/Podcasts/Episodes/GetEpisodeAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 247 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations\Podcasts\Episodes;
use App\Container\EntityManagerAwareTrait;
use App\Controller\Api\Traits\CanSearchResults;
use App\Controller\SingleActionInterface;
use App\Entity\ApiGenerator\PodcastEpisodeApiGenerator;
use App\Entity\Enums\PodcastSources;
use App\Entity\PodcastEpisode;
use App\Http\Response;
use App\Http\ServerRequest;
use App\Paginator;
use Psr\Http\Message\ResponseInterface;
final class ListEpisodesAction implements SingleActionInterface
{
use EntityManagerAwareTrait;
use CanSearchResults;
public function __construct(
private readonly PodcastEpisodeApiGenerator $episodeApiGen
) {
}
public function __invoke(ServerRequest $request, Response $response, array $params): ResponseInterface
{
$podcast = $request->getPodcast();
$queryBuilder = $this->em->createQueryBuilder()
->select('e, p, pm')
->from(PodcastEpisode::class, 'e')
->join('e.podcast', 'p')
->leftJoin('e.media', 'pm')
->leftJoin('e.playlist_media', 'sm')
->where('e.podcast = :podcast')
->setParameter('podcast', $podcast)
->andWhere('e.publish_at <= :publishTime')
->setParameter('publishTime', time())
->andWhere(
'(p.source = :sourceManual AND pm.id IS NOT NULL) OR (p.source = :sourcePlaylist AND sm.id IS NOT NULL)'
)
->setParameter('sourceManual', PodcastSources::Manual->value)
->setParameter('sourcePlaylist', PodcastSources::Playlist->value)
->orderBy('e.publish_at', 'DESC');
$queryBuilder = $this->searchQueryBuilder(
$request,
$queryBuilder,
[
'e.title',
]
);
$paginator = Paginator::fromQueryBuilder($queryBuilder, $request);
$paginator->setPostprocessor(fn($row) => $this->episodeApiGen->__invoke($row, $request));
return $paginator->write($response);
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/Podcasts/Episodes/ListEpisodesAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 455 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations\Podcasts;
use App\Controller\Api\Stations\PodcastEpisodesController;
use App\Controller\SingleActionInterface;
use App\Doctrine\ReadOnlyBatchIteratorAggregate;
use App\Doctrine\ReadWriteBatchIteratorAggregate;
use App\Entity\Api\PodcastBatchResult;
use App\Entity\ApiGenerator\PodcastEpisodeApiGenerator;
use App\Entity\PodcastEpisode;
use App\Entity\Repository\PodcastEpisodeRepository;
use App\Exception\ValidationException;
use App\Flysystem\StationFilesystems;
use App\Http\Response;
use App\Http\ServerRequest;
use App\Utilities\Types;
use Doctrine\ORM\Query;
use InvalidArgumentException;
use Psr\Http\Message\ResponseInterface;
use Symfony\Component\Serializer\Serializer;
use Symfony\Component\Validator\Validator\ValidatorInterface;
use Throwable;
final class BatchAction extends PodcastEpisodesController implements SingleActionInterface
{
private const int BATCH_SIZE = 50;
public function __construct(
PodcastEpisodeRepository $episodeRepository,
PodcastEpisodeApiGenerator $episodeApiGen,
Serializer $serializer,
ValidatorInterface $validator,
private readonly StationFilesystems $stationFilesystems
) {
parent::__construct($episodeRepository, $episodeApiGen, $serializer, $validator);
}
public function __invoke(ServerRequest $request, Response $response, array $params): ResponseInterface
{
$podcast = $request->getPodcast();
$parsedBody = (array)$request->getParsedBody();
if (!isset($parsedBody['episodes']) || !isset($parsedBody['do'])) {
throw new InvalidArgumentException('No episodes and/or action specified.');
}
$rowsQuery = $this->em->createQuery(
<<<'DQL'
SELECT e, pm
FROM App\Entity\PodcastEpisode e
LEFT JOIN e.media pm
WHERE e.podcast = :podcast
AND e.id IN (:ids)
ORDER BY e.publish_at DESC
DQL
)->setParameter('podcast', $podcast)
->setParameter('ids', Types::array($parsedBody['episodes']));
$result = match (Types::string($parsedBody['do'])) {
'list' => $this->doList($request, $rowsQuery),
'delete' => $this->doDelete($request, $rowsQuery),
'edit' => $this->doEdit($request, $rowsQuery, Types::array($parsedBody['records'])),
default => throw new InvalidArgumentException('Invalid batch action specified.')
};
if ($this->em->isOpen()) {
$this->em->clear();
}
return $response->withJson($result);
}
private function doList(
ServerRequest $request,
Query $rowsQuery
): PodcastBatchResult {
$result = new PodcastBatchResult();
$result->records = [];
/** @var ReadOnlyBatchIteratorAggregate<array-key, PodcastEpisode> $rows */
$rows = ReadOnlyBatchIteratorAggregate::fromQuery($rowsQuery, self::BATCH_SIZE);
foreach ($rows as $row) {
$result->episodes[] = [
'id' => $row->getIdRequired(),
'title' => $row->getTitle(),
];
$result->records[] = $this->viewRecord($row, $request);
}
return $result;
}
private function doDelete(
ServerRequest $request,
Query $rowsQuery
): PodcastBatchResult {
$result = new PodcastBatchResult();
$fsPodcasts = $this->stationFilesystems->getPodcastsFilesystem($request->getStation());
/** @var ReadWriteBatchIteratorAggregate<array-key, PodcastEpisode> $rows */
$rows = ReadWriteBatchIteratorAggregate::fromQuery($rowsQuery, self::BATCH_SIZE);
foreach ($rows as $row) {
$id = $row->getIdRequired();
$title = $row->getTitle();
$result->episodes[] = [
'id' => $id,
'title' => $title,
];
try {
$this->episodeRepository->delete($row, $fsPodcasts);
} catch (Throwable $e) {
$result->errors[] = sprintf('%s: %s', $title, $e);
}
}
return $result;
}
private function doEdit(
ServerRequest $request,
Query $rowsQuery,
array $records
): PodcastBatchResult {
$result = new PodcastBatchResult();
$recordsById = array_column($records, null, 'id');
/** @var ReadWriteBatchIteratorAggregate<array-key, PodcastEpisode> $rows */
$rows = ReadWriteBatchIteratorAggregate::fromQuery($rowsQuery, self::BATCH_SIZE);
foreach ($rows as $row) {
$id = $row->getIdRequired();
$title = $row->getTitle();
$result->episodes[] = [
'id' => $id,
'title' => $title,
];
if (isset($recordsById[$id])) {
try {
$record = $this->fromArray($recordsById[$id], $row);
$errors = $this->validator->validate($record);
if (count($errors) > 0) {
throw ValidationException::fromValidationErrors($errors);
}
$this->em->persist($record);
} catch (Throwable $e) {
$result->errors[] = sprintf('%s: %s', $title, $e);
}
} else {
$result->errors[] = sprintf('%s: No changes supplied.', $title);
}
}
return $result;
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/Podcasts/BatchAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 1,224 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations\Podcasts\Episodes\Media;
use App\Controller\SingleActionInterface;
use App\Entity\Api\Error;
use App\Entity\Api\Status;
use App\Entity\Enums\PodcastSources;
use App\Entity\Repository\PodcastEpisodeRepository;
use App\Flysystem\StationFilesystems;
use App\Http\Response;
use App\Http\ServerRequest;
use App\OpenApi;
use App\Service\Flow;
use App\Utilities\Types;
use InvalidArgumentException;
use OpenApi\Attributes as OA;
use Psr\Http\Message\ResponseInterface;
#[OA\Post(
path: '/station/{station_id}/podcast/{podcast_id}/episode/{episode_id}/media',
operationId: 'postPodcastEpisodeMedia',
description: 'Sets the media for a podcast episode.',
security: OpenApi::API_KEY_SECURITY,
tags: ['Stations: Podcasts'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
new OA\Parameter(
name: 'podcast_id',
description: 'Podcast ID',
in: 'path',
required: true,
schema: new OA\Schema(type: 'string')
),
new OA\Parameter(
name: 'episode_id',
description: 'Podcast Episode ID',
in: 'path',
required: true,
schema: new OA\Schema(type: 'string')
),
],
responses: [
new OA\Response(ref: OpenApi::REF_RESPONSE_SUCCESS, response: 200),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_NOT_FOUND, response: 404),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
)]
final class PostMediaAction implements SingleActionInterface
{
public function __construct(
private readonly PodcastEpisodeRepository $episodeRepo,
private readonly StationFilesystems $stationFilesystems
) {
}
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
$podcast = $request->getPodcast();
$station = $request->getStation();
if ($podcast->getSource() !== PodcastSources::Manual) {
throw new InvalidArgumentException('Media cannot be manually set on this podcast.');
}
$episodeId = Types::stringOrNull($params['episode_id'] ?? null, true);
$flowResponse = Flow::process($request, $response, $station->getRadioTempDir());
if ($flowResponse instanceof ResponseInterface) {
return $flowResponse;
}
if (null !== $episodeId) {
$episode = $this->episodeRepo->fetchEpisodeForPodcast($podcast, $episodeId);
if (null === $episode) {
return $response->withStatus(404)
->withJson(Error::notFound());
}
$this->episodeRepo->uploadMedia(
$episode,
$flowResponse->getClientFilename(),
$flowResponse->getUploadedPath(),
$this->stationFilesystems->getPodcastsFilesystem($station)
);
return $response->withJson(Status::updated());
}
return $response->withJson($flowResponse);
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/Podcasts/Episodes/Media/PostMediaAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 715 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations\Podcasts\Episodes\Media;
use App\Controller\SingleActionInterface;
use App\Entity\Api\Error;
use App\Entity\Api\Status;
use App\Entity\Enums\PodcastSources;
use App\Entity\PodcastEpisode;
use App\Entity\PodcastMedia;
use App\Entity\Repository\PodcastEpisodeRepository;
use App\Http\Response;
use App\Http\ServerRequest;
use App\OpenApi;
use App\Utilities\Types;
use InvalidArgumentException;
use OpenApi\Attributes as OA;
use Psr\Http\Message\ResponseInterface;
#[OA\Delete(
path: '/station/{station_id}/podcast/{podcast_id}/episode/{episode_id}/media',
operationId: 'deletePodcastEpisodeMedia',
description: 'Removes the media for a podcast episode.',
security: OpenApi::API_KEY_SECURITY,
tags: ['Stations: Podcasts'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
new OA\Parameter(
name: 'podcast_id',
description: 'Podcast ID',
in: 'path',
required: true,
schema: new OA\Schema(type: 'string')
),
new OA\Parameter(
name: 'episode_id',
description: 'Podcast Episode ID',
in: 'path',
required: true,
schema: new OA\Schema(type: 'string')
),
],
responses: [
new OA\Response(ref: OpenApi::REF_RESPONSE_SUCCESS, response: 200),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_NOT_FOUND, response: 404),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
)]
final class DeleteMediaAction implements SingleActionInterface
{
public function __construct(
private readonly PodcastEpisodeRepository $episodeRepo,
) {
}
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
$podcast = $request->getPodcast();
if ($podcast->getSource() !== PodcastSources::Manual) {
throw new InvalidArgumentException('Media cannot be manually set on this podcast.');
}
$episodeId = Types::string($params['episode_id'] ?? null);
$episode = $this->episodeRepo->fetchEpisodeForPodcast($podcast, $episodeId);
if (!($episode instanceof PodcastEpisode)) {
return $response->withStatus(404)
->withJson(Error::notFound());
}
$podcastMedia = $episode->getMedia();
if ($podcastMedia instanceof PodcastMedia) {
$this->episodeRepo->deleteMedia($podcastMedia);
}
return $response->withJson(Status::deleted());
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/Podcasts/Episodes/Media/DeleteMediaAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 621 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations\Podcasts\Episodes\Art;
use App\Container\EntityManagerAwareTrait;
use App\Controller\SingleActionInterface;
use App\Entity\Api\Error;
use App\Entity\Api\Status;
use App\Entity\Repository\PodcastEpisodeRepository;
use App\Http\Response;
use App\Http\ServerRequest;
use App\OpenApi;
use App\Service\Flow;
use App\Utilities\Types;
use OpenApi\Attributes as OA;
use Psr\Http\Message\ResponseInterface;
#[OA\Post(
path: '/station/{station_id}/podcast/{podcast_id}/episode/{episode_id}/art',
operationId: 'postPodcastEpisodeArt',
description: 'Sets the album art for a podcast episode.',
security: OpenApi::API_KEY_SECURITY,
tags: ['Stations: Podcasts'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
new OA\Parameter(
name: 'podcast_id',
description: 'Podcast ID',
in: 'path',
required: true,
schema: new OA\Schema(type: 'string')
),
new OA\Parameter(
name: 'episode_id',
description: 'Podcast Episode ID',
in: 'path',
required: true,
schema: new OA\Schema(type: 'string')
),
],
responses: [
new OA\Response(ref: OpenApi::REF_RESPONSE_SUCCESS, response: 200),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_NOT_FOUND, response: 404),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
)]
final class PostArtAction implements SingleActionInterface
{
use EntityManagerAwareTrait;
public function __construct(
private readonly PodcastEpisodeRepository $episodeRepo,
) {
}
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
$episodeId = Types::stringOrNull($params['episode_id'] ?? null, true);
$station = $request->getStation();
$flowResponse = Flow::process($request, $response, $station->getRadioTempDir());
if ($flowResponse instanceof ResponseInterface) {
return $flowResponse;
}
if (null !== $episodeId) {
$episode = $this->episodeRepo->fetchEpisodeForPodcast(
$request->getPodcast(),
$episodeId
);
if (null === $episode) {
return $response->withStatus(404)
->withJson(Error::notFound());
}
$this->episodeRepo->writeEpisodeArt(
$episode,
$flowResponse->readAndDeleteUploadedFile()
);
$this->em->flush();
return $response->withJson(Status::updated());
}
return $response->withJson($flowResponse);
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/Podcasts/Episodes/Art/PostArtAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 648 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations\Podcasts\Episodes\Media;
use App\Controller\SingleActionInterface;
use App\Entity\Api\Error;
use App\Entity\Enums\PodcastSources;
use App\Entity\PodcastEpisode;
use App\Entity\PodcastMedia;
use App\Entity\Repository\PodcastEpisodeRepository;
use App\Entity\StationMedia;
use App\Flysystem\StationFilesystems;
use App\Http\Response;
use App\Http\ServerRequest;
use App\OpenApi;
use App\Utilities\Types;
use OpenApi\Attributes as OA;
use Psr\Http\Message\ResponseInterface;
#[OA\Get(
path: '/station/{station_id}/podcast/{podcast_id}/episode/{episode_id}/media',
operationId: 'getPodcastEpisodeMedia',
description: 'Gets the media for a podcast episode.',
security: OpenApi::API_KEY_SECURITY,
tags: ['Stations: Podcasts'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
new OA\Parameter(
name: 'podcast_id',
description: 'Podcast ID',
in: 'path',
required: true,
schema: new OA\Schema(type: 'string')
),
new OA\Parameter(
name: 'episode_id',
description: 'Podcast Episode ID',
in: 'path',
required: true,
schema: new OA\Schema(type: 'string')
),
],
responses: [
new OA\Response(
response: 200,
description: 'Success'
),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_NOT_FOUND, response: 404),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
)]
final class GetMediaAction implements SingleActionInterface
{
public function __construct(
private readonly PodcastEpisodeRepository $episodeRepo,
private readonly StationFilesystems $stationFilesystems,
) {
}
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
set_time_limit(600);
$episodeId = Types::string($params['episode_id'] ?? null);
$station = $request->getStation();
$podcast = $request->getPodcast();
$episode = $this->episodeRepo->fetchEpisodeForPodcast(
$podcast,
$episodeId
);
if ($episode instanceof PodcastEpisode) {
switch ($podcast->getSource()) {
case PodcastSources::Playlist:
$playlistMedia = $episode->getPlaylistMedia();
if ($playlistMedia instanceof StationMedia) {
$fsMedia = $this->stationFilesystems->getMediaFilesystem($station);
set_time_limit(600);
return $response->streamFilesystemFile(
$fsMedia,
$playlistMedia->getPath()
);
}
break;
case PodcastSources::Manual:
$podcastMedia = $episode->getMedia();
if ($podcastMedia instanceof PodcastMedia) {
$fsPodcasts = $this->stationFilesystems->getPodcastsFilesystem($station);
$path = $podcastMedia->getPath();
if ($fsPodcasts->fileExists($path)) {
return $response->streamFilesystemFile(
$fsPodcasts,
$path,
$podcastMedia->getOriginalName()
);
}
}
break;
}
}
return $response->withStatus(404)
->withJson(Error::notFound());
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/Podcasts/Episodes/Media/GetMediaAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 788 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations\Podcasts\Episodes\Art;
use App\Controller\SingleActionInterface;
use App\Entity\Podcast;
use App\Entity\PodcastEpisode;
use App\Entity\Repository\StationRepository;
use App\Flysystem\StationFilesystems;
use App\Http\Response;
use App\Http\ServerRequest;
use App\OpenApi;
use App\Utilities\Types;
use OpenApi\Attributes as OA;
use Psr\Http\Message\ResponseInterface;
#[OA\Get(
path: '/station/{station_id}/podcast/{podcast_id}/episode/{episode_id}/art',
operationId: 'getPodcastEpisodeArt',
description: 'Gets the album art for a podcast episode.',
security: OpenApi::API_KEY_SECURITY,
tags: ['Stations: Podcasts'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
new OA\Parameter(
name: 'podcast_id',
description: 'Podcast ID',
in: 'path',
required: true,
schema: new OA\Schema(type: 'string')
),
new OA\Parameter(
name: 'episode_id',
description: 'Podcast Episode ID',
in: 'path',
required: true,
schema: new OA\Schema(type: 'string')
),
],
responses: [
new OA\Response(
response: 200,
description: 'Success'
),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_NOT_FOUND, response: 404),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
)]
final class GetArtAction implements SingleActionInterface
{
public function __construct(
private readonly StationRepository $stationRepo,
private readonly StationFilesystems $stationFilesystems
) {
}
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
$episodeId = Types::string($params['episode_id'] ?? null);
$podcast = $request->getPodcast();
$station = $request->getStation();
$episodeArtPath = PodcastEpisode::getArtPath($episodeId);
$fsPodcasts = $this->stationFilesystems->getPodcastsFilesystem($station);
if ($fsPodcasts->fileExists($episodeArtPath)) {
return $response->streamFilesystemFile($fsPodcasts, $episodeArtPath, null, 'inline', false);
}
$podcastArtPath = Podcast::getArtPath($podcast->getIdRequired());
if ($fsPodcasts->fileExists($podcastArtPath)) {
return $response->streamFilesystemFile($fsPodcasts, $podcastArtPath, null, 'inline', false);
}
return $response->withRedirect(
(string)$this->stationRepo->getDefaultAlbumArtUrl($station),
302
);
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/Podcasts/Episodes/Art/GetArtAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 661 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations\Podcasts\Episodes\Art;
use App\Container\EntityManagerAwareTrait;
use App\Controller\SingleActionInterface;
use App\Entity\Api\Error;
use App\Entity\Api\Status;
use App\Entity\Repository\PodcastEpisodeRepository;
use App\Http\Response;
use App\Http\ServerRequest;
use App\OpenApi;
use App\Utilities\Types;
use OpenApi\Attributes as OA;
use Psr\Http\Message\ResponseInterface;
#[OA\Delete(
path: '/station/{station_id}/podcast/{podcast_id}/episode/{episode_id}/art',
operationId: 'deletePodcastEpisodeArt',
description: 'Removes the album art for a podcast episode.',
security: OpenApi::API_KEY_SECURITY,
tags: ['Stations: Podcasts'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
new OA\Parameter(
name: 'podcast_id',
description: 'Podcast ID',
in: 'path',
required: true,
schema: new OA\Schema(type: 'string')
),
new OA\Parameter(
name: 'episode_id',
description: 'Podcast Episode ID',
in: 'path',
required: true,
schema: new OA\Schema(type: 'string')
),
],
responses: [
new OA\Response(
response: 200,
description: 'Success',
content: new OA\JsonContent(ref: '#/components/schemas/Api_Status')
),
new OA\Response(
response: 404,
description: 'Record not found',
content: new OA\JsonContent(ref: '#/components/schemas/Api_Error')
),
new OA\Response(
response: 403,
description: 'Access denied',
content: new OA\JsonContent(ref: '#/components/schemas/Api_Error')
),
]
)]
final class DeleteArtAction implements SingleActionInterface
{
use EntityManagerAwareTrait;
public function __construct(
private readonly PodcastEpisodeRepository $episodeRepo,
) {
}
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
$episodeId = Types::string($params['episode_id'] ?? null);
$episode = $this->episodeRepo->fetchEpisodeForPodcast(
$request->getPodcast(),
$episodeId
);
if ($episode === null) {
return $response->withStatus(404)
->withJson(Error::notFound());
}
$this->episodeRepo->removeEpisodeArt($episode);
$this->em->persist($episode);
$this->em->flush();
return $response->withJson(Status::deleted());
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/Podcasts/Episodes/Art/DeleteArtAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 601 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations\Podcasts\Art;
use App\Container\EntityManagerAwareTrait;
use App\Controller\SingleActionInterface;
use App\Entity\Api\Status;
use App\Entity\Repository\PodcastRepository;
use App\Exception\Http\InvalidRequestAttribute;
use App\Http\Response;
use App\Http\ServerRequest;
use App\OpenApi;
use App\Service\Flow;
use OpenApi\Attributes as OA;
use Psr\Http\Message\ResponseInterface;
#[OA\Post(
path: '/station/{station_id}/podcast/{podcast_id}/art',
operationId: 'postPodcastArt',
description: 'Sets the album art for a podcast.',
security: OpenApi::API_KEY_SECURITY,
tags: ['Stations: Podcasts'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
new OA\Parameter(
name: 'podcast_id',
description: 'Podcast ID',
in: 'path',
required: true,
schema: new OA\Schema(type: 'string')
),
],
responses: [
new OA\Response(ref: OpenApi::REF_RESPONSE_SUCCESS, response: 200),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_NOT_FOUND, response: 404),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
)]
final class PostArtAction implements SingleActionInterface
{
use EntityManagerAwareTrait;
public function __construct(
private readonly PodcastRepository $podcastRepo,
) {
}
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
$station = $request->getStation();
try {
$podcast = $request->getPodcast();
} catch (InvalidRequestAttribute) {
$podcast = null;
}
$mediaStorage = $station->getPodcastsStorageLocation();
$mediaStorage->errorIfFull();
$flowResponse = Flow::process($request, $response, $station->getRadioTempDir());
if ($flowResponse instanceof ResponseInterface) {
return $flowResponse;
}
if (null !== $podcast) {
$this->podcastRepo->writePodcastArt(
$podcast,
$flowResponse->readAndDeleteUploadedFile()
);
$this->em->flush();
return $response->withJson(Status::updated());
}
return $response->withJson($flowResponse);
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/Podcasts/Art/PostArtAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 564 |
```php
<?php
declare(strict_types=1);
namespace App\Controller\Api\Stations\Podcasts\Art;
use App\Controller\SingleActionInterface;
use App\Entity\Podcast;
use App\Entity\Repository\StationRepository;
use App\Flysystem\StationFilesystems;
use App\Http\Response;
use App\Http\ServerRequest;
use App\OpenApi;
use OpenApi\Attributes as OA;
use Psr\Http\Message\ResponseInterface;
#[OA\Get(
path: '/station/{station_id}/podcast/{podcast_id}/art',
operationId: 'getPodcastArt',
description: 'Gets the album art for a podcast.',
security: OpenApi::API_KEY_SECURITY,
tags: ['Stations: Podcasts'],
parameters: [
new OA\Parameter(ref: OpenApi::REF_STATION_ID_REQUIRED),
new OA\Parameter(
name: 'podcast_id',
description: 'Podcast ID',
in: 'path',
required: true,
schema: new OA\Schema(type: 'string')
),
],
responses: [
new OA\Response(
response: 200,
description: 'Success',
),
new OA\Response(ref: OpenApi::REF_RESPONSE_ACCESS_DENIED, response: 403),
new OA\Response(ref: OpenApi::REF_RESPONSE_NOT_FOUND, response: 404),
new OA\Response(ref: OpenApi::REF_RESPONSE_GENERIC_ERROR, response: 500),
]
)]
final class GetArtAction implements SingleActionInterface
{
public function __construct(
private readonly StationRepository $stationRepo,
private readonly StationFilesystems $stationFilesystems,
) {
}
public function __invoke(
ServerRequest $request,
Response $response,
array $params
): ResponseInterface {
$podcast = $request->getPodcast();
$station = $request->getStation();
$podcastPath = Podcast::getArtPath($podcast->getIdRequired());
$fsPodcasts = $this->stationFilesystems->getPodcastsFilesystem($station);
if ($fsPodcasts->fileExists($podcastPath)) {
return $response->streamFilesystemFile($fsPodcasts, $podcastPath, null, 'inline', false);
}
return $response->withRedirect(
(string)$this->stationRepo->getDefaultAlbumArtUrl($station),
302
);
}
}
``` | /content/code_sandbox/backend/src/Controller/Api/Stations/Podcasts/Art/GetArtAction.php | php | 2016-04-30T21:41:23 | 2024-08-16T18:27:26 | AzuraCast | AzuraCast/AzuraCast | 2,978 | 511 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.