Merge pull request #39 from cjmellor/dispatch-multiple-events

Fire Multiple Levelled Up Events

src/Concerns/GiveExperience.php

@@ -33,7 +33,7 @@ public function addPoints(
 
         $lastLevel = Level::orderByDesc(column: 'level')->first();
         throw_if(
-            condition: isset($lastLevel->next_level_experience) && $amount > Level::orderByDesc(column: 'level')->first()->next_level_experience,
+            condition: isset($lastLevel->next_level_experience) && $amount > $lastLevel->next_level_experience,
             message: 'Points exceed the last level\'s experience points.',
         );
 
@@ -69,14 +69,15 @@ public function addPoints(
                 'level_id' => $experience->level_id,
             ])->save();
 
-            if ($level?->level > config(key: 'level-up.starting_level')) {
-                Event::dispatch(event: new UserLevelledUp(user: $this, level: $level->level));
+            for ($lvl = config(key: 'level-up.starting_level'); $lvl <= $level?->level; $lvl++) {
+                Event::dispatch(event: new UserLevelledUp(user: $this, level: $lvl));
             }
 
             $this->dispatchEvent($amount, $type, $reason);
 
             return $this->experience;
         }
+
         /**
          * If the User does have an Experience record, update it.
          */
@@ -105,16 +106,6 @@ public function experience(): HasOne
         return $this->hasOne(related: Experience::class);
     }
 
-    public function experienceHistory(): HasMany
-    {
-        return $this->hasMany(related: ExperienceAudit::class);
-    }
-
-    public function getPoints(): int
-    {
-        return $this->experience->experience_points;
-    }
-
     protected function dispatchEvent(int $amount, string $type, ?string $reason): void
     {
         event(new PointsIncreased(
@@ -138,6 +129,11 @@ public function getLevel(): int
         return $this->experience->status->level;
     }
 
+    public function experienceHistory(): HasMany
+    {
+        return $this->hasMany(related: ExperienceAudit::class);
+    }
+
     public function deductPoints(int $amount): Experience
     {
         $this->experience->decrement(column: 'experience_points', amount: $amount);
@@ -191,22 +187,27 @@ public function nextLevelAt(int $checkAgainst = null, bool $showAsPercentage = f
         return max(0, ($nextLevel->next_level_experience - $currentLevelExperience) - ($this->getPoints() - $currentLevelExperience));
     }
 
-    public function levelUp(): void
+    public function getPoints(): int
+    {
+        return $this->experience->experience_points;
+    }
+
+    public function levelUp(int $to): void
     {
         if (config(key: 'level-up.level_cap.enabled') && $this->getLevel() >= config(key: 'level-up.level_cap.level')) {
             return;
         }
 
-        $nextLevel = Level::firstWhere(column: 'level', operator: $this->getLevel() + 1);
+        $this->fill(attributes: ['level_id' => $to])
+            ->save();
 
-        $this->experience->status()->associate(model: $nextLevel);
-        $this->experience->save();
+        $this->experience->status()->associate(model: $to);
+        $this->save();
 
-        $this->update(attributes: [
-            'level_id' => $nextLevel->level,
-        ]);
-
-        event(new UserLevelledUp(user: $this, level: $this->getLevel()));
+        // Fire an event for each level gained
+        for ($lvl = $this->getLevel(); $lvl <= $to; $lvl++) {
+            event(new UserLevelledUp(user: $this, level: $lvl));
+        }
     }
 
     public function level(): BelongsTo

src/Listeners/PointsIncreasedListener.php

@@ -24,16 +24,26 @@ public function __invoke(PointsIncreased $event): void
             ]);
         }
 
-        $nextLevel = Level::firstWhere(column: 'level', operator: $event->user->getLevel() + 1);
+        // Get the next level experience needed for the user's current level
+        $nextLevel = Level::firstWhere(column: 'level', operator: '=', value: $event->user->getLevel() + 1);
 
         if (! $nextLevel) {
+            // If there is no next level, return
             return;
         }
 
-        if ($event->user->getPoints() < $nextLevel->next_level_experience) {
-            return;
+        // Check if user's points are equal or greater than the next level's required experience
+        if ($event->user->getPoints() >= $nextLevel->next_level_experience) {
+            // Find the highest level the user can achieve with current points
+            $highestAchievableLevel = Level::query()
+                ->where(column: 'next_level_experience', operator: '<=', value: $event->user->getPoints())
+                ->orderByDesc(column: 'level')
+                ->first();
+
+            // Update the user level to the highest achievable level
+            if ($highestAchievableLevel->level > $event->user->getLevel()) {
+                $event->user->levelUp(to: $highestAchievableLevel->level);
+            }
         }
-
-        $event->user->levelUp();
     }
 }

tests/Concerns/GiveExperienceTest.php

@@ -257,7 +257,7 @@
 
     expect($this->user->experience)
         ->experience_points->toBe(expected: 400)
-        ->and($this->user)->getLevel()->toBe(expected: 3);
+        ->and($this->user)->getLevel()->toBe(expected: 4);
 });
 
 test('A multiplier can use data that was passed through to it', function () {

tests/Listeners/PointsIncreasedListenerTest.php

@@ -58,7 +58,7 @@
     $this->user->addPoints(amount: 100);
 
     expect($this->user)
-        ->experienceHistory()->count()->toBe(expected: 2);
+        ->experienceHistory()->count()->toBe(expected: 3);
 
     $this->assertDatabaseHas(table: 'experience_audits', data: [
         'user_id' => $this->user->id,
@@ -110,3 +110,14 @@
         'reason' => 'test',
     ]);
 });
+
+test(description: 'a User can level up multiple times', closure: function () {
+    /**
+     * Example: a new User will start with no experience, can be given
+     * 300 points, and will level up to level 3
+     */
+    $this->user->addPoints(amount: 300);
+    $this->user->addPoints(amount: 300);
+
+    expect($this->user)->getLevel()->toBe(expected: 5);
+});

tests/Listeners/UserLevelledUpListenerTest.php

@@ -12,7 +12,7 @@
 it(description: 'adds audit data when a User level\'s up', closure: function () {
     $this->user->addPoints(100);
 
-    expect($this->user)->experienceHistory->count()->toBe(expected: 2);
+    expect($this->user)->experienceHistory->count()->toBe(expected: 3);
 
     $this->assertDatabaseHas(table: 'experience_audits', data: [
         'user_id' => $this->user->id,
@@ -31,3 +31,19 @@
     Event::assertDispatched(event: UserLevelledUp::class);
     Event::assertListening(expectedEvent: UserLevelledUp::class, expectedListener: UserLevelledUpListener::class);
 });
+
+test(description: 'when a User levels up more than once, an event runs for each level', closure: function (int $level) {
+    Event::fake();
+
+    $this->user->addPoints(300);
+
+    expect($this->user)->experience->level_id->toBe(expected: 3)
+        ->and($this->user)->level_id->toBe(expected: 3);
+
+    Event::assertDispatchedTimes(event: UserLevelledUp::class, times: 3);
+
+    Event::assertDispatched(
+        event: UserLevelledUp::class,
+        callback: fn (UserLevelledUp $event): bool => $event->level === $level
+    );
+})->with([1, 2, 3]);