add support to all relation field types

dcasia · Oct 3, 2019 · 881c3b6 · 881c3b6
1 parent 664a99a
commit 881c3b6
Show file tree

Hide file tree

Showing 3 changed files with 108 additions and 21 deletions.
diff --git a/dist/js/field.js b/dist/js/field.js
diff --git a/resources/js/components/DetailField.vue b/resources/js/components/DetailField.vue
@@ -4,15 +4,20 @@
 
         <panel :panel="{ name: field.value, fields: standardFields }"/>
 
-        <resource-index v-for="(hasOneField, index) of hasOneFields"
-                        :key="index"
-                        :field="hasOneField"
-                        :resource-name="hasOneField.resourceName"
-                        :via-resource="hasOneField.inlineMorphTo.viaResource"
-                        :via-resource-id="hasOneField.inlineMorphTo.viaResourceId"
-                        :via-relationship="hasOneField.hasOneRelationship"
-                        :relationship-type="'hasOne'"
-                        :load-cards="false"/>
+        <template v-for="({type, fields}) of relationalFields">
+
+            <resource-index v-for="(relationField, index) of fields"
+                            :key="index"
+                            :field="relationField"
+                            :resource-name="relationField.resourceName"
+                            :via-resource="relationField.inlineMorphTo.viaResource"
+                            :via-resource-id="relationField.inlineMorphTo.viaResourceId"
+                            :via-relationship="relationField[`${type}Relationship`]"
+                            :relationship-type="type"
+                            :load-cards="false"
+                            class="mb-6"/>
+
+        </template>
 
     </div>
 
@@ -26,14 +31,27 @@
         props: ['resource', 'resourceName', 'resourceId', 'field'],
         mixins: [ReplaceValueWithLabel],
         computed: {
-            hasOneFields() {
+            relationalFields() {
 
-                return this.fields.filter(field => field.component === 'has-one-field')
+                return [
+                    {
+                        type: 'hasOne',
+                        fields: this.fields.filter(field => field.component === 'has-one-field')
+                    },
+                    {
+                        type: 'hasMany',
+                        fields: this.fields.filter(field => field.component === 'has-many-field')
+                    },
+                    {
+                        type: 'belongsToMany',
+                        fields: this.fields.filter(field => field.component === 'belongs-to-many-field')
+                    }
+                ]
 
             },
             standardFields() {
 
-                return this.fields.filter(field => field.component !== 'has-one-field')
+                return this.fields.filter(field => !['has-one-field', 'has-many-field', 'belongs-to-many-field'].includes(field.component))
 
             },
             fields() {

diff --git a/src/InlineMorphTo.php b/src/InlineMorphTo.php
@@ -5,10 +5,15 @@
 use App\Nova\Resource;
 use Illuminate\Database\Eloquent\Model;
 use Illuminate\Support\Arr;
+use Illuminate\Support\Collection;
 use Illuminate\Support\Str;
+use Laravel\Nova\Fields\BelongsToMany;
 use Laravel\Nova\Fields\Field;
-use Laravel\Nova\Fields\ID;
-use Laravel\Nova\Fields\MorphOne;
+use Laravel\Nova\Fields\HasMany;
+use Laravel\Nova\Fields\HasOne;
+use Laravel\Nova\Http\Controllers\ResourceIndexController;
+use Laravel\Nova\Http\Controllers\ResourceShowController;
+use Laravel\Nova\Http\Controllers\UpdateFieldController;
 use Laravel\Nova\Http\Requests\NovaRequest;
 use Laravel\Nova\Nova;
 use ReflectionClass;
@@ -61,15 +66,16 @@ public function types(array $types): self
 
         $types = collect($types)->map(function (string $resource, $key) use ($useKeysAsLabel) {
 
-            $fields = (new $resource($resource::newModel()))->fields(app(NovaRequest::class));
+            /**
+             * @var Resource $resourceInstance
+             */
+            $resourceInstance = new $resource($resource::newModel());
 
             return [
                 'className' => $resource,
                 'uriKey' => $resource::uriKey(),
                 'label' => $useKeysAsLabel ? $key : $this->convertToHumanCase($resource),
-                'fields' => collect($fields)->reject(function ($field) {
-                    return $field instanceof ID;
-                })->toArray()
+                'fields' => $this->resolveFields($resourceInstance)
             ];
 
         });
@@ -80,6 +86,37 @@ public function types(array $types): self
 
     }
 
+    private function resolveFields(Resource $resourceInstance): Collection
+    {
+
+        /**
+         * @var NovaRequest $request
+         */
+        $request = app(NovaRequest::class);
+        $controller = $request->route()->controller;
+
+        if ($controller instanceof UpdateFieldController) {
+
+            return $resourceInstance->updateFields($request);
+
+        }
+
+        if ($controller instanceof ResourceShowController) {
+
+            return $resourceInstance->detailFields($request);
+
+        }
+
+        if ($controller instanceof ResourceIndexController) {
+
+            return $resourceInstance->indexFields($request);
+
+        }
+
+        return $resourceInstance->availableFields($request);
+
+    }
+
     private function convertToHumanCase(string $resource): string
     {
         return Str::title(str_replace('_', ' ', Str::snake((new ReflectionClass($resource))->getShortName())));
@@ -107,7 +144,9 @@ protected function resolveAttribute($resource, $attribute)
 
             foreach ($fields as $field) {
 
-                if ($field instanceof MorphOne) {
+                if ($field instanceof HasOne ||
+                    $field instanceof HasMany ||
+                    $field instanceof BelongsToMany) {
 
                     $field->meta[ 'inlineMorphTo' ] = [
                         'viaResourceId' => $relationInstance->id,
@@ -164,11 +203,41 @@ public function fill(NovaRequest $request, $model)
 
     }
 
-    private function getFields(Model $model): array
+    private function getFields(Model $model): Collection
     {
         $resourceClass = Nova::resourceForModel($model);
 
         return $this->meta[ 'resources' ]->where('className', $resourceClass)->first()[ 'fields' ];
     }
 
+    public function jsonSerialize()
+    {
+
+        /**
+         * @var NovaRequest $request
+         */
+        $request = app(NovaRequest::class);
+        $originalResource = $request->route()->resource;
+
+        /**
+         * Temporarily remap the route resource key so every sub field thinks it's being resolved by it's original parent
+         */
+        foreach ($this->meta[ 'resources' ] as $resource) {
+
+            $resource[ 'fields' ] = $resource[ 'fields' ]->transform(function (&$field) use ($request, $resource) {
+
+                $request->route()->setParameter('resource', $resource[ 'uriKey' ]);
+
+                return $field->jsonSerialize();
+
+            });
+
+        }
+
+        $request->route()->setParameter('resource', $originalResource);
+
+        return parent::jsonSerialize();
+
+    }
+
 }