MoonDocs

Motyw

Niestandardowe pola ​

Zdefiniowane rodzaje niestandardowych pól ​

Dozwolone typy wymienia custom-field-types w Modules/ContentBuilder/Config/config.php:

  • header — nagłówek
  • text — tekst
  • text-image — tekst z obrazkiem
  • youtube
  • image — obrazek
  • file — plik
  • content-link — odnośnik
  • repeater — powtarzalna grupa pól
  • custom-item — wymaga wpisu w custom-sectionable-types, domyślnie pustego

Sekcja współdzielona nie jest typem pola. Może natomiast sama mieć niestandardowe pola — zob. Współdzielone sekcje.

Tworzenie rodzajów niestandardowych pól ​

Tworzenie edytowalnych rodzajów niestandardowych pól ​

Należy stworzyć model, który będzie rozszerzać klasę Modules\ContentBuilder\Models\SectionType.

php
class Text extends SectionType

Następnie należy zdefiniować zasady walidacji w metodzie rules(), wiadomości błędów w metodzie messages() oraz nazwy atrybutów w metodzie attributes().

php
public function rules(): array
{
    return [
        'content' => 'required',
    ];
}

public function messages(): array
{
    return [
        'content.required' => 'pole treść jest wymagane',
    ];
}

public function attributes(): array
{
    return [
        'content' => 'treść',
    ];
}

Opcjonalnym krokiem jest zdefiniowanie publicznej metody sectionData(), która będzie zwracać tablicę zawierającą dane niestandardowych pól. Pełni ona rolę transformera.

php
public function sectionData(): array
{
    return [
        'content' => $this->content,
    ];
}

Domyślnie sectionData() zwraca dane modelu w postaci tablicy, korzystając z metody toArray().

php
public function sectionData(): array
{
    return $this->toArray();
}

Następnie w pliku konfiguracyjnym Modules/ContentBuilder/Config/config.php wewnątrz custom-field-types, należy dodać alias obsługiwanego typu niestandardowego pola.

php
'custom-field-types' => [
    'text',
],

// lub
'custom-field-types' => [
    'text',
],

TIP

Jeśli dane dostępne publicznie powinny różnić się od tych, które zwraca metoda sectionData() należy dodać kolejną metodę o nazwie publicSectionData()zawierającą publiczne dane.

php
public function publicSectionData(): array
{
    return $this->toArray();
}

Tworzenie sekcji na podstawie modelu ​

Model, który ma stanowić nowy rodzaj sekcji musi implementować interfejs Modules\ContentBuilder\Contracts\Sectionable oraz korzystać z trait Modules\ContentBuilder\Traits\Itemable.

Należy zdefiniować metodę o nazwie sectionData(), która zwróci tablicę z danymi, które powinna zawierać sekcja.

php
use Illuminate\Database\Eloquent\Model;
use Modules\ContentBuilder\Traits\Itemable;
use Modules\ContentBuilder\Contracts\Sectionable;

class Page extends Model implements Sectionable
{
    use Itemable;

    public function sectionData(): array
    {
        return [
            'title' => $this->title,
            'slug' => $this->slug,
        ];
    }
}

W pliku konfiguracyjnym Modules/ContentBuilder/Config/config.php wewnątrz custom-field-types należy dodać alias typu sekcji oraz dodatkowo dodać wpis do custom-itemable-types, gdzie kluczem jest typ sekcji, a wartością tablica z klasą kontrolera i jego metodą, która zwróci listę pozycji zawierających identyfikator id oraz wyświetlaną nazwę name.

php
// Modules/ContentBuilder/Config/config.php

'custom-field-types' => [
    'page',
],

'itemable-types' => [
    'page' => [PageController::class, 'getToSelect'],
],
php
class PageController
{
    public function getToSelect(Request $request)
    {
        $builder = $this->page->getBuilder($request);

        return $this->getResponse($builder, PageSelectResource::class);
    }
}
php
class PageSelectResource extends JsonResource
{
    public function toArray($request)
    {
        return [
            'id' => $this->id,
            'name' => $this->title,
        ];
    }
}

Tworzenie sekcji na podstawie klasy ​

Niestandardowe typy sekcji służą do podłączenia dynamicznie wygenerowanych danych. Przykładem takich typów sekcji mogą być najnowsze wpisy bloga, polecane produkty, itd.

W pliku konfiguracyjnym Modules/ContentBuilder/Config/config.php wewnątrz custom-itemable-types należy dodać alias rodzaju sekcji.

php
'custom-itemable-types' => [
    'new-products',
],

Następnie należy stworzyć klasę, która zwróci odpowiednie dane.

php
class ProductService
{
    public function getItemData(array $options = null)
    {
        return ProductResource::collection(
            Product::take(3)->latest()->get()
        );
    }
}

Dodatkowe opcje ​

php
use Modules\Core\Models\Option;

class ProductService
{
    public function options(): array
    {
        return [
            Option::number('count'),
            Option::select('order_by', [
                'asc' => 'Ascending',
                'desc' => 'Descending'
            ]),
        ];
    }
}

Walidacja pól z opcjami ​

Reguły walidacji dla opcji należy zdefiniować poprzez dodanie publicznej metody rules():

php
class ProductService
{
    public function rules(): array
    {
        return [
            'count' => 'integer|min:1',
            'order_by' => 'in:asc,desc|string',
        ];
    }
}

Obsługa niestandardowych pól ​

Dodawanie niestandardowych pól do modelu ​

Dodawanie niestandardowych pól odbywa się poprzez dodanie trait Modules\ContentBuilder\Traits\HasCustomFields do klasy modelu.

php
use Modules\ContentBuilder\Contracts\Sectionable;
use Modules\ContentBuilder\Traits\HasCustomFields;

class Page extends Model implements Sectionable
{
    use HasCustomFields;

    ...
}

Walidacja ​

Obsługa walidacji dla niestandardowych pól polega na dodaniu trait Modules\ContentBuilder\Traits\HasCustomFieldsRules do klasy rozszerzającej Modules\Core\Http\Requests\BaseFormRequest.

Uwaga

Roszerzenie klasy BaseFormRequest pozwala wykonać funkcję wewnątrz zaimplementowanego trait, której nazwa jest konkatenacją słowa validate oraz nazwy implementowanego trait.

php
use Modules\Core\Http\Requests\BaseFormRequest;
use Modules\ContentBuilder\Traits\HasCustomFieldsRules;

class CreatePageRequest extends BaseFormRequest
{
    use HasCustomFieldsRules;
}

Wyświetlanie niestandardowych pól ​

Niestandardowe pola modelu można załadować korzystając z metody loadCustomFields(), która jest zdefiniowana wewnątrz trait HasCustomFields.

php
public function show(Page $page)
{
    $page->loadCustomFields();

    return response()->json(new PageResource($page));
}

Następnie należy skorzystać z transformera CustomFieldResource, który zwróci dane niestandardowych pól.

php
use Modules\Media\Traits\HasLoadedCustomFields;
use Illuminate\Http\Resources\Json\JsonResource;
use Modules\ContentBuilder\Http\Transformers\PublicCustomFieldResource;

class PageResource extends JsonResource
{
    use HasLoadedCustomFields;
    
    public function toArray($request)
    {
        return [
            // wewnątrz panelu CMS
            'custom_fields' => $this->loadedCustomFields(),

            // w przypadku publicznych treści
            'custom_fields' => $this->loadedCustomFields(PublicCustomFieldResource::class),
        ];
    }
}

Współdzielone sekcje ​

Backend obsługuje custom_fields również w modelu SharedSection: model korzysta z HasCustomFields, a żądania tworzenia i aktualizacji używają HasCustomFieldsRules. Zasób administracyjny zwraca pola przez loadedCustomFields(), a PublicSharedSectionResource używa PublicCustomFieldResource. Szczegóły znajdują się w Modules/ContentBuilder/Models/SharedSection.php, Http/Requests/CreateSharedSectionRequest.php, Http/Requests/UpdateSharedSectionRequest.php i Http/Transformers/.

Typ pola musi być dozwolony w content-builder.custom-field-types; schemat slugów jest deklarowany po stronie panelu. Instrukcja rejestracji pól w panelu: Custom fields.

Made by Moonbite