Action class chunks target models to 200, thats makes hard to get the action details

[tufankilicaslan]

• Laravel Version: 5.7.16
• Nova Version: 1.2.0
• PHP Version: 7.2.10

Description:

When running a nova action, target models chunks into per 200 records, and we have no way to group action models nor understand total amount of the data from Action class. So if we want to do some operation after all actions completed, there is no way to understand this. And there is no way to get total models count in Action class before or after action run.

Steps To Reproduce:

• Create a sample resource / model with above 200 records.
• Create a simple action class (doesn't matter queued or sync action)

    /**
     * Perform the action on the given models.
     *
     * @param  \Laravel\Nova\Fields\ActionFields  $fields
     * @param  \Illuminate\Support\Collection  $models
     * @return mixed
     */
    public function handle(ActionFields $fields, Collection $models)
    {
        \Log::info("action called with batchId:".$this->batchId);
    }

• Run the action, and check the log file.
• You will see different batchIds creating for each 200 models and we have no way to find the relation between each batchId.

Possible solutions:

@davidhemphill we should access something like this: $this->modelCount , $this->totalChunks, $this->currentChunk similar to pagination module. So we can understand the operation details and total action models count.

[tylernathanreed]

@tufankilicaslan

I've solved this issue in other Laravel (but non-Nova) projects by having the following design:

1) You have a top-level "Action" job
2) You have a child-level "Action Chunk" job
3) You have a tracking table for top-level "Actions"
4) You have a separate tracking table for child-level "Action Chunk"

Then, when each "chunk" completes, you have additional logic at the tail-end of the job that asks, "Am I the last job?", if so, mark my parent as completed.

You end up with the following status matrix:

Action

• Dispatched (In the job queue)
• Reserved (Actively being worked on)
• Released (Top-level job has finished)
• Failed (Top-level job has failed)
• Completed (Top-level job and all chunks have completed)

Action Chunk

• Dispatched (In the job queue)
• Reserved (Actively being worked on)
• Released (Job has finished)
• Failed (Job has failed)

Essentially, an Action is marked as completed under the following scenarios:

• The job itself is released, and no chunks were created
• The final chunk is released
• The final chunk fails

Here's a screenshot from one of the Laravel applications where we built a "Bulk Actions" architecture, which is fairly similar to Nova's Action architecture:

(If this link stops working, here's the dropbox link)

But essentially, you can see the high level results for each "Bulk Action" (which in Nova, would be a single action execution). We stored the results of chunks and records (which is what happened to the individual resource).

We also have a "Rejected" status, which could also be used in Nova. We "reject" a record with it was not actually authorized for the request (like trying to activate a user that is already active).

I'm not certain how much of an overhaul would be required to get Nova's Action architecture to be able to present information like this, but honestly, it would be super useful.

[tufankilicaslan]

@tylernathanreed thanks for the detailed information.

In my nova project, I am using main "jobs" table to store the job details, and job_queues table to store each queue information and result. each queue belongs to a job. i am using my own scheduling mechanism. users able to schedule a job on front-end. but when i try to create a job using nova "action" , it chunks to 200, since i do not know the selected total model count and the actions models not grouped , i am not able to schedule the task well, and have to create separate "job" for each 200 records. i can put a unique field in action fields to understand and group the job, but it would be better we can know about the total model count, the main job id from the Action class itself.

i think so, it will be super useful if we can group by actions, in a top level table, and the chunks , that you explained.

[tylernathanreed]

@tufankilicaslan

Yeah, one of the constraints that we had to enforce in this architecture (for when multiple listeners are running), is that a chunk cannot begin work until the main job has finished dispatching all of the chunks.

But this distinction between "main" and "chunk" doesn't really exist in Nova, which I believe we both agree that this is the problem.

[rominronin]

Was there any update or progress on this issue? I wrote an excel exporter action that is being limited by chunking (it exports data in the last chunk with >200 records).

[cchsu23]

Fixed? I have the same problem, too by using queued actions.

[jbrooksuk]

This issue relates to an unsupported version of Nova. If you're still experiencing this in the latest version of Nova, please open a new ticket, thanks!

[JesperFiltenborg]

Was this ever fixed Currently I'm running 4.32.12 and I cant find a way to run the action without nova splitting it up into chunks of 200....

[tylernathanreed]

@JesperFiltenborg This might be possible in Nova 4 using standalone actions, and you just grab the models you need internally.

If you can't figure it out, then open a new issue. This thread is for an unsupported version of Nova.

[m9tdev]

I've overridden the $chunkCount field in the Action definition like this:

class ExportExcel extends Action
{
  public static $chunkCount = 10000;
  ...rest of you action code...
}

Which does the trick for me. Just set it to an amount that is way bigger than the amount you ever need.

[HugoHeneault]

Looking at Nova's code you can use dispatchRequestUsing in your action to avoid the whole models querying.

You just have to override it and use $request to get your resources ids.

<?php
class ResendCardEnrollmentEmail extends Action
{
    use InteractsWithQueue;
    use Queueable;

    protected function dispatchRequestUsing(ActionRequest $request, Response $response, ActionFields $fields): Response
    {
        $ids = $request->get('resources');

        throw_if(empty($ids), 'No resource selected.', ResponseHttp::HTTP_UNPROCESSABLE_ENTITY);

        $cardQuery = Card::query();

        // if all cards are selected, nova returns 'all' instead of an array of ids
        // so we only have to filter if it's not 'all'
        if ($ids !== 'all') {
            $cardQuery->whereIn('ulid', $ids);
        }

        // do not load each model individually, just get the ids
        $cardsIdsToDispatch = $cardQuery->pluck('ulid');

        // Do the heavy work now

        // Then return response
        return $response->successful(ActionResponse::message($cardsIdsToDispatch->count() . ' resources handled');
   }
}

This should be documented in nova docs as its quite useful.