fe_comment v2: FE-user feedback tickets with summary, uploads and API
- Replace the v1 submit endpoint with a full JSON API under
/api/fe-comment/ (state, feedback create/update/delete, uploads,
summary notes/recipients, submit), guarded by frontend login and a
configurable FE user group; unauthorized callers get {"allowed":false}
- New models: tx_fecomment_summary (one open ticket per user, status
open/sent) and tx_fecomment_feedback (url, RTE note, FAL attachments),
both editable in the backend on the ticket storage page
- FeedbackApiMiddleware registered after frontend authentication (the
frontend.user attribute does not exist earlier); uploads land in
fileadmin/fe_comment/summary-<uid>/ with mime/extension check, 20 MB cap
- Submit sends one HTML mail (author block, items with attachment links,
reply-to = FE user mail) to selected recipients with mailTo fallback,
then closes the summary
- felogin wired React-compatible: felogin.pid=520 plus headless FeLogin
JSON templates via site settings - felogin v14 and EXT:headless both
claim templateRootPaths.10, the felogin.view.* settings feed exactly
that index, so the structured JSON form (incl. __RequestToken) wins
- Read the sys_file_reference insert id before syncAttachmentCount():
DBAL throws "no identity value" once the count UPDATE has run
- migrations: drop_fecomment_tables.php (repairs the no-uid tables,
only drops when empty), check_feuser.php (login diagnosis),
fec_login_test.sh / fec_api_test.sh (curl chains incl. CSRF token flow)
This commit is contained in:
orasche committed
1 parent
78af83d2e3
commit
872c6e715c
14 files changed
+842
-95
No files matched your search
@@ -0,0 +1,452 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace Evomedien\FeComment\Middleware;
|
||||
|
||||
use Evomedien\FeComment\Service\ExtensionSettings;
|
||||
use Psr\Http\Message\ResponseInterface;
|
||||
use Psr\Http\Message\ServerRequestInterface;
|
||||
use Psr\Http\Server\MiddlewareInterface;
|
||||
use Psr\Http\Server\RequestHandlerInterface;
|
||||
use TYPO3\CMS\Core\Database\ConnectionPool;
|
||||
use TYPO3\CMS\Core\Http\JsonResponse;
|
||||
use TYPO3\CMS\Core\Mail\MailMessage;
|
||||
use TYPO3\CMS\Core\Resource\Enum\DuplicationBehavior;
|
||||
use TYPO3\CMS\Core\Resource\StorageRepository;
|
||||
use TYPO3\CMS\Core\Utility\GeneralUtility;
|
||||
use TYPO3\CMS\Frontend\Authentication\FrontendUserAuthentication;
|
||||
|
||||
/**
|
||||
* fe_comment v2 API (2026-10-02): server-side feedback with FE-user
|
||||
* ownership. Every route requires a logged-in frontend user who is a member
|
||||
* of the configured group - that is how the ticket carries its author.
|
||||
*
|
||||
* GET /api/fe-comment/state widget bootstrap: am I
|
||||
* allowed, who am I, recipients, my open summary with items
|
||||
* POST /api/fe-comment/feedback create {url, note}
|
||||
* POST /api/fe-comment/feedback/<uid> update {url?, note}
|
||||
* POST /api/fe-comment/feedback/<uid>/delete remove item
|
||||
* POST /api/fe-comment/upload multipart: file +
|
||||
* feedback=<uid>; attaches via FAL, returns {id, name, url}
|
||||
* POST /api/fe-comment/attachment/<refUid>/delete
|
||||
* POST /api/fe-comment/summary {generalNotes, recipients}
|
||||
* POST /api/fe-comment/submit mail + close the summary
|
||||
*
|
||||
* Registered AFTER typo3/cms-frontend/authentication - earlier in the stack
|
||||
* the frontend.user attribute does not exist yet. Records are written with
|
||||
* plain inserts (no DataHandler in FE context); the TCA gives the backend
|
||||
* read access. Incoming note HTML is passed through TYPO3's HTML sanitizer.
|
||||
*/
|
||||
final class FeedbackApiMiddleware implements MiddlewareInterface
|
||||
{
|
||||
private const PREFIX = '/api/fe-comment/';
|
||||
private const T_SUMMARY = 'tx_fecomment_summary';
|
||||
private const T_FEEDBACK = 'tx_fecomment_feedback';
|
||||
private const MAX_NOTE = 100000;
|
||||
private const MAX_UPLOAD = 20971520; // 20 MB
|
||||
|
||||
private ExtensionSettings $settings;
|
||||
|
||||
public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
|
||||
{
|
||||
$path = rtrim($request->getUri()->getPath(), '/');
|
||||
if (!str_starts_with($path . '/', self::PREFIX) || in_array(substr($path, strlen(self::PREFIX)), ['widget.js', 'widget.css'], true)) {
|
||||
return $handler->handle($request);
|
||||
}
|
||||
$route = substr($path, strlen(self::PREFIX));
|
||||
|
||||
try {
|
||||
$this->settings = GeneralUtility::makeInstance(ExtensionSettings::class);
|
||||
if (!$this->settings->enabled()) {
|
||||
return new JsonResponse(['error' => 'disabled'], 403);
|
||||
}
|
||||
$user = $this->allowedUser($request);
|
||||
if ($user === null) {
|
||||
// The state route answers politely so the widget can hide
|
||||
// itself; everything else refuses.
|
||||
return $route === 'state'
|
||||
? new JsonResponse(['allowed' => false])
|
||||
: new JsonResponse(['error' => 'not allowed'], 403);
|
||||
}
|
||||
|
||||
return match (true) {
|
||||
$route === 'state' && $request->getMethod() === 'GET' => $this->state($user),
|
||||
$route === 'feedback' => $this->createFeedback($request, $user),
|
||||
(bool)preg_match('#^feedback/(\d+)$#', $route, $m) => $this->updateFeedback($request, $user, (int)$m[1]),
|
||||
(bool)preg_match('#^feedback/(\d+)/delete$#', $route, $m) => $this->deleteFeedback($user, (int)$m[1]),
|
||||
$route === 'upload' => $this->upload($request, $user),
|
||||
(bool)preg_match('#^attachment/(\d+)/delete$#', $route, $m) => $this->deleteAttachment($user, (int)$m[1]),
|
||||
$route === 'summary' => $this->updateSummary($request, $user),
|
||||
$route === 'submit' => $this->submit($user),
|
||||
default => new JsonResponse(['error' => 'unknown route'], 404),
|
||||
};
|
||||
} catch (\Throwable $e) {
|
||||
return new JsonResponse(['error' => $e->getMessage()], 500);
|
||||
}
|
||||
}
|
||||
|
||||
// ---- auth ---------------------------------------------------------------
|
||||
|
||||
/** @return array{uid:int,username:string,name:string,email:string}|null */
|
||||
private function allowedUser(ServerRequestInterface $request): ?array
|
||||
{
|
||||
$frontendUser = $request->getAttribute('frontend.user');
|
||||
if (!$frontendUser instanceof FrontendUserAuthentication || empty($frontendUser->user['uid'])) {
|
||||
return null;
|
||||
}
|
||||
$requiredGroup = $this->settings->feUserGroup();
|
||||
if ($requiredGroup > 0) {
|
||||
$groups = GeneralUtility::intExplode(',', (string)($frontendUser->user['usergroup'] ?? ''), true);
|
||||
if (!in_array($requiredGroup, $groups, true)) {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
return [
|
||||
'uid' => (int)$frontendUser->user['uid'],
|
||||
'username' => (string)($frontendUser->user['username'] ?? ''),
|
||||
'name' => trim((string)($frontendUser->user['name'] ?? '')) ?: (string)($frontendUser->user['username'] ?? ''),
|
||||
'email' => (string)($frontendUser->user['email'] ?? ''),
|
||||
];
|
||||
}
|
||||
|
||||
// ---- routes -------------------------------------------------------------
|
||||
|
||||
/** @param array{uid:int,username:string,name:string,email:string} $user */
|
||||
private function state(array $user): ResponseInterface
|
||||
{
|
||||
$summary = $this->openSummary($user['uid'], false);
|
||||
return new JsonResponse([
|
||||
'allowed' => true,
|
||||
'user' => ['name' => $user['name'], 'email' => $user['email']],
|
||||
'recipients' => $this->recipientOptions(),
|
||||
'summary' => $summary === null ? null : $this->summaryPayload($summary),
|
||||
]);
|
||||
}
|
||||
|
||||
/** @param array{uid:int,username:string,name:string,email:string} $user */
|
||||
private function createFeedback(ServerRequestInterface $request, array $user): ResponseInterface
|
||||
{
|
||||
$body = $this->jsonBody($request);
|
||||
$summary = $this->openSummary($user['uid'], true);
|
||||
$connection = GeneralUtility::makeInstance(ConnectionPool::class)->getConnectionForTable(self::T_FEEDBACK);
|
||||
$connection->insert(self::T_FEEDBACK, [
|
||||
'pid' => $this->settings->storagePid(),
|
||||
'tstamp' => time(),
|
||||
'crdate' => time(),
|
||||
'summary' => (int)$summary['uid'],
|
||||
'fe_user' => $user['uid'],
|
||||
'url' => mb_substr(trim((string)($body['url'] ?? '')), 0, 2048),
|
||||
'note' => $this->sanitize((string)($body['note'] ?? '')),
|
||||
'sorting' => time(),
|
||||
]);
|
||||
$uid = (int)$connection->lastInsertId();
|
||||
return new JsonResponse(['ok' => true, 'uid' => $uid, 'summary' => $this->summaryPayload($this->openSummary($user['uid'], true))]);
|
||||
}
|
||||
|
||||
/** @param array{uid:int,username:string,name:string,email:string} $user */
|
||||
private function updateFeedback(ServerRequestInterface $request, array $user, int $uid): ResponseInterface
|
||||
{
|
||||
$this->ownFeedback($user['uid'], $uid);
|
||||
$body = $this->jsonBody($request);
|
||||
$update = ['tstamp' => time()];
|
||||
if (array_key_exists('note', $body)) {
|
||||
$update['note'] = $this->sanitize((string)$body['note']);
|
||||
}
|
||||
if (array_key_exists('url', $body)) {
|
||||
$update['url'] = mb_substr(trim((string)$body['url']), 0, 2048);
|
||||
}
|
||||
GeneralUtility::makeInstance(ConnectionPool::class)->getConnectionForTable(self::T_FEEDBACK)
|
||||
->update(self::T_FEEDBACK, $update, ['uid' => $uid]);
|
||||
return new JsonResponse(['ok' => true]);
|
||||
}
|
||||
|
||||
/** @param array{uid:int,username:string,name:string,email:string} $user */
|
||||
private function deleteFeedback(array $user, int $uid): ResponseInterface
|
||||
{
|
||||
$this->ownFeedback($user['uid'], $uid);
|
||||
$connection = GeneralUtility::makeInstance(ConnectionPool::class)->getConnectionForTable(self::T_FEEDBACK);
|
||||
$connection->update(self::T_FEEDBACK, ['deleted' => 1, 'tstamp' => time()], ['uid' => $uid]);
|
||||
return new JsonResponse(['ok' => true]);
|
||||
}
|
||||
|
||||
/** @param array{uid:int,username:string,name:string,email:string} $user */
|
||||
private function upload(ServerRequestInterface $request, array $user): ResponseInterface
|
||||
{
|
||||
$files = $request->getUploadedFiles();
|
||||
$file = $files['file'] ?? null;
|
||||
$feedbackUid = (int)($request->getParsedBody()['feedback'] ?? 0);
|
||||
$feedback = $this->ownFeedback($user['uid'], $feedbackUid);
|
||||
if ($file === null || $file->getError() !== UPLOAD_ERR_OK) {
|
||||
return new JsonResponse(['error' => 'no file'], 400);
|
||||
}
|
||||
if ($file->getSize() > self::MAX_UPLOAD) {
|
||||
return new JsonResponse(['error' => 'file too large (max 20 MB)'], 400);
|
||||
}
|
||||
|
||||
$storage = GeneralUtility::makeInstance(StorageRepository::class)->getDefaultStorage();
|
||||
$folderPath = 'fe_comment/summary-' . (int)$feedback['summary'];
|
||||
$folder = $storage->hasFolder($folderPath) ? $storage->getFolder($folderPath) : $storage->createFolder($folderPath);
|
||||
$temp = GeneralUtility::tempnam('fecomment_');
|
||||
$file->moveTo($temp);
|
||||
$clientName = $file->getClientFilename() ?: 'upload.bin';
|
||||
$falFile = $storage->addFile($temp, $folder, $clientName, DuplicationBehavior::RENAME);
|
||||
|
||||
$connection = GeneralUtility::makeInstance(ConnectionPool::class)->getConnectionForTable('sys_file_reference');
|
||||
$connection->insert('sys_file_reference', [
|
||||
'pid' => $this->settings->storagePid(),
|
||||
'tstamp' => time(),
|
||||
'crdate' => time(),
|
||||
'uid_local' => $falFile->getUid(),
|
||||
'uid_foreign' => $feedbackUid,
|
||||
'tablenames' => self::T_FEEDBACK,
|
||||
'fieldname' => 'attachments',
|
||||
]);
|
||||
// lastInsertId() must be read BEFORE any further statement on this
|
||||
// connection - syncAttachmentCount() runs an UPDATE and DBAL then
|
||||
// throws "No identity value was generated".
|
||||
$refUid = (int)$connection->lastInsertId();
|
||||
$this->syncAttachmentCount($feedbackUid);
|
||||
|
||||
return new JsonResponse(['ok' => true, 'attachment' => [
|
||||
'refUid' => $refUid,
|
||||
'name' => $falFile->getName(),
|
||||
'url' => '/fileadmin' . $falFile->getIdentifier(),
|
||||
]]);
|
||||
}
|
||||
|
||||
/** @param array{uid:int,username:string,name:string,email:string} $user */
|
||||
private function deleteAttachment(array $user, int $refUid): ResponseInterface
|
||||
{
|
||||
$connection = GeneralUtility::makeInstance(ConnectionPool::class)->getConnectionForTable('sys_file_reference');
|
||||
$reference = $connection->fetchAssociative(
|
||||
'SELECT uid, uid_foreign FROM sys_file_reference WHERE uid = ? AND deleted = 0 AND tablenames = ?',
|
||||
[$refUid, self::T_FEEDBACK]
|
||||
);
|
||||
if (!$reference) {
|
||||
return new JsonResponse(['error' => 'not found'], 404);
|
||||
}
|
||||
$this->ownFeedback($user['uid'], (int)$reference['uid_foreign']);
|
||||
$connection->update('sys_file_reference', ['deleted' => 1, 'tstamp' => time()], ['uid' => $refUid]);
|
||||
$this->syncAttachmentCount((int)$reference['uid_foreign']);
|
||||
return new JsonResponse(['ok' => true]);
|
||||
}
|
||||
|
||||
/** @param array{uid:int,username:string,name:string,email:string} $user */
|
||||
private function updateSummary(ServerRequestInterface $request, array $user): ResponseInterface
|
||||
{
|
||||
$body = $this->jsonBody($request);
|
||||
$summary = $this->openSummary($user['uid'], true);
|
||||
$update = ['tstamp' => time()];
|
||||
if (array_key_exists('generalNotes', $body)) {
|
||||
$update['general_notes'] = $this->sanitize((string)$body['generalNotes']);
|
||||
}
|
||||
if (array_key_exists('recipients', $body) && is_array($body['recipients'])) {
|
||||
$valid = array_keys($this->recipientMap());
|
||||
$chosen = array_values(array_intersect(array_map('intval', $body['recipients']), $valid));
|
||||
$update['recipients'] = implode(',', $chosen);
|
||||
}
|
||||
GeneralUtility::makeInstance(ConnectionPool::class)->getConnectionForTable(self::T_SUMMARY)
|
||||
->update(self::T_SUMMARY, $update, ['uid' => (int)$summary['uid']]);
|
||||
return new JsonResponse(['ok' => true]);
|
||||
}
|
||||
|
||||
/** @param array{uid:int,username:string,name:string,email:string} $user */
|
||||
private function submit(array $user): ResponseInterface
|
||||
{
|
||||
$summary = $this->openSummary($user['uid'], false);
|
||||
if ($summary === null) {
|
||||
return new JsonResponse(['error' => 'nothing to submit'], 400);
|
||||
}
|
||||
$payload = $this->summaryPayload($summary);
|
||||
if ($payload['items'] === [] && trim(strip_tags((string)$payload['generalNotes'])) === '') {
|
||||
return new JsonResponse(['error' => 'nothing to submit'], 400);
|
||||
}
|
||||
|
||||
$recipientMap = $this->recipientMap();
|
||||
$chosen = GeneralUtility::intExplode(',', (string)$summary['recipients'], true);
|
||||
$to = [];
|
||||
foreach ($chosen as $id) {
|
||||
if (isset($recipientMap[$id])) {
|
||||
$to[] = $recipientMap[$id]['email'];
|
||||
}
|
||||
}
|
||||
if ($to === []) {
|
||||
$to = $this->settings->mailTo();
|
||||
}
|
||||
if ($to === []) {
|
||||
return new JsonResponse(['error' => 'no recipient configured'], 503);
|
||||
}
|
||||
|
||||
$html = '<h2>Page feedback from ' . htmlspecialchars($user['name']) . '</h2>'
|
||||
. '<p><strong>Author:</strong> ' . htmlspecialchars($user['name'])
|
||||
. ' <' . htmlspecialchars($user['email']) . '></p>';
|
||||
if (trim(strip_tags((string)$payload['generalNotes'])) !== '') {
|
||||
$html .= '<h3>General notes</h3>' . $payload['generalNotes'];
|
||||
}
|
||||
foreach ($payload['items'] as $i => $item) {
|
||||
$html .= '<hr><h3>' . ($i + 1) . ') ' . htmlspecialchars($item['url'] ?: '(no url)') . '</h3>' . $item['note'];
|
||||
if ($item['attachments'] !== []) {
|
||||
$html .= '<p><strong>Attachments:</strong></p><ul>';
|
||||
foreach ($item['attachments'] as $attachment) {
|
||||
$base = 'https://' . ($_SERVER['HTTP_HOST'] ?? 'dev.vitec.com');
|
||||
$html .= '<li><a href="' . htmlspecialchars($base . $attachment['url']) . '">' . htmlspecialchars($attachment['name']) . '</a></li>';
|
||||
}
|
||||
$html .= '</ul>';
|
||||
}
|
||||
}
|
||||
|
||||
$mail = GeneralUtility::makeInstance(MailMessage::class);
|
||||
$mail->to(...$to)
|
||||
->subject($this->settings->subject() . ' — ' . $user['name'] . ' (' . count($payload['items']) . ' item' . (count($payload['items']) === 1 ? '' : 's') . ')')
|
||||
->html($html);
|
||||
if ($this->settings->mailCc() !== []) {
|
||||
$mail->cc(...$this->settings->mailCc());
|
||||
}
|
||||
if ($this->settings->mailBcc() !== []) {
|
||||
$mail->bcc(...$this->settings->mailBcc());
|
||||
}
|
||||
if (GeneralUtility::validEmail($user['email'])) {
|
||||
$mail->replyTo($user['email']);
|
||||
}
|
||||
GeneralUtility::makeInstance(\TYPO3\CMS\Core\Mail\Mailer::class)->send($mail);
|
||||
|
||||
GeneralUtility::makeInstance(ConnectionPool::class)->getConnectionForTable(self::T_SUMMARY)
|
||||
->update(self::T_SUMMARY, ['status' => 'sent', 'sent_at' => time(), 'tstamp' => time()], ['uid' => (int)$summary['uid']]);
|
||||
return new JsonResponse(['ok' => true, 'sent' => count($payload['items'])]);
|
||||
}
|
||||
|
||||
// ---- helpers ------------------------------------------------------------
|
||||
|
||||
/** @return array<string,mixed>|null */
|
||||
private function openSummary(int $userUid, bool $createIfMissing): ?array
|
||||
{
|
||||
$connection = GeneralUtility::makeInstance(ConnectionPool::class)->getConnectionForTable(self::T_SUMMARY);
|
||||
$summary = $connection->fetchAssociative(
|
||||
'SELECT * FROM ' . self::T_SUMMARY . " WHERE deleted = 0 AND status = 'open' AND fe_user = ? ORDER BY uid DESC",
|
||||
[$userUid]
|
||||
);
|
||||
if ($summary) {
|
||||
return $summary;
|
||||
}
|
||||
if (!$createIfMissing) {
|
||||
return null;
|
||||
}
|
||||
$connection->insert(self::T_SUMMARY, [
|
||||
'pid' => $this->settings->storagePid(),
|
||||
'tstamp' => time(),
|
||||
'crdate' => time(),
|
||||
'fe_user' => $userUid,
|
||||
'status' => 'open',
|
||||
]);
|
||||
return $this->openSummary($userUid, false);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param array<string,mixed> $summary
|
||||
* @return array{uid:int,generalNotes:string,recipients:int[],items:array<int,array{uid:int,url:string,note:string,attachments:array<int,array{refUid:int,name:string,url:string}>}>}
|
||||
*/
|
||||
private function summaryPayload(array $summary): array
|
||||
{
|
||||
$connection = GeneralUtility::makeInstance(ConnectionPool::class)->getConnectionForTable(self::T_FEEDBACK);
|
||||
$items = [];
|
||||
foreach ($connection->fetchAllAssociative(
|
||||
'SELECT uid, url, note FROM ' . self::T_FEEDBACK . ' WHERE deleted = 0 AND summary = ? ORDER BY sorting',
|
||||
[(int)$summary['uid']]
|
||||
) as $row) {
|
||||
$items[] = [
|
||||
'uid' => (int)$row['uid'],
|
||||
'url' => (string)$row['url'],
|
||||
'note' => (string)$row['note'],
|
||||
'attachments' => $this->attachments((int)$row['uid']),
|
||||
];
|
||||
}
|
||||
return [
|
||||
'uid' => (int)$summary['uid'],
|
||||
'generalNotes' => (string)($summary['general_notes'] ?? ''),
|
||||
'recipients' => GeneralUtility::intExplode(',', (string)($summary['recipients'] ?? ''), true),
|
||||
'items' => $items,
|
||||
];
|
||||
}
|
||||
|
||||
/** @return array<int,array{refUid:int,name:string,url:string}> */
|
||||
private function attachments(int $feedbackUid): array
|
||||
{
|
||||
$connection = GeneralUtility::makeInstance(ConnectionPool::class)->getConnectionForTable('sys_file_reference');
|
||||
$rows = $connection->fetchAllAssociative(
|
||||
'SELECT r.uid AS ref_uid, f.name, f.identifier FROM sys_file_reference r
|
||||
JOIN sys_file f ON f.uid = r.uid_local
|
||||
WHERE r.deleted = 0 AND r.tablenames = ? AND r.fieldname = ? AND r.uid_foreign = ? ORDER BY r.uid',
|
||||
[self::T_FEEDBACK, 'attachments', $feedbackUid]
|
||||
);
|
||||
return array_map(static fn(array $r): array => [
|
||||
'refUid' => (int)$r['ref_uid'],
|
||||
'name' => (string)$r['name'],
|
||||
'url' => '/fileadmin' . $r['identifier'],
|
||||
], $rows);
|
||||
}
|
||||
|
||||
/** @return array<string,mixed> the feedback row - throws when not the user's */
|
||||
private function ownFeedback(int $userUid, int $feedbackUid): array
|
||||
{
|
||||
$connection = GeneralUtility::makeInstance(ConnectionPool::class)->getConnectionForTable(self::T_FEEDBACK);
|
||||
$row = $connection->fetchAssociative(
|
||||
'SELECT * FROM ' . self::T_FEEDBACK . ' WHERE deleted = 0 AND uid = ? AND fe_user = ?',
|
||||
[$feedbackUid, $userUid]
|
||||
);
|
||||
if (!$row) {
|
||||
throw new \RuntimeException('feedback not found or not yours', 1764600000);
|
||||
}
|
||||
return $row;
|
||||
}
|
||||
|
||||
private function syncAttachmentCount(int $feedbackUid): void
|
||||
{
|
||||
$connection = GeneralUtility::makeInstance(ConnectionPool::class)->getConnectionForTable('sys_file_reference');
|
||||
$count = (int)$connection->fetchOne(
|
||||
'SELECT COUNT(*) FROM sys_file_reference WHERE deleted = 0 AND tablenames = ? AND fieldname = ? AND uid_foreign = ?',
|
||||
[self::T_FEEDBACK, 'attachments', $feedbackUid]
|
||||
);
|
||||
GeneralUtility::makeInstance(ConnectionPool::class)->getConnectionForTable(self::T_FEEDBACK)
|
||||
->update(self::T_FEEDBACK, ['attachments' => $count, 'tstamp' => time()], ['uid' => $feedbackUid]);
|
||||
}
|
||||
|
||||
/** @return array<int,array{label:string,email:string}> id => recipient */
|
||||
private function recipientMap(): array
|
||||
{
|
||||
return $this->settings->recipients();
|
||||
}
|
||||
|
||||
/** @return array<int,array{id:int,label:string}> */
|
||||
private function recipientOptions(): array
|
||||
{
|
||||
$options = [];
|
||||
foreach ($this->recipientMap() as $id => $recipient) {
|
||||
$options[] = ['id' => $id, 'label' => $recipient['label']];
|
||||
}
|
||||
return $options;
|
||||
}
|
||||
|
||||
/** @return array<string,mixed> */
|
||||
private function jsonBody(ServerRequestInterface $request): array
|
||||
{
|
||||
$parsed = $request->getParsedBody();
|
||||
if (is_array($parsed) && $parsed !== []) {
|
||||
return $parsed;
|
||||
}
|
||||
$decoded = json_decode((string)$request->getBody(), true);
|
||||
return is_array($decoded) ? $decoded : [];
|
||||
}
|
||||
|
||||
/** TYPO3 HTML sanitizer; falls back to a hard strip when unavailable. */
|
||||
private function sanitize(string $html): string
|
||||
{
|
||||
$html = mb_substr($html, 0, self::MAX_NOTE);
|
||||
try {
|
||||
$builder = GeneralUtility::makeInstance(\TYPO3\CMS\Core\Html\SanitizerBuilderFactory::class)->build('default');
|
||||
return $builder->sanitize($html);
|
||||
} catch (\Throwable) {
|
||||
return strip_tags($html, '<p><br><b><strong><i><em><u><ul><ol><li><a><img><h3><h4>');
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user