feat: Implement read cursor activity tracking and recent activity dashboard with context

app/Http/Controllers/DashboardController.php

@@ -0,0 +1,20 @@
+<?php
+
+namespace App\Http\Controllers;
+
+use App\Services\ActivityService;
+use Illuminate\Http\Request;
+use Inertia\Inertia;
+
+class DashboardController extends Controller
+{
+    public function index(Request $request, ActivityService $activityService)
+    {
+        $user = $request->user();
+        $unreadEntities = $activityService->getUnreadEntitiesGrouped($user);
+
+        return Inertia::render('Dashboard', [
+            'unreadEntities' => $unreadEntities,
+        ]);
+    }
+}

app/Http/Controllers/DynamicController.php

@@ -8,6 +8,8 @@ use Illuminate\Foundation\Auth\Access\AuthorizesRequests;
 use Illuminate\Http\Request;
 use Inertia\Inertia;
 
+use App\Services\ActivityService;
+
 class DynamicController extends Controller
 {
     use AuthorizesRequests;
@@ -44,10 +46,12 @@ class DynamicController extends Controller
     /**
      * Display the specified resource.
      */
-    public function show(Dynamic $dynamic)
+    public function show(Dynamic $dynamic, ActivityService $activityService)
     {
         $this->authorize('view', $dynamic);
 
+        $activityService->updateCursor(auth()->user(), $dynamic);
+
         $dynamic->load([
             'ledgers.media',
             'participants',

app/Http/Controllers/LedgerController.php

@@ -5,6 +5,7 @@ namespace App\Http\Controllers;
 use App\Http\Requests\StoreLedgerRequest;
 use App\Models\Dynamic;
 use App\Models\Ledger;
+use App\Services\ActivityService;
 use Illuminate\Http\Request;
 use Illuminate\Foundation\Auth\Access\AuthorizesRequests;
 use Inertia\Inertia;
@@ -53,10 +54,12 @@ class LedgerController extends Controller
     /**
      * Display the specified resource.
      */
-    public function show(Request $request, Dynamic $dynamic, Ledger $ledger)
+    public function show(Request $request, Dynamic $dynamic, Ledger $ledger, ActivityService $activityService)
     {
         $this->authorize('view', $ledger);
 
+        $activityService->updateCursor($request->user(), $ledger);
+
         $dynamic->load('chat', 'participants');
 
         $ledger->load([

app/Http/Middleware/HandleInertiaRequests.php

@@ -42,6 +42,14 @@ class HandleInertiaRequests extends Middleware
                 'user' => $request->user(),
             ],
             'sidebarOpen' => ! $request->hasCookie('sidebar_state') || $request->cookie('sidebar_state') === 'true',
+            'unreadNotificationsCount' => function () use ($request) {
+                if (! $request->user()) {
+                    return 0;
+                }
+                
+                $service = app(\App\Services\ActivityService::class);
+                return count($service->getUnreadEntitiesGrouped($request->user()));
+            },
         ];
     }
 }

app/Models/ReadCursor.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace App\Models;
+
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\Relations\BelongsTo;
+use Illuminate\Database\Eloquent\Relations\MorphTo;
+
+class ReadCursor extends Model
+{
+    protected $fillable = [
+        'user_id',
+        'cursorable_id',
+        'cursorable_type',
+        'read_at',
+    ];
+
+    protected $casts = [
+        'read_at' => 'datetime',
+    ];
+
+    public function user(): BelongsTo
+    {
+        return $this->belongsTo(User::class);
+    }
+
+    public function cursorable(): MorphTo
+    {
+        return $this->morphTo();
+    }
+}

app/Models/User.php

@@ -44,6 +44,11 @@ class User extends Authenticatable implements PasskeyUser
         return $this->hasMany(Mutation::class);
     }
 
+    public function readCursors()
+    {
+        return $this->hasMany(ReadCursor::class);
+    }
+
     /**
      * Get the attributes that should be cast.
      *

app/Services/ActivityService.php

@@ -0,0 +1,233 @@
+<?php
+
+namespace App\Services;
+
+use App\Models\User;
+use App\Models\Dynamic;
+use App\Models\Ledger;
+use App\Models\Mutation;
+use App\Models\Message;
+use App\Models\ReadCursor;
+use Illuminate\Support\Carbon;
+
+class ActivityService
+{
+    /**
+     * Update the read cursor for a user on a specific entity.
+     */
+    public function updateCursor(User $user, $entity): void
+    {
+        ReadCursor::updateOrCreate(
+            [
+                'user_id' => $user->id,
+                'cursorable_id' => $entity->id,
+                'cursorable_type' => get_class($entity),
+            ],
+            [
+                'read_at' => Carbon::now(),
+            ]
+        );
+    }
+
+    /**
+     * Get the read cursor timestamp for a user on a specific entity.
+     */
+    public function getCursorReadAt(User $user, $entity): \Carbon\CarbonInterface
+    {
+        $cursor = ReadCursor::where([
+            'user_id' => $user->id,
+            'cursorable_id' => $entity->id,
+            'cursorable_type' => get_class($entity),
+        ])->first();
+
+        // If no cursor exists, default to epoch (all activities are unread)
+        return $cursor ? $cursor->read_at : Carbon::parse('1970-01-01');
+    }
+
+    /**
+     * Retrieve all activities for a Dynamic.
+     */
+    public function getDynamicActivities(Dynamic $dynamic): array
+    {
+        $activities = [];
+
+        // 1. Chat Messages
+        if ($dynamic->chat) {
+            $messages = Message::where('chat_id', $dynamic->chat->id)
+                ->with('user')
+                ->get();
+
+            foreach ($messages as $msg) {
+                $activities[] = [
+                    'id' => "dynamic_msg_{$msg->id}",
+                    'type' => 'message',
+                    'description' => $msg->content,
+                    'user' => [
+                        'name' => $msg->user ? $msg->user->name : 'Unknown User',
+                    ],
+                    'created_at' => $msg->created_at,
+                ];
+            }
+        }
+
+        // 2. Ledgers Created
+        $ledgers = Ledger::where('dynamic_id', $dynamic->id)->get();
+        foreach ($ledgers as $ledger) {
+            $activities[] = [
+                'id' => "ledger_created_{$ledger->id}",
+                'type' => 'ledger_created',
+                'description' => "New Ledger '{$ledger->name}' was created.",
+                'user' => [
+                    'name' => 'System',
+                ],
+                'created_at' => $ledger->created_at,
+            ];
+        }
+
+        // Sort activities chronologically ascending
+        usort($activities, fn($a, $b) => $a['created_at']->timestamp <=> $b['created_at']->timestamp);
+
+        return $activities;
+    }
+
+    /**
+     * Retrieve all activities for a Ledger.
+     */
+    public function getLedgerActivities(Ledger $ledger): array
+    {
+        $activities = [];
+
+        // 1. Mutations (Creation and Status updates)
+        $mutations = Mutation::where('ledger_id', $ledger->id)
+            ->with('user')
+            ->get();
+
+        foreach ($mutations as $mutation) {
+            // Log creation of mutation
+            $verb = $mutation->type === 'penalty' ? 'issued demerit' : ($mutation->type === 'reward' ? 'credited points' : 'submitted entry');
+            $activities[] = [
+                'id' => "mutation_created_{$mutation->id}",
+                'type' => 'mutation_created',
+                'description' => "{$verb} ({$mutation->amount}): \"{$mutation->description}\"",
+                'user' => [
+                    'name' => $mutation->user ? $mutation->user->name : 'Unknown User',
+                ],
+                'created_at' => $mutation->created_at,
+            ];
+
+            // Log status approval/rejection update if different from creation
+            if ($mutation->status !== 'pending' && $mutation->updated_at->gt($mutation->created_at->addSeconds(2))) {
+                $activities[] = [
+                    'id' => "mutation_updated_{$mutation->id}",
+                    'type' => 'mutation_updated',
+                    'description' => "Entry '{$mutation->description}' was " . strtoupper($mutation->status),
+                    'user' => [
+                        'name' => 'System',
+                    ],
+                    'created_at' => $mutation->updated_at,
+                ];
+            }
+        }
+
+        // 2. Mutation Comments
+        if ($mutations->isNotEmpty()) {
+            $comments = Message::whereHas('chat', function ($q) use ($mutations) {
+                $q->where('chatable_type', Mutation::class)
+                  ->whereIn('chatable_id', $mutations->pluck('id'));
+            })
+            ->with(['user', 'chat.chatable'])
+            ->get();
+
+            foreach ($comments as $comment) {
+                /** @var Mutation|null $mutationEntity */
+                $mutationEntity = $comment->chat->chatable;
+                $context = $mutationEntity ? " on \"{$mutationEntity->description}\"" : "";
+                
+                $activities[] = [
+                    'id' => "comment_{$comment->id}",
+                    'type' => 'comment',
+                    'description' => "Commented{$context}: \"{$comment->content}\"",
+                    'user' => [
+                        'name' => $comment->user ? $comment->user->name : 'Unknown User',
+                    ],
+                    'created_at' => $comment->created_at,
+                ];
+            }
+        }
+
+        // Sort activities chronologically ascending
+        usort($activities, fn($a, $b) => $a['created_at']->timestamp <=> $b['created_at']->timestamp);
+
+        return $activities;
+    }
+
+    /**
+     * Get unread activities grouped by active entities (Dynamics, Ledgers) for the given user.
+     */
+    public function getUnreadEntitiesGrouped(User $user): array
+    {
+        $groupedEntities = [];
+
+        // 1. Get all participating Dynamics
+        $dynamics = $user->dynamics()->get();
+
+        foreach ($dynamics as $dynamic) {
+            $readAt = $this->getCursorReadAt($user, $dynamic);
+            $activities = $this->getDynamicActivities($dynamic);
+
+            $this->partitionActivities($activities, $readAt, $dynamic, 'Dynamic', route('dynamics.show', $dynamic->id), $groupedEntities);
+        }
+
+        // 2. Get all Ledgers under those Dynamics
+        if ($dynamics->isNotEmpty()) {
+            $ledgers = Ledger::whereIn('dynamic_id', $dynamics->pluck('id'))->get();
+
+            foreach ($ledgers as $ledger) {
+                $readAt = $this->getCursorReadAt($user, $ledger);
+                $activities = $this->getLedgerActivities($ledger);
+
+                $this->partitionActivities($activities, $readAt, $ledger, 'Ledger', route('dynamics.ledgers.show', [$ledger->dynamic_id, $ledger->id]), $groupedEntities);
+            }
+        }
+
+        return $groupedEntities;
+    }
+
+    /**
+     * Partition activities into read and unread, and construct the grouped entity metadata.
+     */
+    private function partitionActivities(array $activities, \Carbon\CarbonInterface $readAt, $entity, string $type, string $url, array &$groupedEntities): void
+    {
+        $alreadyRead = [];
+        $unread = [];
+
+        foreach ($activities as $act) {
+            if ($act['created_at']->gt($readAt)) {
+                $unread[] = $act;
+            } else {
+                $alreadyRead[] = $act;
+            }
+        }
+
+        if (!empty($unread)) {
+            // We have unread activity! Let's pull the last two read items as context
+            $context = array_slice($alreadyRead, -2);
+
+            // Format timestamps for serializing to frontend
+            $formatActivity = function ($act) {
+                $act['created_at'] = $act['created_at']->toIso8601String();
+                return $act;
+            };
+
+            $groupedEntities[] = [
+                'id' => $entity->id,
+                'name' => $entity->name,
+                'type' => $type,
+                'url' => $url,
+                'unread_count' => count($unread),
+                'context_activities' => array_map($formatActivity, $context),
+                'new_activities' => array_map($formatActivity, $unread),
+            ];
+        }
+    }
+}