forceDelete method fires both deleted and forceDeleted event

[johnylemon]

I am curious what is the reason behind decision of firing deleted event during both delete and forceDelete action.

Where is my problem:

When user deletes his account, deleted_at is filled with current date, (softDeletes trait handles that for me).
Next the deleted event from UserObserver class is fired, where I am firing next event with queued listener, doing some cleanup logic. This may take some time.

Then, from this listener I would like to remove user record entirely using forceDelete method.
But both deleted and forceDeleted events are fired. So my cleanup process will be fired again.

I think this behavior may be corrected

[Muhammad-Sarfaraz]

Can you show me/us your code

[johnylemon]

no problem. But I will use example for files (named items) that users can upload etc.

Flow:

• Item is deleted
• deleted_at is set, so it is no more searchable
• ItemObserver@deleted fires custom ItemDeleted event with queued listener
• listener will do some cleanup: removes files from storage(s), blah blah
• after cleanup this item sholud be removed from the database, because we dont need that anymore, or will be left in the db and still marked as deleted if for some reason we have to keep this record for future use.

Code snippets

ItemObserver

<?php

namespace App\Observers;

use App\Models\Item;
use App\Events\ItemDeleted;

class ItemObserver
{
    public function deleted(Item $item)
    {
        //
        // fire async event
        //
        event(new ItemDeleted($item->id));
    }

    public function forceDeleted(Item $item)
    {
        // maybe some logic here
    }
}

App\Events\ItemDeletedListener (handles App\Models\ItemDeleted event)

<?php

namespace App\Listeners;

use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Queue\InteractsWithQueue;

use App\Events\ItemDeleted;
use App\Models\Item;

class ItemDeletedListener implements ShouldQueue
{
    /**
     * Handle the event.
     *
     * @param  App\Events\ItemDeleted  $event
     * @return void
     */
    public function handle(ItemDeleted $event)
    {
        $item = Item::withTrashed()->find($event->modelId);

        if(!$item)
            return;

        //
        // remove assets
        //
        if($item->assets)
            $item->assets->each->delete();
        
        //
        // some more logic here that may take some time
        // and thats why I like to fire such events in my apps
        //

        if(!$item->shouldBeKept())
        {
            //
            // here is the problem. 
            // The `forceDelete` method calls `delete` under the hood 
            // so `ItemObserver@delete` will be called again firing `App\Events\ItemDeleted` event
            //
            $item->forceDelete(); 
        }
    }
}

Of course I can do something like that in ItemObserver@delete

?php

namespace App\Observers;

use App\Models\Item;
use App\Events\ItemDeleted;

class ItemObserver
{
    public function deleted(Item $item)
    {
        // 
        // fire `ItemDeleted` event only if not coming from `forceDelete` method call
        //
        if(!$item->trashed())
            event(new ItemDeleted($item->id));
    }
}

but the problem I am talking about is that forceDelete method should not trigger ItemObserver@deleted method, because it was called and handled during initial soft deleting process.

[Sophist-UK]

My own view is that:

1. For non softDelete models, both the deleted event and then the forceDeleted event should be fired when the record is deleted.

2. For softDelete models, the deleted event should be fired when the record is soft-deleted, and the forceDeleted even when the record is hard-deleted.

The rationale for this that the deleted event represents when the record is no longer visible (but remains in the table and so e.g. foreign-keys remain valid, whilst the forceDeleted event represents when the record is physically deleted, and so foreign-key clean-up may be required.

[shehi]

The event you are searching for is trashed. deleted event is triggered during forceDeleted as well.