Gruppen-Plugin 1.0.0

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
This commit is contained in:
Friederich Loheide 2026-09-27 17:17:10 +00:00
commit 5bdfb8a082
49 changed files with 4679 additions and 0 deletions

93
src/Files.php Normal file
View file

@ -0,0 +1,93 @@
<?php
namespace Inhaus\Plugins\Gruppen;
use App\Support\BlockedFiles;
use App\Support\Images;
use Illuminate\Http\UploadedFile;
use Illuminate\Support\Facades\Storage;
use Illuminate\Support\Str;
use Illuminate\Validation\ValidationException;
use Inhaus\Plugins\Gruppen\Models\Attachment;
use Inhaus\Plugins\Gruppen\Models\Post;
use Intervention\Image\Drivers\Gd\Driver;
use Intervention\Image\Encoders\WebpEncoder;
use Intervention\Image\ImageManager;
use Throwable;
/**
* Anhänge und Titelbilder – außerhalb des öffentlichen Ordners, ausgeliefert nur an Berechtigte.
* Fotos werden verkleinert (max. 1600 px) und bekommen eine Vorschau.
*/
class Files
{
public const DISK = 'local';
public const IMAGE_TYPES = ['image/jpeg', 'image/png', 'image/webp', 'image/gif'];
public function attach(Post $post, UploadedFile $file, int $sort): Attachment
{
$name = Str::limit(preg_replace('/[^\pL\pN ._()-]+/u', '_', $file->getClientOriginalName()) ?: 'Datei', 150, '');
$mime = $file->getMimeType() ?: 'application/octet-stream';
$base = "gruppen/{$post->group_id}/{$post->id}/".Str::random(24);
// Fotos (außer GIF – Animation erhalten) verkleinern
if (in_array($mime, ['image/jpeg', 'image/png', 'image/webp'], true)) {
try {
return Images::withLocalCopy($file, function (string $local) use ($post, $base, $name, $sort) {
Images::raiseMemoryLimitFor($local);
$image = ImageManager::usingDriver(Driver::class)->decodePath($local)->scaleDown(1600, 1600);
$disk = Storage::disk(self::DISK);
$disk->put("{$base}.webp", $full = $image->encode(new WebpEncoder(quality: 82))->toString());
[$w, $h] = [$image->width(), $image->height()];
$disk->put("{$base}-thumb.webp", $image->scaleDown(720, 720)->encode(new WebpEncoder(quality: 78))->toString());
return $post->attachments()->create(['path' => "{$base}.webp", 'thumb_path' => "{$base}-thumb.webp", 'name' => $name, 'mime' => 'image/webp', 'size' => strlen($full), 'width' => $w, 'height' => $h, 'sort' => $sort]);
});
} catch (ValidationException $e) {
throw $e;
} catch (Throwable $e) {
report($e);
throw ValidationException::withMessages(['files' => "„{$name}“ ließ sich nicht als Bild lesen."]);
}
}
$extension = strtolower($file->guessExtension() ?: $file->getClientOriginalExtension());
if (in_array($extension, BlockedFiles::EXTENSIONS, true) || in_array(strtolower($file->getClientOriginalExtension()), BlockedFiles::EXTENSIONS, true)) {
throw ValidationException::withMessages(['files' => "Dateien dieses Typs („{$name}“) sind nicht erlaubt."]);
}
$path = $file->storeAs(dirname($base), basename($base).($extension ? '.'.$extension : ''), self::DISK);
$size = $mime === 'image/gif' ? @getimagesize($file->getRealPath()) : false;
return $post->attachments()->create([
'path' => $path, 'thumb_path' => $mime === 'image/gif' ? $path : null, 'name' => $name, 'mime' => $mime,
'size' => $file->getSize(), 'width' => $size[0] ?? null, 'height' => $size[1] ?? null, 'sort' => $sort,
]);
}
public function storeCover(int $groupId, UploadedFile $file): string
{
$path = "gruppen/{$groupId}/cover-".Str::random(16).'.webp';
Images::withLocalCopy($file, function (string $local) use ($path) {
Images::raiseMemoryLimitFor($local);
$image = ImageManager::usingDriver(Driver::class)->decodePath($local)->coverDown(1600, 500);
Storage::disk(self::DISK)->put($path, $image->encode(new WebpEncoder(quality: 82))->toString());
});
return $path;
}
public function deletePost(Post $post): void
{
Storage::disk(self::DISK)->deleteDirectory("gruppen/{$post->group_id}/{$post->id}");
}
public function deleteGroup(int $groupId): void
{
Storage::disk(self::DISK)->deleteDirectory("gruppen/{$groupId}");
}
}

382
src/Groups.php Normal file
View file

@ -0,0 +1,382 @@
<?php
namespace Inhaus\Plugins\Gruppen;
use App\Models\User;
use App\Notifications\PortalNotification;
use App\Plugins\PluginAccess;
use Illuminate\Http\UploadedFile;
use Illuminate\Support\Collection;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Notification;
use Illuminate\Support\Str;
use Illuminate\Validation\ValidationException;
use Inhaus\Plugins\Gruppen\Models\Comment;
use Inhaus\Plugins\Gruppen\Models\Group;
use Inhaus\Plugins\Gruppen\Models\Member;
use Inhaus\Plugins\Gruppen\Models\Post;
/**
* Diskussionsgruppen: Zugriff je Art (offen, geschlossen, privat), Mitgliedschaft,
* Beiträge, Kommentare, Reaktionen und Umfragen.
*/
class Groups
{
public const MAX_PINNED = 3;
public const MAX_FILES = 10;
public function __construct(private readonly Files $files) {}
/**
* Was darf die Person in dieser Gruppe?
*
* @return array{member: ?Member, see: bool, read: bool, post: bool, moderate: bool, admin: bool}
*/
public function access(Group $group, User $user): array
{
$member = $group->membership($user);
$active = $member?->isActive() ?? false;
$manager = $user->can('gruppen.manage');
return [
'member' => $member,
'see' => $group->privacy !== 'secret' || $manager || in_array($member?->status, ['active', 'invited'], true),
'read' => $group->privacy === 'open' || $active || $manager,
'post' => $active,
'moderate' => ($member?->canModerate() ?? false) || $manager,
'admin' => ($member?->isAdmin() ?? false) || $manager,
];
}
public function create(User $creator, array $data, ?UploadedFile $cover = null): Group
{
$group = DB::transaction(function () use ($creator, $data) {
$group = Group::query()->create([
'name' => $data['name'],
'slug' => $this->slug($data['name']),
'description' => $data['description'] ?? null,
'privacy' => $data['privacy'],
'created_by' => $creator->id,
'last_activity_at' => now(),
]);
$group->memberships()->create(['user_id' => $creator->id, 'role' => 'admin', 'status' => 'active', 'joined_at' => now()]);
return $group;
});
if ($cover) {
$group->update(['cover_path' => $this->files->storeCover($group->id, $cover)]);
}
$group->refreshCounts();
return $group;
}
/** Beitreten: offen sofort, geschlossen als Anfrage, privat nur mit Einladung */
public function join(Group $group, User $user): string
{
$member = $group->membership($user);
if ($member?->isActive()) {
return 'active';
}
if ($member?->status === 'invited' || $group->privacy === 'open') {
$this->upsert($group, $user, ['status' => 'active', 'joined_at' => now()]);
$group->refreshCounts();
return 'active';
}
abort_if($group->privacy === 'secret', 404);
$this->upsert($group, $user, ['status' => 'pending']);
Notification::send($this->moderators($group), new PortalNotification(
"Beitrittsanfrage für „{$group->name}“",
"{$user->name} möchte beitreten.",
route('gruppen.show', [$group, 'tab' => 'mitglieder'], false),
'users',
));
return 'pending';
}
public function leave(Group $group, User $user): void
{
$member = $group->membership($user);
if (! $member) {
return;
}
$member->delete();
// Letzte Admin-Person weg: die am längsten dabei ist, übernimmt
if (! $group->memberships()->where('status', 'active')->where('role', 'admin')->exists()) {
$group->memberships()->where('status', 'active')->orderBy('joined_at')->first()?->forceFill(['role' => 'admin'])->save();
}
$group->refreshCounts();
}
/**
* Einladen: in offenen Gruppen alle Mitglieder, sonst Admins und Moderation.
*
* @param list<int> $userIds
*/
public function invite(Group $group, User $actor, array $userIds): int
{
$access = $this->access($group, $actor);
abort_unless($access['post'] && ($group->privacy === 'open' || $access['moderate']), 403);
$count = 0;
foreach (User::query()->whereKey(array_slice(array_map('intval', $userIds), 0, 100))->whereKeyNot($actor->id)->get() as $user) {
if (! $user->is_active || ! app(PluginAccess::class)->allows('gruppen', $user)) {
continue;
}
$existing = $group->membership($user);
if ($existing?->isActive() || $existing?->status === 'invited') {
continue;
}
// Wer schon angefragt hat, ist mit der Einladung drin
$this->upsert($group, $user, $existing?->status === 'pending'
? ['status' => 'active', 'joined_at' => now()]
: ['status' => 'invited', 'invited_by' => $actor->id]);
$count++;
$user->notify(new PortalNotification("Einladung in die Gruppe „{$group->name}“", "{$actor->name} lädt Sie ein.", route('gruppen.show', $group, false), 'users'));
}
$group->refreshCounts();
return $count;
}
public function decide(Group $group, User $actor, User $user, bool $accept): void
{
abort_unless($this->access($group, $actor)['moderate'], 403);
$member = $group->membership($user);
abort_unless($member?->status === 'pending', 404);
if ($accept) {
$member->forceFill(['status' => 'active', 'joined_at' => now()])->save();
$user->notify(new PortalNotification("Willkommen in „{$group->name}“", 'Ihre Beitrittsanfrage wurde angenommen.', route('gruppen.show', $group, false), 'users'));
} else {
$member->delete();
}
$group->refreshCounts();
}
public function setRole(Group $group, User $actor, User $user, string $role): void
{
abort_unless($this->access($group, $actor)['admin'] && isset(Member::ROLES[$role]), 403);
$member = $group->membership($user);
abort_unless($member?->isActive(), 404);
if ($role !== 'admin' && $member->role === 'admin' && $group->memberships()->where('role', 'admin')->where('status', 'active')->count() === 1) {
throw ValidationException::withMessages(['role' => 'Eine Gruppe braucht mindestens eine Admin-Person.']);
}
$member->forceFill(['role' => $role])->save();
}
public function removeMember(Group $group, User $actor, User $user): void
{
$access = $this->access($group, $actor);
$member = $group->membership($user);
abort_unless($member && $access['moderate'] && ($access['admin'] || $member->role === 'member'), 403);
$this->leave($group, $user);
}
/**
* @param list<UploadedFile> $files
* @param list<string>|null $pollOptions
*/
public function post(Group $group, User $user, ?string $body, array $files = [], ?array $pollOptions = null, bool $multiple = false): Post
{
abort_unless($this->access($group, $user)['post'], 403);
$body = filled($body) ? trim($body) : null;
$options = $pollOptions ? array_values(array_filter(array_map(fn ($o) => Str::limit(trim((string) $o), 120, ''), $pollOptions))) : [];
if ($pollOptions !== null && count($options) < 2) {
throw ValidationException::withMessages(['poll' => 'Eine Umfrage braucht mindestens zwei Antworten.']);
}
if ($body === null && $files === [] && $options === []) {
throw ValidationException::withMessages(['body' => 'Der Beitrag ist leer.']);
}
$post = $group->posts()->create(['user_id' => $user->id, 'body' => $body, 'poll' => $options ? ['options' => array_slice($options, 0, 10), 'multiple' => $multiple] : null]);
foreach (array_values($files) as $i => $file) {
$this->files->attach($post, $file, $i);
}
$group->forceFill(['last_activity_at' => now()])->save();
$group->refreshCounts();
$this->notifyNewPost($group, $post, $user);
return $post;
}
public function deletePost(Post $post, User $user): void
{
abort_unless($post->user_id === $user->id || $this->access($post->group, $user)['moderate'], 403);
$this->files->deletePost($post);
$post->delete();
$post->group->refreshCounts();
}
public function pin(Post $post, User $user, bool $pinned): void
{
abort_unless($this->access($post->group, $user)['moderate'], 403);
if ($pinned && $post->group->posts()->whereNotNull('pinned_at')->count() >= self::MAX_PINNED) {
throw ValidationException::withMessages(['pin' => 'Höchstens '.self::MAX_PINNED.' Beiträge lassen sich anpinnen.']);
}
$post->forceFill(['pinned_at' => $pinned ? now() : null])->save();
}
public function react(Post $post, User $user, ?string $emoji): void
{
abort_unless($this->access($post->group, $user)['post'], 403);
DB::table('gruppen_reactions')->where(['post_id' => $post->id, 'user_id' => $user->id])->delete();
if ($emoji !== null) {
abort_unless(in_array($emoji, Post::REACTIONS, true), 422);
DB::table('gruppen_reactions')->insert(['post_id' => $post->id, 'user_id' => $user->id, 'emoji' => $emoji]);
}
}
/**
* @param list<int> $options
*/
public function vote(Post $post, User $user, array $options): void
{
abort_unless($post->poll && $this->access($post->group, $user)['post'], 403);
$count = count($post->poll['options']);
$options = array_values(array_unique(array_filter(array_map('intval', $options), fn ($o) => $o >= 0 && $o < $count)));
$options = $post->poll['multiple'] ? $options : array_slice($options, 0, 1);
DB::transaction(function () use ($post, $user, $options) {
DB::table('gruppen_poll_votes')->where(['post_id' => $post->id, 'user_id' => $user->id])->delete();
DB::table('gruppen_poll_votes')->insert(array_map(fn ($o) => ['post_id' => $post->id, 'user_id' => $user->id, 'option' => $o], $options));
});
}
public function comment(Post $post, User $user, string $body, ?int $parentId): Comment
{
abort_unless($this->access($post->group, $user)['post'], 403);
$parent = $parentId ? $post->comments()->find($parentId) : null;
// Antworten hängen immer am obersten Kommentar
$parent = $parent?->parent_id ? $post->comments()->find($parent->parent_id) : $parent;
$comment = $post->comments()->create(['user_id' => $user->id, 'parent_id' => $parent?->id, 'body' => trim($body)]);
$post->forceFill(['comments_count' => $post->comments()->count()])->saveQuietly();
$post->group->forceFill(['last_activity_at' => now()])->save();
$url = route('gruppen.post', [$post->group, $post], false).'#kommentar-'.$comment->id;
$recipients = collect([$post->user, $parent?->user])->filter()->unique('id')->reject(fn (User $u) => $u->is($user) || ! $u->is_active);
foreach ($recipients as $recipient) {
$recipient->notify(new PortalNotification(
$recipient->is($parent?->user) ? "{$user->name} hat Ihnen geantwortet" : "{$user->name} hat Ihren Beitrag kommentiert",
Str::limit($comment->body, 100),
$url,
'message-circle',
));
}
return $comment;
}
public function deleteComment(Comment $comment, User $user): void
{
abort_unless($comment->user_id === $user->id || $this->access($comment->post->group, $user)['moderate'], 403);
$post = $comment->post;
$comment->delete();
$post->forceFill(['comments_count' => $post->comments()->count()])->saveQuietly();
}
public function report(Post $post, ?Comment $comment, User $user, string $reason): void
{
abort_unless($this->access($post->group, $user)['read'], 404);
$created = DB::table('gruppen_reports')->insertOrIgnore([
'group_id' => $post->group_id, 'post_id' => $post->id, 'comment_id' => $comment?->id, 'user_id' => $user->id,
'reason' => $reason, 'created_at' => now(), 'updated_at' => now(),
]);
if ($created) {
Notification::send($this->moderators($post->group)->reject(fn (User $u) => $u->is($user)), new PortalNotification(
($comment ? 'Kommentar' : 'Beitrag')." in „{$post->group->name}“ gemeldet",
Str::limit($reason, 100),
route('gruppen.post', [$post->group, $post], false),
'flag',
));
}
}
/** Beim Besuch: gesehen – ab jetzt wieder benachrichtigen */
public function seen(Group $group, User $user): void
{
$group->memberships()->where('user_id', $user->id)->update(['last_seen_at' => now()]);
}
/**
* @return Collection<int, User>
*/
public function moderators(Group $group): Collection
{
return User::query()->active()->whereIn('id', $group->memberships()->where('status', 'active')->whereIn('role', ['admin', 'moderator'])->pluck('user_id'))->get();
}
/**
* Neue Beiträge: Mitglieder mit „alle Beiträge“ – je Gruppe einmal, bis sie wieder vorbeischauen.
*/
private function notifyNewPost(Group $group, Post $post, User $author): void
{
$members = $group->memberships()->with('user')->where('status', 'active')->where('notify', 'all')->where('user_id', '!=', $author->id)
->where(fn ($q) => $q->whereNull('notified_at')->orWhereColumn('last_seen_at', '>', 'notified_at'))->get();
foreach ($members as $member) {
if (! $member->user?->is_active) {
continue;
}
$member->forceFill(['notified_at' => now()])->save();
$member->user->notify(new PortalNotification(
"Neu in „{$group->name}“",
$author->name.': '.Str::limit($post->body ?: ($post->poll ? 'Umfrage' : 'Fotos/Dateien'), 90),
route('gruppen.post', [$group, $post], false),
'users',
));
}
}
private function upsert(Group $group, User $user, array $values): void
{
$existing = $group->membership($user);
$existing ? $existing->forceFill($values)->save() : $group->memberships()->create(['user_id' => $user->id, 'role' => 'member', ...$values]);
}
private function slug(string $name): string
{
$base = Str::slug($name, language: 'de') ?: 'gruppe';
$slug = $base;
for ($i = 2; Group::query()->where('slug', $slug)->exists(); $i++) {
$slug = "{$base}-{$i}";
}
return $slug;
}
}

73
src/GruppenPlugin.php Normal file
View file

@ -0,0 +1,73 @@
<?php
namespace Inhaus\Plugins\Gruppen;
use App\Dashboard\Widgets;
use App\Digest\Digest;
use App\Models\User;
use App\Plugins\Plugin;
use App\Search\GlobalSearch;
use App\Support\Abilities;
use App\Support\Navigation;
use Carbon\CarbonImmutable;
use Illuminate\Support\Facades\Storage;
use Illuminate\Support\Str;
use Inhaus\Plugins\Gruppen\Models\Group;
use Inhaus\Plugins\Gruppen\Models\Member;
use Inhaus\Plugins\Gruppen\Models\Post;
/**
* Diskussionsgruppen – offen, geschlossen oder privat, mit Beiträgen, Kommentaren und Umfragen.
*/
class GruppenPlugin extends Plugin
{
public function register(): void
{
$this->app->singleton(Groups::class);
$this->app->make(Navigation::class)->add('gruppen', 'Gruppen', '/gruppen', active: 'gruppen.*', sort: 25);
$this->app->make(Abilities::class)->define('gruppen.manage', 'Alle Gruppen verwalten (auch private) und bei Meldungen eingreifen', 'Gruppen', portal: true);
$this->app->make(GlobalSearch::class)->add('gruppen', 'Gruppen', 'users', function (User $user, string $search, int $limit) {
$query = Group::query()->discoverableBy($user);
GlobalSearch::whereTerms($query, ['name', 'description'], $search);
return $query->orderByDesc('members_count')->limit($limit)->get()->map(fn (Group $g) => [
'title' => $g->name,
'url' => '/gruppen/'.$g->slug,
'excerpt' => GlobalSearch::excerpt((string) $g->description, $search),
'meta' => Group::PRIVACY[$g->privacy].' · '.$g->members_count.($g->members_count === 1 ? ' Mitglied' : ' Mitglieder'),
])->all();
}, sort: 45);
// Startseite: Neues aus den eigenen Gruppen
$this->app->make(Widgets::class)->add('gruppen.feed', 'gruppen::Recent', 'aside', sort: 35, props: function (User $user) {
$ids = Member::query()->where('user_id', $user->id)->where('status', 'active')->pluck('group_id');
$posts = Post::query()->with(['user', 'group'])->whereIn('group_id', $ids)->latest('id')->limit(4)->get();
return $posts->isEmpty() ? null : ['posts' => $posts->map(fn (Post $p) => [
'id' => $p->id,
'group' => $p->group->name,
'user' => Presenter::person($p->user),
'text' => Str::limit((string) ($p->body ?: ($p->poll ? 'Umfrage' : 'Fotos/Dateien')), 90),
'created_at' => $p->created_at?->toIso8601String(),
'url' => route('gruppen.post', [$p->group, $p]),
])->all()];
}, label: 'Gruppen', mobileSort: 42);
if (class_exists(Digest::class)) {
$this->app->make(Digest::class)->add('gruppen', 'Aus Ihren Gruppen', 45, function (User $user, CarbonImmutable $since) {
$ids = Member::query()->where('user_id', $user->id)->where('status', 'active')->pluck('group_id');
return Group::query()->whereIn('id', $ids)->withCount(['posts as new_posts' => fn ($q) => $q->where('created_at', '>=', $since)])->get()
->where('new_posts', '>', 0)->sortByDesc('new_posts')->take(6)
->map(fn (Group $g) => ['title' => $g->name, 'url' => route('gruppen.show', $g), 'meta' => $g->new_posts === 1 ? '1 neuer Beitrag' : "{$g->new_posts} neue Beiträge"])->values()->all();
});
}
}
public function uninstall(): void
{
Storage::disk(Files::DISK)->deleteDirectory('gruppen');
}
}

View file

@ -0,0 +1,232 @@
<?php
namespace Inhaus\Plugins\Gruppen\Http\Controllers;
use App\Http\Controllers\Controller;
use App\Models\User;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Storage;
use Illuminate\Validation\Rule;
use Inertia\Inertia;
use Inertia\Response;
use Inhaus\Plugins\Gruppen\Files;
use Inhaus\Plugins\Gruppen\Groups;
use Inhaus\Plugins\Gruppen\Models\Group;
use Inhaus\Plugins\Gruppen\Models\Member;
use Inhaus\Plugins\Gruppen\Models\Post;
use Inhaus\Plugins\Gruppen\Presenter;
use Symfony\Component\HttpFoundation\StreamedResponse;
class GroupController extends Controller
{
public const PAGE = 15;
public function __construct(private readonly Groups $groups, private readonly Files $files) {}
/** Übersicht: Beiträge aus den eigenen Gruppen, dazu die eigenen Gruppen und Einladungen */
public function index(Request $request): Response|JsonResponse
{
$user = $request->user();
$groupIds = Member::query()->where('user_id', $user->id)->where('status', 'active')->pluck('group_id');
$posts = Post::query()->with(['user', 'attachments', 'group'])->whereIn('group_id', $groupIds)
->when($request->integer('vor'), fn ($q, $before) => $q->where('id', '<', $before))
->latest('id')->limit(self::PAGE)->get();
$payload = ['posts' => Presenter::posts($posts, $user, $this->groups), 'more' => $posts->count() === self::PAGE];
if ($request->wantsJson() && ! $request->header('X-Inertia')) {
return response()->json($payload);
}
$memberships = Member::query()->with('group')->where('user_id', $user->id)->whereIn('status', ['active', 'invited', 'pending'])->get();
return Inertia::render('gruppen::Index', [
...$payload,
'groups' => $memberships->where('status', 'active')->sortByDesc(fn ($m) => $m->group->last_activity_at)->map(fn ($m) => Presenter::group($m->group, 'active'))->values()->all(),
'invitations' => $memberships->where('status', 'invited')->map(fn ($m) => Presenter::group($m->group, 'invited'))->values()->all(),
'suggested' => Group::query()->where('privacy', 'open')->whereNotIn('id', $memberships->pluck('group_id'))->orderByDesc('members_count')->limit(4)->get()->map(fn ($g) => Presenter::group($g))->all(),
'privacy' => Group::PRIVACY,
'privacyHints' => Group::PRIVACY_HINTS,
]);
}
public function discover(Request $request): Response
{
$user = $request->user();
$q = trim((string) $request->query('q', ''));
$statuses = Member::query()->where('user_id', $user->id)->pluck('status', 'group_id');
$groups = Group::query()->discoverableBy($user)
->when($q !== '', fn ($query) => $query->where(fn ($w) => $w->where('name', 'like', '%'.addcslashes($q, '%_\\').'%')->orWhere('description', 'like', '%'.addcslashes($q, '%_\\').'%')))
->orderByDesc('last_activity_at')->paginate(24)->withQueryString();
return Inertia::render('gruppen::Discover', [
'groups' => collect($groups->items())->map(fn (Group $g) => Presenter::group($g, $statuses[$g->id] ?? null))->all(),
'pagination' => ['prev' => $groups->previousPageUrl(), 'next' => $groups->nextPageUrl()],
'q' => $q,
'privacy' => Group::PRIVACY,
'privacyHints' => Group::PRIVACY_HINTS,
]);
}
public function show(Request $request, Group $group): Response|JsonResponse
{
$user = $request->user();
$access = $this->groups->access($group, $user);
abort_unless($access['see'], 404);
$posts = $access['read']
? $group->posts()->with(['user', 'attachments', 'group'])
->when($request->integer('vor'), fn ($q, $before) => $q->where('id', '<', $before)->whereNull('pinned_at'))
->orderByRaw('pinned_at IS NULL')->orderByDesc('pinned_at')->latest('id')->limit(self::PAGE)->get()
: collect();
$payload = ['posts' => Presenter::posts($posts, $user, $this->groups), 'more' => $posts->count() === self::PAGE];
if ($request->wantsJson() && ! $request->header('X-Inertia')) {
return response()->json($payload);
}
$this->groups->seen($group, $user);
return Inertia::render('gruppen::Show', [
...$payload,
'group' => Presenter::group($group, $access['member']?->status),
'membership' => $access['member'] ? ['status' => $access['member']->status, 'role' => $access['member']->role, 'notify' => $access['member']->notify] : null,
'can' => collect($access)->except('member')->all(),
'members' => $access['read'] ? $this->members($group, $access['moderate']) : null,
'privacy' => Group::PRIVACY,
'privacyHints' => Group::PRIVACY_HINTS,
'roles' => Member::ROLES,
'reactions' => Post::REACTIONS,
'tab' => $request->query('tab') === 'mitglieder' ? 'mitglieder' : 'beitraege',
'reports' => $access['moderate'] ? DB::table('gruppen_reports')->where('group_id', $group->id)->whereNull('resolved_at')->count() : 0,
]);
}
public function store(Request $request): RedirectResponse
{
$data = $this->validated($request);
$group = $this->groups->create($request->user(), $data, $request->file('cover'));
return to_route('gruppen.show', $group)->with('status', 'Gruppe gegründet – laden Sie jetzt Kolleginnen und Kollegen ein.');
}
public function update(Request $request, Group $group): RedirectResponse
{
abort_unless($this->groups->access($group, $request->user())['admin'], 403);
$data = $this->validated($request);
$group->update(collect($data)->only(['name', 'description', 'privacy'])->all());
if ($request->hasFile('cover')) {
$old = $group->cover_path;
$group->update(['cover_path' => $this->files->storeCover($group->id, $request->file('cover'))]);
$old && Storage::disk(Files::DISK)->delete($old);
} elseif ($request->boolean('remove_cover') && $group->cover_path) {
Storage::disk(Files::DISK)->delete($group->cover_path);
$group->update(['cover_path' => null]);
}
return back()->with('status', 'Gruppe gespeichert.');
}
public function destroy(Request $request, Group $group): RedirectResponse
{
abort_unless($this->groups->access($group, $request->user())['admin'], 403);
$this->files->deleteGroup($group->id);
$group->delete();
return to_route('gruppen.index')->with('status', "Gruppe „{$group->name}“ gelöscht.");
}
public function join(Request $request, Group $group): RedirectResponse
{
abort_unless($this->groups->access($group, $request->user())['see'], 404);
$status = $this->groups->join($group, $request->user());
return back()->with('status', $status === 'active' ? 'Willkommen in der Gruppe!' : 'Anfrage gesendet – die Gruppe entscheidet.');
}
public function leave(Request $request, Group $group): RedirectResponse
{
$this->groups->leave($group, $request->user());
return $group->privacy === 'open' ? back()->with('status', 'Gruppe verlassen.') : to_route('gruppen.index')->with('status', 'Gruppe verlassen.');
}
public function invite(Request $request, Group $group): RedirectResponse
{
$data = $request->validate(['users' => ['required', 'array', 'max:100'], 'users.*' => ['integer']]);
$count = $this->groups->invite($group, $request->user(), $data['users']);
return back()->with('status', $count === 1 ? '1 Person eingeladen.' : "{$count} Personen eingeladen.");
}
public function decide(Request $request, Group $group, User $user): RedirectResponse
{
$data = $request->validate(['accept' => ['required', 'boolean']]);
$this->groups->decide($group, $request->user(), $user, $data['accept']);
return back()->with('status', $data['accept'] ? "{$user->name} ist jetzt Mitglied." : 'Anfrage abgelehnt.');
}
public function role(Request $request, Group $group, User $user): RedirectResponse
{
$data = $request->validate(['role' => ['required', Rule::in(array_keys(Member::ROLES))]]);
$this->groups->setRole($group, $request->user(), $user, $data['role']);
return back()->with('status', 'Rolle geändert.');
}
public function remove(Request $request, Group $group, User $user): RedirectResponse
{
$this->groups->removeMember($group, $request->user(), $user);
return back()->with('status', "{$user->name} entfernt.");
}
public function notifications(Request $request, Group $group): RedirectResponse
{
$data = $request->validate(['notify' => ['required', 'in:all,off']]);
$group->memberships()->where('user_id', $request->user()->id)->update(['notify' => $data['notify']]);
return back()->with('status', $data['notify'] === 'all' ? 'Sie werden über neue Beiträge benachrichtigt.' : 'Keine Benachrichtigungen mehr zu neuen Beiträgen.');
}
public function cover(Request $request, Group $group): StreamedResponse
{
abort_unless($group->cover_path && $this->groups->access($group, $request->user())['see'], 404);
return Storage::disk(Files::DISK)->response($group->cover_path, null, ['Content-Type' => 'image/webp', 'Cache-Control' => 'private, max-age=604800', 'X-Content-Type-Options' => 'nosniff']);
}
/**
* @return array<string, mixed>
*/
private function members(Group $group, bool $moderate): array
{
$all = $group->memberships()->with('user')->get()->filter(fn (Member $m) => $m->user);
$map = fn (Member $m) => [...Presenter::person($m->user), 'role' => $m->role, 'status' => $m->status];
return [
'active' => $all->where('status', 'active')->sortBy(fn (Member $m) => [array_search($m->role, ['admin', 'moderator', 'member'], true), $m->user->name])->map($map)->values()->all(),
'pending' => $moderate ? $all->where('status', 'pending')->map($map)->values()->all() : [],
'invited' => $moderate ? $all->where('status', 'invited')->map($map)->values()->all() : [],
];
}
/**
* @return array<string, mixed>
*/
private function validated(Request $request): array
{
return $request->validate([
'name' => ['required', 'string', 'max:100'],
'description' => ['nullable', 'string', 'max:2000'],
'privacy' => ['required', Rule::in(array_keys(Group::PRIVACY))],
'cover' => ['nullable', 'image', 'mimes:jpg,jpeg,png,webp', 'max:15360'],
], [], ['name' => 'Name', 'description' => 'Beschreibung', 'privacy' => 'Art', 'cover' => 'Titelbild']);
}
}

View file

@ -0,0 +1,162 @@
<?php
namespace Inhaus\Plugins\Gruppen\Http\Controllers;
use App\Http\Controllers\Controller;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Storage;
use Inertia\Inertia;
use Inertia\Response;
use Inhaus\Plugins\Gruppen\Files;
use Inhaus\Plugins\Gruppen\Groups;
use Inhaus\Plugins\Gruppen\Models\Attachment;
use Inhaus\Plugins\Gruppen\Models\Comment;
use Inhaus\Plugins\Gruppen\Models\Group;
use Inhaus\Plugins\Gruppen\Models\Post;
use Inhaus\Plugins\Gruppen\Presenter;
use Symfony\Component\HttpFoundation\StreamedResponse;
class PostController extends Controller
{
public function __construct(private readonly Groups $groups) {}
/** Einzelner Beitrag (Link aus Benachrichtigungen), mit allen Kommentaren */
public function show(Request $request, Group $group, Post $post): Response
{
abort_unless($post->group_id === $group->id, 404);
$access = $this->groups->access($group, $request->user());
abort_unless($access['read'], 404);
$post->load(['user', 'attachments', 'group']);
return Inertia::render('gruppen::Post', [
'group' => Presenter::group($group, $access['member']?->status),
'post' => Presenter::posts(collect([$post]), $request->user(), $this->groups)[0],
'comments' => $this->allComments($post, $request, $access['moderate']),
'reactions' => Post::REACTIONS,
'reports' => $access['moderate'] ? DB::table('gruppen_reports')->where('post_id', $post->id)->whereNull('resolved_at')->get(['id', 'comment_id', 'reason'])->all() : [],
]);
}
public function store(Request $request, Group $group): JsonResponse
{
$data = $request->validate([
'body' => ['nullable', 'string', 'max:'.Post::MAX_LENGTH],
'files' => ['nullable', 'array', 'max:'.Groups::MAX_FILES],
'files.*' => ['file', 'max:25600'],
'poll' => ['nullable', 'array', 'max:10'],
'poll.*' => ['nullable', 'string', 'max:120'],
'multiple' => ['boolean'],
], ['files.*.max' => 'Eine Datei ist größer als 25 MB.'], ['body' => 'Beitrag']);
$post = $this->groups->post($group, $request->user(), $data['body'] ?? null, $request->file('files', []), $data['poll'] ?? null, (bool) ($data['multiple'] ?? false));
$post->load(['user', 'attachments', 'group']);
return response()->json(['post' => Presenter::posts(collect([$post]), $request->user(), $this->groups)[0]], 201);
}
public function update(Request $request, Post $post): JsonResponse
{
abort_unless($post->user_id === $request->user()->id && $this->groups->access($post->group, $request->user())['post'], 403);
$data = $request->validate(['body' => ['nullable', 'string', 'max:'.Post::MAX_LENGTH]]);
$post->update(['body' => filled($data['body'] ?? null) ? trim($data['body']) : null, 'edited_at' => now()]);
return response()->json(['ok' => true]);
}
public function destroy(Request $request, Post $post): JsonResponse
{
$this->groups->deletePost($post, $request->user());
return response()->json(['ok' => true]);
}
public function pin(Request $request, Post $post): JsonResponse
{
$this->groups->pin($post, $request->user(), $request->boolean('pinned'));
return response()->json(['ok' => true]);
}
public function react(Request $request, Post $post): JsonResponse
{
$data = $request->validate(['emoji' => ['nullable', 'string', 'max:16']]);
$this->groups->react($post, $request->user(), $data['emoji'] ?? null);
return response()->json(['ok' => true]);
}
public function vote(Request $request, Post $post): JsonResponse
{
$data = $request->validate(['options' => ['present', 'array', 'max:10'], 'options.*' => ['integer']]);
$this->groups->vote($post, $request->user(), $data['options']);
$post->load(['user', 'attachments', 'group']);
return response()->json(['poll' => Presenter::posts(collect([$post]), $request->user(), $this->groups)[0]['poll']]);
}
public function comments(Request $request, Post $post): JsonResponse
{
$access = $this->groups->access($post->group, $request->user());
abort_unless($access['read'], 404);
return response()->json(['comments' => $this->allComments($post, $request, $access['moderate'])]);
}
public function comment(Request $request, Post $post): JsonResponse
{
$data = $request->validate(['body' => ['required', 'string', 'max:'.Comment::MAX_LENGTH], 'parent_id' => ['nullable', 'integer']], [], ['body' => 'Kommentar']);
$this->groups->comment($post, $request->user(), $data['body'], $data['parent_id'] ?? null);
return $this->comments($request, $post->fresh());
}
public function deleteComment(Request $request, Comment $comment): JsonResponse
{
$this->groups->deleteComment($comment, $request->user());
return response()->json(['ok' => true]);
}
public function report(Request $request, Post $post): JsonResponse
{
$data = $request->validate(['reason' => ['required', 'string', 'max:500'], 'comment_id' => ['nullable', 'integer']]);
$comment = isset($data['comment_id']) ? $post->comments()->findOrFail($data['comment_id']) : null;
$this->groups->report($post, $comment, $request->user(), trim($data['reason']));
return response()->json(['message' => 'Danke – die Gruppenmoderation sieht es sich an.']);
}
public function resolveReports(Request $request, Post $post): JsonResponse
{
abort_unless($this->groups->access($post->group, $request->user())['moderate'], 403);
DB::table('gruppen_reports')->where('post_id', $post->id)->whereNull('resolved_at')->update(['resolved_at' => now()]);
return response()->json(['ok' => true]);
}
public function file(Request $request, Attachment $attachment, string $size): StreamedResponse
{
$post = $attachment->post;
abort_unless($this->groups->access($post->group, $request->user())['read'], 404);
$disk = Storage::disk(Files::DISK);
$path = $size === 'thumb' && $attachment->thumb_path ? $attachment->thumb_path : $attachment->path;
abort_unless($disk->exists($path), 404);
$headers = ['X-Content-Type-Options' => 'nosniff', 'Cache-Control' => 'private, max-age=604800', 'Content-Security-Policy' => "default-src 'none'; img-src 'self'; sandbox"];
return $attachment->isImage()
? $disk->response($path, $attachment->name, [...$headers, 'Content-Type' => $attachment->mime], 'inline')
: $disk->download($path, $attachment->name, [...$headers, 'Content-Type' => 'application/octet-stream']);
}
/**
* @return list<array<string, mixed>>
*/
private function allComments(Post $post, Request $request, bool $moderate): array
{
$all = $post->comments()->with('user')->orderBy('id')->limit(1000)->get();
return Presenter::comments($all->whereNull('parent_id')->values(), $request->user(), $moderate, $all->whereNotNull('parent_id')->groupBy('parent_id'));
}
}

28
src/Models/Attachment.php Normal file
View file

@ -0,0 +1,28 @@
<?php
namespace Inhaus\Plugins\Gruppen\Models;
use Illuminate\Database\Eloquent\Attributes\Fillable;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\BelongsTo;
#[Fillable(['post_id', 'path', 'thumb_path', 'name', 'mime', 'size', 'width', 'height', 'sort'])]
class Attachment extends Model
{
protected $table = 'gruppen_attachments';
public $timestamps = false;
/**
* @return BelongsTo<Post, $this>
*/
public function post(): BelongsTo
{
return $this->belongsTo(Post::class);
}
public function isImage(): bool
{
return $this->thumb_path !== null;
}
}

37
src/Models/Comment.php Normal file
View file

@ -0,0 +1,37 @@
<?php
namespace Inhaus\Plugins\Gruppen\Models;
use App\Models\User;
use Illuminate\Database\Eloquent\Attributes\Fillable;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\BelongsTo;
#[Fillable(['post_id', 'user_id', 'parent_id', 'body', 'edited_at'])]
class Comment extends Model
{
public const MAX_LENGTH = 3000;
protected $table = 'gruppen_comments';
protected function casts(): array
{
return ['edited_at' => 'datetime'];
}
/**
* @return BelongsTo<User, $this>
*/
public function user(): BelongsTo
{
return $this->belongsTo(User::class);
}
/**
* @return BelongsTo<Post, $this>
*/
public function post(): BelongsTo
{
return $this->belongsTo(Post::class);
}
}

81
src/Models/Group.php Normal file
View file

@ -0,0 +1,81 @@
<?php
namespace Inhaus\Plugins\Gruppen\Models;
use App\Models\User;
use Illuminate\Database\Eloquent\Attributes\Fillable;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\HasMany;
#[Fillable(['name', 'slug', 'description', 'cover_path', 'privacy', 'created_by', 'members_count', 'posts_count', 'last_activity_at'])]
class Group extends Model
{
public const PRIVACY = [
'open' => 'Offen',
'closed' => 'Geschlossen',
'secret' => 'Privat',
];
public const PRIVACY_HINTS = [
'open' => 'Alle sehen die Beiträge und können sofort beitreten.',
'closed' => 'Alle finden die Gruppe; Beiträge sehen nur Mitglieder. Beitritt auf Anfrage.',
'secret' => 'Nur Mitglieder finden die Gruppe. Beitritt nur auf Einladung.',
];
protected $table = 'gruppen_groups';
protected function casts(): array
{
return ['last_activity_at' => 'datetime'];
}
public function getRouteKeyName(): string
{
return 'slug';
}
/**
* @return HasMany<Member, $this>
*/
public function memberships(): HasMany
{
return $this->hasMany(Member::class);
}
/**
* @return HasMany<Post, $this>
*/
public function posts(): HasMany
{
return $this->hasMany(Post::class);
}
public function membership(?User $user): ?Member
{
return $user ? $this->memberships()->where('user_id', $user->id)->first() : null;
}
/**
* Auffindbar: offene und geschlossene Gruppen, private nur für Mitglieder bzw. Eingeladene.
*
* @param Builder<Group> $query
*/
public function scopeDiscoverableBy(Builder $query, User $user): void
{
if ($user->can('gruppen.manage')) {
return;
}
$query->where(fn ($q) => $q->where('privacy', '!=', 'secret')
->orWhereHas('memberships', fn ($m) => $m->where('user_id', $user->id)->whereIn('status', ['active', 'invited'])));
}
public function refreshCounts(): void
{
$this->forceFill([
'members_count' => $this->memberships()->where('status', 'active')->count(),
'posts_count' => $this->posts()->count(),
])->saveQuietly();
}
}

74
src/Models/Member.php Normal file
View file

@ -0,0 +1,74 @@
<?php
namespace Inhaus\Plugins\Gruppen\Models;
use App\Models\User;
use Illuminate\Database\Eloquent\Attributes\Fillable;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\BelongsTo;
#[Fillable(['group_id', 'user_id', 'role', 'status', 'invited_by', 'notify', 'joined_at', 'last_seen_at', 'notified_at'])]
class Member extends Model
{
public const ROLES = ['admin' => 'Admin', 'moderator' => 'Moderation', 'member' => 'Mitglied'];
protected $table = 'gruppen_members';
public $incrementing = false;
protected $primaryKey = null;
protected function casts(): array
{
return ['joined_at' => 'datetime', 'last_seen_at' => 'datetime', 'notified_at' => 'datetime'];
}
/**
* @return BelongsTo<User, $this>
*/
public function user(): BelongsTo
{
return $this->belongsTo(User::class);
}
/**
* @return BelongsTo<Group, $this>
*/
public function group(): BelongsTo
{
return $this->belongsTo(Group::class);
}
public function isActive(): bool
{
return $this->status === 'active';
}
/** Admin oder Moderation: pinnen, löschen, Anfragen annehmen */
public function canModerate(): bool
{
return $this->isActive() && in_array($this->role, ['admin', 'moderator'], true);
}
public function isAdmin(): bool
{
return $this->isActive() && $this->role === 'admin';
}
protected function setKeysForSaveQuery($query): Builder
{
return $query->where('group_id', $this->group_id)->where('user_id', $this->user_id);
}
protected function setKeysForSelectQuery($query): Builder
{
return $this->setKeysForSaveQuery($query);
}
/** Zusammengesetzter Schlüssel: Löschen nur genau dieser Mitgliedschaft */
public function delete(): ?bool
{
return (bool) static::query()->where('group_id', $this->group_id)->where('user_id', $this->user_id)->delete();
}
}

56
src/Models/Post.php Normal file
View file

@ -0,0 +1,56 @@
<?php
namespace Inhaus\Plugins\Gruppen\Models;
use App\Models\User;
use Illuminate\Database\Eloquent\Attributes\Fillable;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\BelongsTo;
use Illuminate\Database\Eloquent\Relations\HasMany;
#[Fillable(['group_id', 'user_id', 'body', 'poll', 'pinned_at', 'edited_at', 'comments_count'])]
class Post extends Model
{
public const MAX_LENGTH = 10000;
public const REACTIONS = ['👍', '❤️', '😂', '😮', '😢', '👏'];
protected $table = 'gruppen_posts';
protected function casts(): array
{
return ['poll' => 'array', 'pinned_at' => 'datetime', 'edited_at' => 'datetime'];
}
/**
* @return BelongsTo<User, $this>
*/
public function user(): BelongsTo
{
return $this->belongsTo(User::class);
}
/**
* @return BelongsTo<Group, $this>
*/
public function group(): BelongsTo
{
return $this->belongsTo(Group::class);
}
/**
* @return HasMany<Attachment, $this>
*/
public function attachments(): HasMany
{
return $this->hasMany(Attachment::class)->orderBy('sort');
}
/**
* @return HasMany<Comment, $this>
*/
public function comments(): HasMany
{
return $this->hasMany(Comment::class);
}
}

112
src/Presenter.php Normal file
View file

@ -0,0 +1,112 @@
<?php
namespace Inhaus\Plugins\Gruppen;
use App\Models\User;
use Illuminate\Support\Collection;
use Illuminate\Support\Facades\DB;
use Inhaus\Plugins\Gruppen\Models\Attachment;
use Inhaus\Plugins\Gruppen\Models\Comment;
use Inhaus\Plugins\Gruppen\Models\Group;
use Inhaus\Plugins\Gruppen\Models\Post;
class Presenter
{
/**
* @return array<string, mixed>|null
*/
public static function person(?User $user): ?array
{
return $user ? ['id' => $user->id, 'name' => $user->name, 'initials' => $user->initials, 'avatar_url' => $user->avatarUrl(96), 'job_title' => $user->job_title] : null;
}
/**
* @return array<string, mixed>
*/
public static function group(Group $group, ?string $status = null): array
{
return [
'id' => $group->id,
'slug' => $group->slug,
'name' => $group->name,
'description' => $group->description,
'privacy' => $group->privacy,
'privacy_label' => Group::PRIVACY[$group->privacy],
'privacy_hint' => Group::PRIVACY_HINTS[$group->privacy],
'cover_url' => $group->cover_path ? route('gruppen.cover', [$group, 'v' => substr(md5($group->cover_path), 0, 8)]) : null,
'members_count' => $group->members_count,
'posts_count' => $group->posts_count,
'last_activity_at' => $group->last_activity_at?->toIso8601String(),
'status' => $status,
'url' => route('gruppen.show', $group),
];
}
/**
* @param Collection<int, Post> $posts mit user, attachments, group
* @return list<array<string, mixed>>
*/
public static function posts(Collection $posts, User $me, Groups $groups): array
{
$ids = $posts->pluck('id')->all();
$reactions = DB::table('gruppen_reactions')->whereIn('post_id', $ids ?: [0])->get()->groupBy('post_id');
$votes = DB::table('gruppen_poll_votes')->whereIn('post_id', $ids ?: [0])->get()->groupBy('post_id');
$comments = Comment::query()->with('user')->whereIn('post_id', $ids ?: [0])->whereNull('parent_id')
->orderByDesc('id')->get()->groupBy('post_id');
$access = [];
return $posts->map(function (Post $post) use ($me, $groups, $reactions, $votes, $comments, &$access) {
$rights = $access[$post->group_id] ??= $groups->access($post->group, $me);
$mineReaction = $reactions->get($post->id)?->firstWhere('user_id', $me->id)?->emoji;
$postVotes = $votes->get($post->id) ?? collect();
return [
'id' => $post->id,
'group' => ['slug' => $post->group->slug, 'name' => $post->group->name],
'user' => self::person($post->user),
'body' => $post->body,
'pinned' => $post->pinned_at !== null,
'edited' => $post->edited_at !== null,
'created_at' => $post->created_at?->toIso8601String(),
'url' => route('gruppen.post', [$post->group, $post]),
'images' => $post->attachments->filter->isImage()->map(fn (Attachment $a) => [
'id' => $a->id, 'url' => route('gruppen.file', [$a, 'full']), 'thumb_url' => route('gruppen.file', [$a, 'thumb']), 'width' => $a->width, 'height' => $a->height, 'name' => $a->name,
])->values()->all(),
'files' => $post->attachments->reject->isImage()->map(fn (Attachment $a) => [
'id' => $a->id, 'url' => route('gruppen.file', [$a, 'full']), 'name' => $a->name, 'size' => $a->size,
])->values()->all(),
'poll' => $post->poll ? [
'multiple' => (bool) $post->poll['multiple'],
'voters' => $postVotes->pluck('user_id')->unique()->count(),
'mine' => $postVotes->where('user_id', $me->id)->pluck('option')->map(fn ($o) => (int) $o)->values()->all(),
'options' => collect($post->poll['options'])->map(fn ($label, $i) => ['label' => $label, 'votes' => $postVotes->where('option', $i)->count()])->all(),
] : null,
'reactions' => ($reactions->get($post->id) ?? collect())->countBy('emoji')->map(fn ($count, $emoji) => ['emoji' => $emoji, 'count' => $count])->sortByDesc('count')->values()->all(),
'reactions_total' => ($reactions->get($post->id) ?? collect())->count(),
'my_reaction' => $mineReaction,
'comments_count' => $post->comments_count,
'comments' => self::comments(($comments->get($post->id) ?? collect())->take(2)->reverse()->values(), $me, $rights['moderate']),
'can_comment' => $rights['post'],
'can_delete' => $post->user_id === $me->id || $rights['moderate'],
'can_edit' => $post->user_id === $me->id,
'can_pin' => $rights['moderate'],
];
})->values()->all();
}
/**
* @param Collection<int, Comment> $comments
* @return list<array<string, mixed>>
*/
public static function comments(Collection $comments, User $me, bool $moderate, ?Collection $replies = null): array
{
return $comments->map(fn (Comment $c) => [
'id' => $c->id,
'user' => self::person($c->user),
'body' => $c->body,
'created_at' => $c->created_at?->toIso8601String(),
'can_delete' => $c->user_id === $me->id || $moderate,
'replies' => $replies ? self::comments($replies->get($c->id) ?? collect(), $me, $moderate) : [],
])->values()->all();
}
}