ADD polymorphic relation to allow multiple user types

README.md

@@ -145,18 +145,39 @@ return [
 
 ### Basic
 
-To use the package, add the `Maize\LegalConsent\HasLegalConsent` trait to the User model.
+To use the package, add the `Maize\LegalConsent\HasLegalConsent` trait to the all Authenticatable models you want to handle.
 
-Here's an example model including the `HasLegalConsent` trait:
+Here's an example including the `HasLegalConsent` trait to both User and Admin models:
 
 ``` php
 <?php
 
 namespace App\Models;
 
+use Illuminate\Foundation\Auth\User as Authenticatable;
 use Maize\LegalConsent\HasLegalConsent;
 
-class User extends Model
+class User extends Authenticatable
+{
+    use HasLegalConsent;
+
+    protected $fillable = [
+        'fist_name',
+        'last_name',
+        'email',
+    ];
+}
+```
+
+``` php
+<?php
+
+namespace App\Models;
+
+use Illuminate\Foundation\Auth\User as Authenticatable;
+use Maize\LegalConsent\HasLegalConsent;
+
+class Admin extends Authenticatable
 {
     use HasLegalConsent;
 
@@ -188,7 +209,7 @@ Here are the fields who should be filled:
 Let's say we create a privacy policy document with the publication on 2021-01-01: here's the model entity we would have:
 
 ``` php
-$nps = [
+$legalDocument = [
     "id" => 1,
     "type" => "privacy-policy",
     "body" => "The privacy policy's very long text",

database/factories/AdminFactory.php

@@ -0,0 +1,18 @@
+<?php
+
+namespace Maize\LegalConsent\Database\Factories;
+
+use Maize\LegalConsent\Tests\Models\Admin;
+use Illuminate\Database\Eloquent\Factories\Factory;
+
+class AdminFactory extends Factory
+{
+    protected $model = Admin::class;
+
+    public function definition()
+    {
+        return [
+            //
+        ];
+    }
+}

database/migrations/create_admins_table.php.stub

@@ -0,0 +1,16 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+class CreateAdminsTable extends Migration
+{
+    public function up()
+    {
+        Schema::create('admins', function (Blueprint $table) {
+            $table->bigIncrements('id');
+            $table->timestamps();
+        });
+    }
+}

database/migrations/create_legal_consent_tables.php.stub

@@ -19,7 +19,7 @@ class CreateLegalConsentTables extends Migration
 
         Schema::create('legal_consents', function (Blueprint $table) {
             $table->foreignId('document_id')->constrained('legal_documents')->cascadeOnUpdate()->cascadeOnDelete();
-            $table->foreignId('user_id')->constrained()->cascadeOnUpdate()->cascadeOnDelete();
+            $table->morphs('user');
             $table->timestamps();
         });
     }

src/HasLegalConsent.php

@@ -2,11 +2,27 @@
 
 namespace Maize\LegalConsent;
 
+use Illuminate\Database\Eloquent\Relations\MorphMany;
 use Illuminate\Support\Facades\Cache;
 use Maize\LegalConsent\Models\LegalDocument;
 
 trait HasLegalConsent
 {
+    public static function bootHasLegalConsent(): void
+    {
+        static::deleted(
+            fn ($model) => $model->legalConsents()->delete()
+        );
+    }
+
+    public function legalConsents(): MorphMany
+    {
+        return $this->morphMany(
+            config('legal-consent.legal_consent_model'),
+            'user'
+        );
+    }
+
     public function hasAcceptedDefaultLegalDocument(string $type): bool
     {
         $document = $this->findDefaultLegalDocumentForType($type);
@@ -20,23 +36,19 @@ public function hasAcceptedDefaultLegalDocument(string $type): bool
 
     public function hasAcceptedLegalDocument(LegalDocument $document): bool
     {
-        $legalConsentModelClass = config('legal-consent.legal_consent_model');
-
         return Cache::remember(
             $this->legalCacheKey($document),
             config('legal-consent.cache.document_user_ttl'),
-            fn () => $legalConsentModelClass::query()
-                ->where([
-                    'document_id' => $document->getKey(),
-                    'user_id' => $this->getKey(),
-                ])
+            fn () => $this
+                ->legalConsents()
+                ->where('document_id', $document->getKey())
                 ->exists()
         );
     }
 
     protected function legalCacheKey(LegalDocument $document): string
     {
-        return "legal.documents.{$document->getKey()}.users.{$this->getKey()}";
+        return "legal.documents.{$document->getKey()}.{$this->getMorphClass()}.{$this->getKey()}";
     }
 
     public function acceptDefaultLegalDocument(string $type): void
@@ -48,11 +60,8 @@ public function acceptDefaultLegalDocument(string $type): void
 
     public function acceptLegalDocument(LegalDocument $document): void
     {
-        $legalConsentModelClass = config('legal-consent.legal_consent_model');
-
-        $legalConsentModelClass::firstOrCreate([
+        $this->legalConsents()->firstOrCreate([
             'document_id' => $document->getKey(),
-            'user_id' => $this->getKey(),
         ]);
 
         Cache::forget(

src/Models/LegalConsent.php

@@ -13,6 +13,7 @@ class LegalConsent extends Pivot
 
     protected $fillable = [
         'document_id',
+        'user_type',
         'user_id',
     ];
 }

tests/AcceptLegalDocumentListenerTest.php

@@ -112,7 +112,7 @@ public function can_not_auto_accept_document_after_registration_if_request_is_em
     /** @test */
     public function ignore_event_if_not_have_user_setted()
     {
-        $event = new class () {
+        $event = new class() {
         };
 
         $listener = new AcceptLegalDocumentListener();

tests/HasLegalConsentTest.php

@@ -3,7 +3,9 @@
 namespace Maize\LegalConsent\Tests;
 
 use Carbon\Carbon;
+use Maize\LegalConsent\Models\LegalConsent;
 use Maize\LegalConsent\Models\LegalDocument;
+use Maize\LegalConsent\Tests\Models\Admin;
 use Maize\LegalConsent\Tests\Models\User;
 
 class HasLegalConsentTest extends TestCase
@@ -102,4 +104,61 @@ public function can_check_if_user_has_accepted_default_document()
         $this->assertTrue($users[1]->hasAcceptedDefaultLegalDocument($type1));
         $this->assertTrue($users[1]->hasAcceptedDefaultLegalDocument($type2));
     }
+
+    /** @test */
+    public function can_delete_associated_legal_consents_on_user_delete()
+    {
+        $type1 = config('legal-consent.allowed_document_types')[0];
+        $type2 = config('legal-consent.allowed_document_types')[1];
+
+        $user = User::factory()->create();
+
+        LegalDocument::factory()->create([
+            'type' => $type1,
+            'published_at' => Carbon::now()->subDays(2),
+        ]);
+
+        LegalDocument::factory()->create([
+            'type' => $type2,
+            'published_at' => Carbon::now()->subDays(2),
+        ]);
+
+        $user->acceptDefaultLegalDocument($type1);
+        $user->acceptDefaultLegalDocument($type2);
+
+        $this->assertDatabaseCount(LegalConsent::class, 2);
+
+        $user->delete();
+
+        $this->assertDatabaseCount(LegalConsent::class, 0);
+    }
+
+    /** @test */
+    public function can_allow_multiple_user_types()
+    {
+        $type = config('legal-consent.allowed_document_types')[0];
+
+        $user = User::factory()->create();
+        $admin = Admin::factory()->create();
+
+        $document = LegalDocument::factory()->create([
+            'type' => $type,
+            'published_at' => Carbon::now()->subDays(2),
+        ]);
+
+        $user->acceptDefaultLegalDocument($type);
+        $admin->acceptDefaultLegalDocument($type);
+
+        $this->assertDatabaseHas(LegalConsent::class, [
+            'user_type' => $user->getMorphClass(),
+            'user_id' => $user->getKey(),
+            'document_id' => $document->getKey(),
+        ]);
+
+        $this->assertDatabaseHas(LegalConsent::class, [
+            'user_type' => $admin->getMorphClass(),
+            'user_id' => $admin->getKey(),
+            'document_id' => $document->getKey(),
+        ]);
+    }
 }

tests/Models/Admin.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace Maize\LegalConsent\Tests\Models;
+
+use Illuminate\Database\Eloquent\Factories\HasFactory;
+use Illuminate\Foundation\Auth\User as Authenticatable;
+use Maize\LegalConsent\HasLegalConsent;
+
+class Admin extends Authenticatable
+{
+    use HasFactory;
+    use HasLegalConsent;
+}

tests/TestCase.php

@@ -56,6 +56,9 @@ public function getEnvironmentSetUp($app)
         include_once __DIR__.'/../database/migrations/create_users_table.php.stub';
         (new \CreateUsersTable())->up();
 
+        include_once __DIR__.'/../database/migrations/create_admins_table.php.stub';
+        (new \CreateAdminsTable())->up();
+
         include_once __DIR__.'/../database/migrations/create_legal_consent_tables.php.stub';
         (new \CreateLegalConsentTables())->up();
     }