How to validate fields in a repeatable type?

[astarialexi]

Currently I have a module that can add a user with fields name and email one at a time. But now we changed it so we can add multiple users at once so I used a repeatable field type.

I was adding the validation at class UserRequest extends FormRequest here:

public function rules()
    {
        return [
             'name' => 'required',
             'email' => 'required|email|unique:users,email',
        ];
        
    }

So how can I validate the fields in a repeatable type?

[pxpm]

Repeatable sends the value as a json string. You can ovewrite the create() method in your CrudController, intercept the request and manualy validate and create the users.

Something along this lines (this is pseudo, not tested but should get you working..) :

use Illuminate\Support\Facades\Validator;
use \Backpack\CRUD\app\Http\Controllers\Operations\CreateOperation { store as traitStore; }

...

    public function store()
    {
        $this->crud->hasAccessOrFail('create');

        $users_to_add = json_decode(request()->get('your_repeatable_field'));

        foreach($users_to_add as $user) {
            Validator::make($user, ['email' => 'required|min:5', 'name' => 'required'])->validate();
        }

        // if we are here there is no validator errors, otherwise we would be redirected back with errors.
       // mass create your users, or create them individually inside the foreach loop 

        \Alert::success(trans('backpack::crud.insert_success'))->flash();

       return redirect()->back();

    }

About the validating part ... atm is not possible to figure out which one of the names failed in the repeatable field.

It would get you back with like: Field 'name' is required but does not specify which one of them are the one with the error.

More on field functions override here: https://backpackforlaravel.com/docs/4.1/crud-operation-create#callbacks

Best,
Pedro

[lordjack]

Thanks for your tip @pxpm , with it I was able to validate the fields of the Repeatable form.

The format I did was this, I want to share, if someone also needs it.

use Illuminate\Support\Facades\Validator;

public function store()
{
    $item = $this->crud->create($this->crud->getRequest()->except(['save_action', '_token', '_method']));

    $products = json_decode($this->crud->getRequest()->input('products'));

    $this->validateRepeatableFields($products);

    if (is_array($products)) {

        foreach ($products  as $itens) {

            $obj = new ItensProduct();
            $obj->sale_id =  $item->getKey();
            $obj->product_id = $itens->product_id;
            $obj->quantity  = $itens->quantity;
            $obj->save();

            $categoryProduct = json_decode($itens->categories);

            foreach ($categoryProduct  as $cItens) {
                $objCat = new CategoryProduct();
                $objCat->product_id = $obj->getKey();
                $objCat->name = $cItens;
                $objCat->save();
            }
        }
    } else {
        \Alert::add('warning', '<b>Preencha os campos de pelo menos um produto.</b>')->flash();
        return redirect('admin/sales/create');
    }
    \Alert::success(trans('backpack::crud.insert_success'))->flash();
    return redirect('admin/sales');
}



function validateRepeatableFields($products)
{
    foreach ($products as $group) {
        Validator::make((array)$group, [
            'sale_id' => 'required',
            'product_id' => 'required',
            'quantity' => 'required',
        ], [
            "product_id.required" => "O campo Produto é obrigatório",
            "quantity.required" => "O campo quantidade é obrigatório",
        ])->validate();
    }
}

[tabacitu]

I agree with @pxpm 's answer here, it should do just fine, but I think there's a more elegant way to go about it.

Personally I think it's better to keep all validation in one place, and I don't see any reason not to add validation logic to the existing FormRequest. That's where the normal validation happens, that's where the repeatable validation should also happen, in my opinion.

I've just created a simple example on how to validate the first repeatable field inside our demo's DummyCrudController. This works well inside DummyRequest, for example:

    public function rules()
    {
        return [
            'name'        => 'required|min:5|max:255',
            'description' => 'required',
            'simple' => function($attribute, $value, $fail) {
                  $fieldGroups = json_decode($value);

                  // allow repeatable field group to be empty
                  if (count($fieldGroups) == 0) {
                    return true;
                  }

                  // run through each field group inside the repeatable field
                  // and run a custom validation for it
                  foreach ($fieldGroups as $key => $group) {
                        $fieldGroupValidator = Validator::make((array)$group, [
                            'text' => 'required|min:10|max:255',
                            'email' => 'required|email',
                        ]);

                        if ($fieldGroupValidator->fails())
                        {
                            // dd($fieldGroupValidator->errors());
                            return $fail('One of the entries in the '.$attribute.' group is invalid.');
                        }
                   }
               },
        ];
    }

The code above does have one downside, though. When something is invalid inside a field group, the ENTIRE field group is flagged as being invalid:

Which... might not be what you're looking for. Obviously this could be further customized and we could parse $fieldGroupValidator->errors() to see exactly which fields inside repeatable failed, and use that inside the custom error message, but yeah. For most use cases though, I believe this approach, or a combination of the two approaches, should do just fine.

I'd love to have a definitive guide on how to do this properly... I think this is a pretty cool problem to solve, I've had fun 😆

[tabacitu]

Hmmm... maybe the least we could do is implement this example above (or a complete one) inside the demo? At least we'd have a working example, even if we don't have a guide for it yet.

[aberaldo]

@tabacitu Is there a solution for this?
What i need is view which field cause the error. And also see in the UI which fields are required or not.

[aberaldo]

@tabacitu @pxpm i think this should be fixed. Its really anoying for a user that all the repeatable field flaged as invalid. Any idea on how to solve?

[aberaldo]

@tabacitu @pxpm i made sth like this in the request

'order_invoice_rules_data' => function ($attribute, $value, $fail) {
$fieldGroups = json_decode($value);
foreach ($fieldGroups as $key => $group) {
    $fieldGroupValidator = Validator::make((array) $group, [
        'order_services[]'  => 'required|min:1|max:255',
        'invoice_moment_id'  => 'required|min:1|max:255',
        'inc_id'  => 'required|min:1|max:255',
        'invoice_description'  => 'required|min:1|max:255',
    ], $this->messages())->validate();
}

The result

But showing * as required in labels and which fields are invalid (marked with red border ) i think is fixed in repeatable blade file. Im right?

[pxpm]

Hello @aberaldo

Thanks for sharing your solution. You can configure your repeatable fields to show the red astherisk by setting up the wrapper class required:

'wrapperAttributes' => [
    'class' => 'form-group col-md-6 required',
],

We still don't have a non-hacky solution for knowing exactly which row triggered the error.

Well technically we could know by getting the key in the validation loop that failed and then have some kind of script that would find the "X" row and mark it with error.

I didn't test this, not sure it could be implemented at all, I think it could work like that, but never tried.