352 lines
12 KiB
PHP
352 lines
12 KiB
PHP
<?php
|
|
|
|
namespace app\controller\Api;
|
|
|
|
use app\service\AdminAuthService;
|
|
use app\service\AdminConsole\AdminDocService;
|
|
use app\service\AdminConsole\ArchiveAdminService;
|
|
use app\service\AdminConsole\MaintenanceScriptService;
|
|
use app\service\AdminConsole\OpenSearchAdminService;
|
|
use app\service\AdminUserRepository;
|
|
use InvalidArgumentException;
|
|
use JsonException;
|
|
use support\Request;
|
|
use support\Response;
|
|
use Throwable;
|
|
|
|
class AdminConsoleController
|
|
{
|
|
public function archives(Request $request): Response
|
|
{
|
|
if ($guard = $this->guard($request)) {
|
|
return $guard;
|
|
}
|
|
|
|
try {
|
|
$data = (new ArchiveAdminService())->list(
|
|
trim((string) $request->get('query', '')),
|
|
(int) $request->get('page', 1),
|
|
(int) $request->get('page_size', 20),
|
|
);
|
|
} catch (Throwable $exception) {
|
|
return $this->error(500, 'Archive list lookup failed.', ['archives' => $exception->getMessage()]);
|
|
}
|
|
|
|
return $this->ok('Archive list loaded.', $data);
|
|
}
|
|
|
|
public function archive(Request $request, string $archiveUid): Response
|
|
{
|
|
if ($guard = $this->guard($request)) {
|
|
return $guard;
|
|
}
|
|
|
|
try {
|
|
$archive = (new ArchiveAdminService())->detail($archiveUid);
|
|
} catch (Throwable $exception) {
|
|
return $this->error(500, 'Archive lookup failed.', ['archive' => $exception->getMessage()]);
|
|
}
|
|
|
|
if ($archive === null) {
|
|
return $this->error(404, 'Archive not found.', ['archive_uid' => $archiveUid], 404);
|
|
}
|
|
|
|
return $this->ok('Archive loaded.', $archive);
|
|
}
|
|
|
|
public function updateArchive(Request $request, string $archiveUid): Response
|
|
{
|
|
if ($guard = $this->guard($request)) {
|
|
return $guard;
|
|
}
|
|
|
|
try {
|
|
$archive = (new ArchiveAdminService())->update($archiveUid, $this->payload($request));
|
|
} catch (JsonException $exception) {
|
|
return $this->error(400, 'Invalid JSON body.', ['body' => $exception->getMessage()], 400);
|
|
} catch (InvalidArgumentException $exception) {
|
|
return $this->error(422, 'Archive update validation failed.', ['archive' => $exception->getMessage()], 422);
|
|
} catch (Throwable $exception) {
|
|
return $this->error(500, 'Archive update failed.', ['archive' => $exception->getMessage()]);
|
|
}
|
|
|
|
if ($archive === null) {
|
|
return $this->error(404, 'Archive not found.', ['archive_uid' => $archiveUid], 404);
|
|
}
|
|
|
|
return $this->ok('Archive updated.', $archive);
|
|
}
|
|
|
|
public function deleteArchive(Request $request, string $archiveUid): Response
|
|
{
|
|
if ($guard = $this->guard($request)) {
|
|
return $guard;
|
|
}
|
|
|
|
try {
|
|
$deleted = (new ArchiveAdminService())->delete($archiveUid);
|
|
} catch (Throwable $exception) {
|
|
return $this->error(500, 'Archive delete failed.', ['archive' => $exception->getMessage()]);
|
|
}
|
|
|
|
if (!$deleted) {
|
|
return $this->error(404, 'Archive not found.', ['archive_uid' => $archiveUid], 404);
|
|
}
|
|
|
|
return $this->ok('Archive deleted.', ['archive_uid' => $archiveUid]);
|
|
}
|
|
|
|
public function openSearchStatus(Request $request): Response
|
|
{
|
|
if ($guard = $this->guard($request)) {
|
|
return $guard;
|
|
}
|
|
|
|
try {
|
|
$status = (new OpenSearchAdminService())->status();
|
|
} catch (Throwable $exception) {
|
|
return $this->error(500, 'OpenSearch status lookup failed.', ['opensearch' => $exception->getMessage()]);
|
|
}
|
|
|
|
return $this->ok('OpenSearch status loaded.', $status);
|
|
}
|
|
|
|
public function openSearchDocuments(Request $request): Response
|
|
{
|
|
if ($guard = $this->guard($request)) {
|
|
return $guard;
|
|
}
|
|
|
|
try {
|
|
$documents = (new OpenSearchAdminService())->documents(
|
|
trim((string) $request->get('query', '')),
|
|
(int) $request->get('size', 20),
|
|
);
|
|
} catch (Throwable $exception) {
|
|
return $this->error(500, 'OpenSearch document lookup failed.', ['opensearch' => $exception->getMessage()]);
|
|
}
|
|
|
|
return $this->ok('OpenSearch documents loaded.', $documents);
|
|
}
|
|
|
|
public function users(Request $request): Response
|
|
{
|
|
if ($guard = $this->guard($request)) {
|
|
return $guard;
|
|
}
|
|
|
|
try {
|
|
$users = (new AdminUserRepository())->listAll();
|
|
} catch (Throwable $exception) {
|
|
return $this->error(500, 'Admin users lookup failed.', ['users' => $exception->getMessage()]);
|
|
}
|
|
|
|
return $this->ok('Admin users loaded.', ['items' => array_map(fn (array $user): array => $this->sanitizeUser($user), $users)]);
|
|
}
|
|
|
|
public function createUser(Request $request): Response
|
|
{
|
|
if ($guard = $this->guard($request)) {
|
|
return $guard;
|
|
}
|
|
|
|
try {
|
|
$payload = $this->payload($request);
|
|
$username = trim((string) ($payload['username'] ?? ''));
|
|
$password = trim((string) ($payload['password'] ?? ''));
|
|
$displayName = trim((string) ($payload['display_name'] ?? ''));
|
|
|
|
if ($username === '' || $password === '') {
|
|
throw new InvalidArgumentException('username and password are required.');
|
|
}
|
|
|
|
$repository = new AdminUserRepository();
|
|
if ($repository->findAnyByUsername($username)) {
|
|
throw new InvalidArgumentException('username already exists.');
|
|
}
|
|
|
|
$user = $repository->create($username, $password, $displayName !== '' ? $displayName : null);
|
|
} catch (JsonException $exception) {
|
|
return $this->error(400, 'Invalid JSON body.', ['body' => $exception->getMessage()], 400);
|
|
} catch (InvalidArgumentException $exception) {
|
|
return $this->error(422, 'Admin user creation validation failed.', ['user' => $exception->getMessage()], 422);
|
|
} catch (Throwable $exception) {
|
|
return $this->error(500, 'Admin user creation failed.', ['user' => $exception->getMessage()]);
|
|
}
|
|
|
|
return $this->ok('Admin user created.', ['user' => $this->sanitizeUser($user)]);
|
|
}
|
|
|
|
public function updateUser(Request $request, int $id): Response
|
|
{
|
|
if ($guard = $this->guard($request)) {
|
|
return $guard;
|
|
}
|
|
|
|
try {
|
|
$payload = $this->payload($request);
|
|
$repository = new AdminUserRepository();
|
|
if ($repository->findAnyById($id) === null) {
|
|
return $this->error(404, 'Admin user not found.', ['id' => $id], 404);
|
|
}
|
|
|
|
$updates = [];
|
|
if (array_key_exists('display_name', $payload)) {
|
|
$updates['display_name'] = $payload['display_name'];
|
|
}
|
|
if (array_key_exists('password', $payload)) {
|
|
$updates['password'] = $payload['password'];
|
|
}
|
|
if (array_key_exists('is_active', $payload)) {
|
|
$updates['is_active'] = (bool) $payload['is_active'];
|
|
}
|
|
|
|
$user = $repository->updateUser($id, $updates);
|
|
} catch (JsonException $exception) {
|
|
return $this->error(400, 'Invalid JSON body.', ['body' => $exception->getMessage()], 400);
|
|
} catch (Throwable $exception) {
|
|
return $this->error(500, 'Admin user update failed.', ['user' => $exception->getMessage()]);
|
|
}
|
|
|
|
return $this->ok('Admin user updated.', ['user' => $this->sanitizeUser($user ?? [])]);
|
|
}
|
|
|
|
public function docs(Request $request): Response
|
|
{
|
|
if ($guard = $this->guard($request)) {
|
|
return $guard;
|
|
}
|
|
|
|
try {
|
|
$docs = (new AdminDocService())->list();
|
|
} catch (Throwable $exception) {
|
|
return $this->error(500, 'API docs lookup failed.', ['docs' => $exception->getMessage()]);
|
|
}
|
|
|
|
return $this->ok('API docs loaded.', ['items' => $docs]);
|
|
}
|
|
|
|
public function doc(Request $request, string $name): Response
|
|
{
|
|
if ($guard = $this->guard($request)) {
|
|
return $guard;
|
|
}
|
|
|
|
try {
|
|
$doc = (new AdminDocService())->read($name);
|
|
} catch (Throwable $exception) {
|
|
return $this->error(404, 'API doc not found.', ['doc' => $exception->getMessage()], 404);
|
|
}
|
|
|
|
return $this->ok('API doc loaded.', $doc);
|
|
}
|
|
|
|
public function scripts(Request $request): Response
|
|
{
|
|
if ($guard = $this->guard($request)) {
|
|
return $guard;
|
|
}
|
|
|
|
return $this->ok('Maintenance scripts loaded.', ['items' => (new MaintenanceScriptService())->list()]);
|
|
}
|
|
|
|
public function script(Request $request, string $name): Response
|
|
{
|
|
if ($guard = $this->guard($request)) {
|
|
return $guard;
|
|
}
|
|
|
|
try {
|
|
$script = (new MaintenanceScriptService())->describe($name);
|
|
} catch (Throwable $exception) {
|
|
return $this->error(404, 'Maintenance script not found.', ['script' => $exception->getMessage()], 404);
|
|
}
|
|
|
|
return $this->ok('Maintenance script loaded.', $script);
|
|
}
|
|
|
|
public function runScript(Request $request): Response
|
|
{
|
|
if ($guard = $this->guard($request)) {
|
|
return $guard;
|
|
}
|
|
|
|
try {
|
|
$payload = $this->payload($request);
|
|
$scriptName = trim((string) ($payload['script_name'] ?? ''));
|
|
$args = $payload['args'] ?? [];
|
|
|
|
if ($scriptName === '') {
|
|
throw new InvalidArgumentException('script_name is required.');
|
|
}
|
|
if (!is_array($args)) {
|
|
throw new InvalidArgumentException('args must be an array.');
|
|
}
|
|
|
|
$result = (new MaintenanceScriptService())->run($scriptName, $args);
|
|
} catch (JsonException $exception) {
|
|
return $this->error(400, 'Invalid JSON body.', ['body' => $exception->getMessage()], 400);
|
|
} catch (InvalidArgumentException $exception) {
|
|
return $this->error(422, 'Script execution validation failed.', ['script' => $exception->getMessage()], 422);
|
|
} catch (Throwable $exception) {
|
|
return $this->error(500, 'Script execution failed.', ['script' => $exception->getMessage()]);
|
|
}
|
|
|
|
return $this->ok('Maintenance script finished.', $result);
|
|
}
|
|
|
|
private function guard(Request $request): ?Response
|
|
{
|
|
return (new AdminAuthService())->current($request) === null
|
|
? $this->error(401, 'Admin session not found.', [], 401)
|
|
: null;
|
|
}
|
|
|
|
/**
|
|
* @throws JsonException
|
|
*/
|
|
private function payload(Request $request): array
|
|
{
|
|
$rawBody = trim($request->rawBody());
|
|
if ($rawBody === '') {
|
|
return $request->post();
|
|
}
|
|
|
|
$payload = json_decode($rawBody, true, 512, JSON_THROW_ON_ERROR);
|
|
return is_array($payload) ? $payload : [];
|
|
}
|
|
|
|
private function ok(string $message, array $data): Response
|
|
{
|
|
return $this->jsonResponse([
|
|
'code' => 0,
|
|
'message' => $message,
|
|
'data' => $data,
|
|
], 200);
|
|
}
|
|
|
|
private function error(int $code, string $message, array $errors = [], int $status = 500): Response
|
|
{
|
|
return $this->jsonResponse([
|
|
'code' => $code,
|
|
'message' => $message,
|
|
'errors' => $errors,
|
|
], $status);
|
|
}
|
|
|
|
private function sanitizeUser(array $user): array
|
|
{
|
|
unset($user['password_hash']);
|
|
return $user;
|
|
}
|
|
|
|
private function jsonResponse(array $data, int $status): Response
|
|
{
|
|
return response(
|
|
json_encode($data, JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES | JSON_THROW_ON_ERROR),
|
|
$status,
|
|
['Content-Type' => 'application/json']
|
|
);
|
|
}
|
|
}
|