Niestandardowe pola

Zdefiniowane rodzaje niestandardowych pól

• Tekst
• Obrazek
• Tekst z obrazkiem
• Youtube
• 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.

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().

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.

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

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

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.

'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.

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.

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.

// Modules/ContentBuilder/Config/config.php

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

'itemable-types' => [
    'page' => [PageController::class, 'getToSelect'],
],

class PageController
{
    public function getToSelect(Request $request)
    {
        $builder = $this->page->getBuilder($request);

        return $this->getResponse($builder, PageSelectResource::class);
    }
}

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.

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

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

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

Dodatkowe opcje

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():

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.

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.

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.

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.

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),
        ];
    }
}