[WIP] add method to get ajax uploaders

src/app/Library/CrudPanel/Traits/FieldsProtectedMethods.php

@@ -277,6 +277,8 @@ protected function makeSureSubfieldsHaveNecessaryAttributes($field)
             $subfield['name'] = Str::replace(' ', '', $subfield['name']);
 
             $subfield['parentFieldName'] = $field['name'];
+            $subfield['baseFieldName'] = is_array($subfield['name']) ? implode(',', $subfield['name']) : $subfield['name'];
+            $subfield['baseFieldName'] = Str::afterLast($subfield['baseFieldName'], '.');
 
             if (! isset($field['model'])) {
                 // we're inside a simple 'repeatable' with no model/relationship, so
@@ -290,8 +292,6 @@ protected function makeSureSubfieldsHaveNecessaryAttributes($field)
                 $currentEntity = $subfield['baseEntity'] ?? $field['entity'];
                 $subfield['baseModel'] = $subfield['baseModel'] ?? $field['model'];
                 $subfield['baseEntity'] = isset($field['baseEntity']) ? $field['baseEntity'].'.'.$currentEntity : $currentEntity;
-                $subfield['baseFieldName'] = is_array($subfield['name']) ? implode(',', $subfield['name']) : $subfield['name'];
-                $subfield['baseFieldName'] = Str::afterLast($subfield['baseFieldName'], '.');
             }
 
             $field['subfields'][$key] = $this->makeSureFieldHasNecessaryAttributes($subfield);

src/app/Library/Uploaders/Support/UploadersRepository.php

@@ -2,7 +2,9 @@
 
 namespace Backpack\CRUD\app\Library\Uploaders\Support;
 
+use Backpack\CRUD\app\Library\CrudPanel\CrudPanelFacade as CRUD;
 use Backpack\CRUD\app\Library\Uploaders\Support\Interfaces\UploaderInterface;
+use Illuminate\Support\Str;
 
 final class UploadersRepository
 {
@@ -119,4 +121,73 @@ public function getRegisteredUploadNames(string $uploadName): array
             return $uploader->getName();
         }, $this->getRepeatableUploadersFor($uploadName));
     }
+
+    /**
+     * Get the uploaders classes for the given group of uploaders.
+     */
+    public function getAjaxUploadTypes(string $uploaderMacro = 'withFiles'): array
+    {
+        $ajaxFieldTypes = [];
+        foreach ($this->uploaderClasses[$uploaderMacro] as $fieldType => $uploader) {
+            if (is_a($uploader, 'Backpack\Pro\Uploads\BackpackAjaxUploader', true)) {
+                $ajaxFieldTypes[] = $fieldType;
+            }
+        }
+
+        return $ajaxFieldTypes;
+    }
+
+    /**
+     * Get an uploader instance for a given crud object.
+     */
+    public function getFieldUploaderInstance(string $requestInputName): UploaderInterface
+    {
+        if (strpos($requestInputName, '#') !== false) {
+            $repeatableContainerName = Str::before($requestInputName, '#');
+            $requestInputName = Str::after($requestInputName, '#');
+            $uploaders = $this->getRepeatableUploadersFor($repeatableContainerName);
+            //TODO: Implement the logic for repeatable uploaders
+            dd('here');
+        }
+
+        if (empty($crudObject = CRUD::fields()[$requestInputName])) {
+            abort(500, 'Could not find the field in the CRUD fields.');
+        }
+
+        if (! $uploaderMacro = $this->getUploadCrudObjectMacroType($crudObject)) {
+            abort(500, 'There is no uploader defined for the given field type.');
+        }
+
+        if (! $this->isValidUploadField($crudObject, $uploaderMacro)) {
+            abort(500, 'Invalid field for upload.');
+        }
+
+        $uploaderConfiguration = $crudObject[$uploaderMacro] ?? [];
+        $uploaderConfiguration = ! is_array($uploaderConfiguration) ? [] : $uploaderConfiguration;
+        $uploaderClass = $this->getUploadFor($crudObject['type'], $uploaderMacro);
+
+        return new $uploaderClass(['name' => $requestInputName], $uploaderConfiguration);
+    }
+
+    /**
+     * Get the upload field macro type for the given object.
+     */
+    private function getUploadCrudObjectMacroType(array $crudObject): string
+    {
+        return isset($crudObject['withFiles']) ? 'withFiles' : ($crudObject['withMedia'] ? 'withMedia' : null);
+    }
+
+    private function isValidUploadField($crudObject, $uploaderMacro)
+    {
+        if (Str::contains($crudObject['name'], '#')) {
+            $container = Str::before($crudObject['name'], '#');
+            $field = array_filter(CRUD::fields()[$container]['subfields'] ?? [], function ($item) use ($crudObject, $uploaderMacro) {
+                return $item['name'] === $crudObject['name'] && in_array($item['type'], $this->getAjaxUploadTypes($uploaderMacro));
+            });
+
+            return ! empty($field);
+        }
+
+        return in_array($crudObject['type'], $this->getAjaxUploadTypes($uploaderMacro));
+    }
 }

src/app/Library/Validation/Rules/BackpackCustomRule.php

@@ -2,18 +2,21 @@
 
 namespace Backpack\CRUD\app\Library\Validation\Rules;
 
+use Backpack\CRUD\app\Library\Validation\Rules\Support\ValidateArrayContract;
 use Closure;
 use Illuminate\Contracts\Validation\DataAwareRule;
 use Illuminate\Contracts\Validation\Rule;
 use Illuminate\Contracts\Validation\ValidationRule;
 use Illuminate\Contracts\Validation\ValidatorAwareRule;
+use Illuminate\Http\UploadedFile;
+use Illuminate\Support\Arr;
 use Illuminate\Support\Facades\Validator;
+use Illuminate\Support\Str;
 
-/**
- * @method static static itemRules()
- */
 abstract class BackpackCustomRule implements ValidationRule, DataAwareRule, ValidatorAwareRule
 {
+    use Support\HasFiles;
+
     /**
      * @var \Illuminate\Contracts\Validation\Validator
      */
@@ -30,6 +33,12 @@ public static function field(string|array|ValidationRule|Rule $rules = []): self
         $instance = new static();
         $instance->fieldRules = self::getRulesAsArray($rules);
 
+        if ($instance->validatesArrays()) {
+            if (! in_array('array', $instance->getFieldRules())) {
+                $instance->fieldRules[] = 'array';
+            }
+        }
+
         return $instance;
     }
 
@@ -43,7 +52,18 @@ public static function field(string|array|ValidationRule|Rule $rules = []): self
      */
     public function validate(string $attribute, mixed $value, Closure $fail): void
     {
-        // is the extending class reponsability the implementation of the validation logic
+        $value = $this->ensureValueIsValid($value);
+
+        if ($value === false) {
+            $fail('Invalid value for the attribute.')->translate();
+
+            return;
+        }
+
+        $errors = $this->validateOnSubmit($attribute, $value);
+        foreach ($errors as $error) {
+            $fail($error)->translate();
+        }
     }
 
     /**
@@ -96,19 +116,118 @@ protected static function getRulesAsArray($rules)
         return $rules;
     }
 
+    protected function ensureValueIsValid($value)
+    {
+        if ($this->validatesArrays() && ! is_array($value)) {
+            try {
+                $value = json_decode($value, true) ?? [];
+            } catch(\Exception $e) {
+                return false;
+            }
+        }
+
+        return $value;
+    }
+
+    private function validatesArrays(): bool
+    {
+        return is_a($this, ValidateArrayContract::class);
+    }
+
+    private function validateAndGetErrors(string $attribute, mixed $value, array $rules): array
+    {
+        $validator = Validator::make($value, [
+            $attribute => $rules,
+        ], $this->validator->customMessages, $this->validator->customAttributes);
+
+        return $validator->errors()->messages()[$attribute] ?? [];
+    }
+
+    protected function getValidationAttributeString(string $attribute)
+    {
+        return Str::substrCount($attribute, '.') > 1 ?
+                Str::before($attribute, '.').'.*.'.Str::afterLast($attribute, '.') :
+                $attribute;
+    }
+
+    protected function validateOnSubmit(string $attribute, mixed $value): array
+    {
+        return $this->validateRules($attribute, $value);
+    }
+
+    protected function validateFieldAndFile(string $attribute, null|array $data = null, array|null $customRules = null): array
+    {
+        $fieldErrors = $this->validateFieldRules($attribute, $data, $customRules);
+        $fileErrors = $this->validateFileRules($attribute, $data);
+
+        return array_merge($fieldErrors, $fileErrors);
+    }
+
     /**
      * Implementation.
      */
-    public function validateFieldRules(string $attribute, mixed $value, Closure $fail): void
+    public function validateFieldRules(string $attribute, null|array|UploadedFile $data = null, array|null $customRules = null): array
     {
-        $validator = Validator::make([$attribute => $value], [
-            $attribute => $this->getFieldRules(),
-        ], $this->validator->customMessages, $this->validator->customAttributes);
+        $data = $data ?? $this->data;
+        $validationRuleAttribute = $this->getValidationAttributeString($attribute);
+
+        $data = $this->prepareValidatorData($data, $attribute);
+
+        return $this->validateAndGetErrors($validationRuleAttribute, $data, $customRules ?? $this->getFieldRules());
+    }
 
-        if ($validator->fails()) {
-            foreach ($validator->errors()->messages()[$attribute] as $message) {
-                $fail($message)->translate();
+    protected function prepareValidatorData(array|UploadedFile $data, string $attribute): array
+    {
+        if ($this->validatesArrays() && is_array($data)) {
+            return Arr::has($data, $attribute) ? $data : [$attribute => Arr::get($data, $attribute)];
+        }
+
+        return [$attribute => $data];
+    }
+
+    protected function validateFileRules(string $attribute, mixed $data): array
+    {
+        $data = $data ?? $this->data;
+        $items = is_array($data) && array_key_exists($attribute, $data) ? $data[$attribute] : $data;
+        $items = is_array($items) ? $items : [$items];
+        $errors = [];
+        // we validate each file individually to avoid returning messages like: `field.0` is not a pdf.
+        foreach ($items as $sentFiles) {
+            if (! is_array($sentFiles)) {
+                try {
+                    if (is_file($sentFiles)) {
+                        $errors[] = $this->validateAndGetErrors($attribute, [$attribute => $sentFiles], $this->getFileRules());
+                    }
+                    continue;
+                } catch(\Exception) {
+                    $errors[] = 'Unknown datatype, aborting upload process.';
+                    break;
+                }
+            }
+
+            if (is_multidimensional_array($sentFiles)) {
+                foreach ($sentFiles as $key => $value) {
+                    foreach ($value[$attribute] as $file) {
+                        if (is_file($file)) {
+                            $errors[] = $this->validateAndGetErrors($attribute, [$attribute => $file], $this->getFileRules());
+                        }
+                    }
+                }
+                continue;
+            }
+
+            foreach ($sentFiles as $key => $value) {
+                if (is_file($value)) {
+                    $errors[] = $this->validateAndGetErrors($attribute, [$attribute => $value], $this->getFileRules());
+                }
             }
         }
+
+        return array_unique(array_merge(...$errors));
+    }
+
+    public function validateRules(string $attribute, mixed $value): array
+    {
+        return $this->validateFieldAndFile($attribute, $value);
     }
 }

src/app/Library/Validation/Rules/Support/ValidateArrayContract.php

@@ -0,0 +1,7 @@
+<?php
+
+namespace Backpack\CRUD\app\Library\Validation\Rules\Support;
+
+interface ValidateArrayContract
+{
+}