Tipos de campo generales

Belich, dispone de una amplia lista de campos predefinidos. Los hemos divido en dos tipos, los genéricos (que son de los que hablaremos en este punto), y los específicos, los cuales, por su complejidad o peculiaridades, los hemos confinado su propia sección.

Los campos específicos soportados por Belich, son:

Los campos genéricos soportados por Belich, son:

  • Boolean
  • Color
  • Coordenates
  • Countries
  • Date
  • Decimal
  • Email
  • Header
  • Hidden
  • Id
  • Markdown
  • Number
  • Range
  • Select
  • Text
  • TextArea
  • Time
  • Password
  • PasswordConfirmation
  • Year

Cada campo, puede disponer de métodos exclusivos para cada uno de ellos. A continuación, vamos a explicar estos métodos genéricos, uno por uno.

Todos los campos que admiten decimales: Decimal(), Number() o Coordenates(), utilizan la etiqueta <html lang="en"> de la cabecera de la web, para utilizar el separador adecuado: coma o punto.

Campo Boolean

Nos permite generar un checkbox que admite los valores: verdadero o falso.

Boolean example - 1

fig 1: Ejemplo de campo boleano

Este campo se visualiza en las vistas index y show de la siguiente forma:

Boolean example - 2

fig 2: Ejemplo de campo boleano

Pero a veces nos interesa que en estas vistas (index y show), en vez de mostrarle un valor activo o no, se muestre un texto para cuando está activo y otro para cuando esta desactivado. Veamos un ejemplo:

use Daguilarm\Belich\Fields\Types\Boolean;

/**
 * Get the fields displayed by the resource.
 *
 * @param  \Illuminate\Http\Request  $request
 * @return Illuminate\Support\Collection
 */
public function fields(Request $request) {
    return [
        Boolean::make('Status', 'status')
            ->trueValue('on')
            ->falseValue('off'),
    ];
}

Si ambos métodos no tienen un valor asignado, no se mostrará ninguno de los dos.

Este campo se guarda automáticamente como bool. Puede consultar la sección Tipos para modificar esto.

Se puede seleccionar el color del campo, el sistema solo permite los colores: green, blue y red, el valor por defecto es green. La variable color, puede asignarse de la siguiente forma:

Boolean::make('Status', 'status')
    ->color('red'),

Este campo es editable, en las vistas: edit y create.

Métodos no recomendados (O no funcionan o no tiene sentido utilizarlos)
  • addClass()
  • autofocus()
  • displayUsing()
  • prefix()
  • resolveUsing
  • suffix()
  • Campo Color

    Es un alias para el campo HTML5 color:

     use Daguilarm\Belich\Fields\Types\Color;
    
     /**
      * Get the fields displayed by the resource.
      *
      * @param  \Illuminate\Http\Request  $request
      * @return Illuminate\Support\Collection
      */
     public function fields(Request $request) {
         return [
             Color::make('Select color', 'color')
                ->defaultValue('#e66465'),
         ];
     }

    Mostrando:

    <input class="mr-3" value="#e66465" dusk="dusk-color" id="color" name="color" type="color">

    Otra funcionalidad de este campo, es el que en las vistas: index y show, se muestre el color (como si fuera html), en vez del código. Mostrando algo así:

    <div class="w-12 h-2 rounded" style="background-color:#a9d1bf">&nbsp;</div>

    Para ello, utilizaremos el método: asColor()

     use Daguilarm\Belich\Fields\Types\Color;
    
     /**
      * Get the fields displayed by the resource.
      *
      * @param  \Illuminate\Http\Request  $request
      * @return Illuminate\Support\Collection
      */
     public function fields(Request $request) {
         return [
             Color::make('Select color', 'color')
                ->defaultValue('#e66465')
                ->asColor(),
         ];
     }

    Campo Coordenates

    Con este campo, podremos añadir a nuestra base de datos las coordenadas: latitud y longitud. Veamos un ejemplo:

     use Daguilarm\Belich\Fields\Types\Coordenates;
    
     /**
      * Get the fields displayed by the resource.
      *
      * @param  \Illuminate\Http\Request  $request
      * @return Illuminate\Support\Collection
      */
     public function fields(Request $request) {
         return [
             Coordenates::make('Lat', 'lat_coordenates'),
         ];
     }

    Este código, nos generará un campo númerico con seis decimales. Podemos indicar que queremos que nos calcule la coordenada en grados, minutos y segundos, para ello, debemos indicar el tipo de conversión, y si el campo es de latitud o longitud:

    use Daguilarm\Belich\Fields\Types\Coordenates;
    
    /**
     * Get the fields displayed by the resource.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return Illuminate\Support\Collection
     */
    public function fields(Request $request) {
        return [
            Coordenates::make('Lat', 'lat_coordenates')
                ->toDegrees('lat'),
        ];
    }

    Esto es necesario para determinar la componente cardinal de la coordenada: N, S, E u O. El campo toDegrees() acepta los valores:

    • lat
    • latitude
    • lng
    • longitude

    Coordenadas

    fig 3: Ejemplo de campo para coordenadas
    Métodos no recomendados (O no funcionan o no tiene sentido utilizarlos)
  • displayUsing()
  • prefix()
  • resolveUsing
  • suffix()
  • Countries

    Este campo nos permite listar los paises del mundo mediante un campo autocompletado, usando la etiqueta <datalist></datalist>. Es un alias del campo Autocomplete(), al que se le inyecta directamente un archivo de idioma, con la lista de paises.

    A partir del archivo de idioma ubicado en ./resources/lang/vendor/belich/metrics.php, obtenemos un array con los paises y con el siguiente formato:

        ['code' => 'ES', 'name' => 'Spain'],
        ['code' => 'US', 'name' => 'United States'],
        ...

    Por supuesto, se puede modificar este archivo de idioma, y por tanto, ampliar o cambiar cualquier nombre o código.

    El sistema convertirá el array anterior con los paises, en un array listo para ser usuado por el campo <datalist></datalist>:

        ['ES' => 'Spain'],
        ['US' => 'United States'],
        ...

    El funcionamiento, será:

    use Daguilarm\Belich\Fields\Types\Countries;
    
    /**
     * Get the fields displayed by the resource.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return Illuminate\Support\Collection
     */
    public function fields(Request $request) {
        return [
            Countries::make('Countries', 'billing_country'),
        ];
    }

    Mostrando:

    Countries example

    fig 4: Ejemplo de campo para paises

    El campo Country no soporta los métodos: prefix(), sufix() y displayUsing().

    Métodos no recomendados (O no funcionan o no tiene sentido utilizarlos)
  • autofocus()
  • displayUsing()
  • prefix()
  • suffix()
  • Campo Date

    Nos creará un campo para para gestionar fechas. Este campo automáticamente se encarga de gestionar el formato adecuado para ser almacenado en la base de datos, y nos permite definir el formato en el que queremos mostrar la fecha:

    use Daguilarm\Belich\Fields\Types\Date;
    
    /**
     * Get the fields displayed by the resource.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return Illuminate\Support\Collection
     */
    public function fields(Request $request) {
        return [
            Date::make('Date', 'billing_date')
                ->format('d/m/Y'),
        ];
    }

    Si no indicamos el formato, utilizará el predefinido en el archivo ./config/belich.php

    Este campo se guarda automáticamente como objeto Carbon\Carbon. Puede consultar la sección Tipos para modificarlo.

    Métodos no recomendados (O no funcionan o no tiene sentido utilizarlos)
  • asHtml()
  • displayUsing()
  • prefix()
  • suffix()
  • Campo Decimal

    Nos genera un campo decimal (float), pero en el que podemos limitar el número de decimales:

    use Daguilarm\Belich\Fields\Types\Decimal;
    
    /**
     * Get the fields displayed by the resource.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return Illuminate\Support\Collection
     */
    public function fields(Request $request) {
        return [
            Decimal::make('Price', 'price')
                ->decimals(4),
        ];
    }

    Si no indicamos un número de decimales, el valor por defecto es: 2.

    Este campo se guarda automáticamente como float. Puede consultar la sección Tipos para modificarlo.

    Métodos no recomendados (O no funcionan o no tiene sentido utilizarlos)
  • displayUsing()
  • prefix()
  • suffix()
  • Campo Email

    El campo email nos permite generar un campo HTML5 de email. El funcionamiento, sería el siguiente:

    use Daguilarm\Belich\Fields\Types\Email;
    
    /**
     * Get the fields displayed by the resource.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return Illuminate\Support\Collection
     */
    public function fields(Request $request) {
        return [
            Email::make('Hellow world'),
        ];
    }

    Mostrando:

    <input type="email" name="myEmail" id="myEmail" dusk="dusk-myEmail">

    Al igual que los campos: File y Image, dispone del método multiple(), que le permite añadir multiples direcciones de email, separadas por coma.

    use Daguilarm\Belich\Fields\Types\Email;
    
    /**
     * Get the fields displayed by the resource.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return Illuminate\Support\Collection
     */
    public function fields(Request $request) {
        return [
            Email::make('Hellow world')
                ->multiple(),
        ];
    }

    Campo Header

    Nos permite añadir un título en el formulario para separar conceptos o añadir información adicional.

    use Daguilarm\Belich\Fields\Types\Header;
    
    /**
     * Get the fields displayed by the resource.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return Illuminate\Support\Collection
     */
    public function fields(Request $request) {
        return [
            Header::make('Hellow world'),
        ];
    }

    Por defecto, el código hmtl que mostrará, será:

    <div class="w-full items-center py-5 px-6 font-bold text-gray-600 bg-gray-200">Hellow world</div>

    En la figura 5 (a continuación), podremos ver un ejemplo, donde se mostrará el texto: Personal data.

    Este campo, nos permite personalizar los colores de forma sencilla, usando los métodos:

    • color(): para el color del texto.
    • background(): para el color de fondo.
    use Daguilarm\Belich\Fields\Types\Header;
    
    /**
     * Get the fields displayed by the resource.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return Illuminate\Support\Collection
     */
    public function fields(Request $request) {
        return [
            Header::make('Hellow world')
                ->background('red-500')
                ->color('white'),
        ];
    }

    Los colores soportados son: black, white, red, yellow, blue, green, orange y teal, con sus respectivos grados de color. Ej: red-400, white, blue-800,...

    También podemos añadir nuestro propio código html:

    use Daguilarm\Belich\Facades\Helper;
    use Daguilarm\Belich\Fields\Types\Header;
    
    /**
     * Get the fields displayed by the resource.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return Illuminate\Support\Collection
     */
    public function fields(Request $request) {
        return [
            Header::make('<h1 class="bg-gray-200 text-gray-700 p-5">' . Helper::icon('envelope-open-text') . ' Email</h1>')
                ->asHtml(),
        ];
    }

    Hay que utilizar el método asHtml() para no escapar el código, y que se renderice correctamente.

    Un ejemplo de como quedarían los campos Header:

    Header example

    fig 5: Ejemplo de campo header personalizado

    Este campo solo es accesible desde las vistas edit y create. Pero podemos añadir la vista show, usando:

    Header::make('My header title')->visibleOn('show');

    Campo Hidden

    El campo hidden, nos permite añadir campos ocultos, para enviar información extra a la base de datos.

    Este campo, sólo se muestra en las vistas de formularios: create y edit. Un ejemplo de uso, sería:

    Hidden::make('Hidden item', 'test_email'),

    Como el resto de campos de formulario, soporta una serie de métodos que le permiten modificar sus valores.

    Los métodos soportados son:

    Hidden::make('Hidden item', 'test_email')
        ->id('testing_id')
        ->name('testing-name')
        ->data('test', 'testing-data')
        ->dusk('testing-dusk')
        ->defaultValue('testing-value')
        ->disabled(),

    El resto de métodos, como: addClass(), readonly(), etc... no tienen sentido y han sido deshabilitados.

    Campo ID

    Nos permite visualizar en las vistas: index y show el valor del campo Id de la tabla.

    use Daguilarm\Belich\Fields\Types\ID;
    
    /**
     * Get the fields displayed by the resource.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return Illuminate\Support\Collection
     */
    public function fields(Request $request) {
        return [
            ID::make('Id'),
        ];
    }

    Por supuesto, si el nombre del campo en la tabla, es diferente al valor por defecto: id, podemos especificarlo:

    use Daguilarm\Belich\Fields\Types\ID;
    
    /**
     * Get the fields displayed by the resource.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return Illuminate\Support\Collection
     */
    public function fields(Request $request) {
        return [
            ID::make('Id', 'myCustomId'),
        ];
    }

    Es solo un campo de visualización. No puede ser modificado y por tanto, no permite métodos adicionales, como el resto de campos de formulario.

    Campo Markdown

    El campo markdown, nos permite almacenar en la base de datos, textos formateados mediante este sistema. Su funcionamiento es el siguiente:

    use Daguilarm\Belich\Fields\Types\Markdown;
    
    /**
     * Get the fields displayed by the resource.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return Illuminate\Support\Collection
     */
    public function fields(Request $request) {
        return [
            Markdown::make('Markdown field', 'blog_description'),
        ];
    }

    Por defecto, este campo no muestra la vista index, pero si consideramos que es necesario, podemos añadir el método:

    use Daguilarm\Belich\Fields\Types\Markdown;
    
    /**
     * Get the fields displayed by the resource.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return Illuminate\Support\Collection
     */
    public function fields(Request $request) {
        return [
            Markdown::make('Markdown field', 'blog_description')
                ->showOnIndex(),
        ];
    }

    Por defecto, en las vistas index y show, se muestra una versión acortada del texto, por lo que si queremos que se muestre el texto completo, tendremos que utilizar los métodos:

    • fullText(): muestra el texto completo en las dos vistas.
    • fullTextOnIndex(): muestra el texto completo solo en la vista index.
    • fullTextOnShow(): muestra el texto completo solo en la vista show.
    • fullTextOnDetail(): es un alias del anterior.

    También podemos mostrar una preview de nuestro código en las vistas: create y edit:

    use Daguilarm\Belich\Fields\Types\Markdown;
    
    /**
     * Get the fields displayed by the resource.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return Illuminate\Support\Collection
     */
    public function fields(Request $request) {
        return [
            Markdown::make('Markdown field', 'blog_description')
                ->preview(),
        ];
    }

    Mostrando lo siguiente:

    Markdown example

    fig 7: Ejemplo de campo Markdown con preview

    Campo Number

    Genera un campo number con las opciones: min(), max() y step():

    use Daguilarm\Belich\Fields\Types\Number;
    
    /**
     * Get the fields displayed by the resource.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return Illuminate\Support\Collection
     */
    public function fields(Request $request) {
        return [
            Number::make('Money', 'money')
                ->min(1)
                ->max(10000)
                ->step(1),
        ];
    }

    Campo Range

    Es un alias para la generar un campo HTML5 range. Funciona igual que un campo: Number, que se explicará en el siguiente punto. A modo de ejemplo:

    use Daguilarm\Belich\Fields\Types\Range;
    
    /**
     * Get the fields displayed by the resource.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return Illuminate\Support\Collection
     */
    public function fields(Request $request) {
        return [
            Range::make('Money', 'money')
                ->min(1)
                ->max(10000)
                ->step(1),
        ];
    }

    También disponemos del método options(), que nos permite enviar un array de valores:

    use Daguilarm\Belich\Fields\Types\Range;
    
    /**
     * Get the fields displayed by the resource.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return Illuminate\Support\Collection
     */
    public function fields(Request $request) {
        return [
            Range::make('Money', 'money')
                ->step(10)
                ->options(['0', '10', '20', '30', '40', '50', '60', '70', '80', '90', '100']),
        ];
    }

    En este caso, no hay que enviar el valor mínimo ni el máximo, simplemente el intervalo de valores. A continuación, veamos como quedarían los dos ejemplos anteriores:

    Range example

    fig 6: Ejemplo de campos range

    De momento, el uso del método: options(), no está soportando por todos los navegadores, por lo que su visualización, dependerá de ellos. Mas información en: Campo range

    Campo Select

    El campo select incluye el método options(), el cual nos permite añadir valores a la etiqueta option del campo select, tal y como se muestra a continuación:

    use Daguilarm\Belich\Fields\Types\Select;
    
    /**
     * Get the fields displayed by the resource.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return Illuminate\Support\Collection
     */
    public function fields(Request $request) {
        return [
            Select::make('Role', 'role')
                ->options([
                    1 => 'Admin', 
                    2 => 'Manager', 
                    3 => 'User'
                ])
                ->defaultValue(1)
        ];
    }

    Si necesitamos añadir valores desde la base de datos, podemos user el método __contructor:

    /**
     * List of emails from users
     *
     * @var array
     */
    protected $selectNames;
    
    /**
     * Generate constructor for the resource
     *
     * @return void
     */
    public function __construct()
    {
        //Getting data from storage to populate the field
        $this->selectNames = \App\User::pluck('name', 'id')->toArray();
    }
    
    /**
     * Get the fields displayed by the resource.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return Illuminate\Support\Collection
     */
    public function fields(Request $request) {
        return [
            Select::make('Role', 'role')
                ->options($this->selectNames),
        ]
    }
    Importante: Si utiliza un constructor para llamar a la base de datos, recuerde que si llama a este recurso desde un campo relacional, realizará la consulta a la base de datos aunque no sea necesaria...

    O sin constructor:

    /**
     * Get the fields displayed by the resource.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return Illuminate\Support\Collection
     */
    public function fields(Request $request) {
        return [
            Select::make('Role', 'role')
                ->options(\App\User::pluck('name', 'id')->toArray()),
        ]
    }
    Por lo general, es mejor no utilizar constructores si vamos a utilizar en nuestro proyecto campos relacionales.

    También podemos mostrar en las vistas index y show, el resultado como valor, en vez de como clave. Por ejemplo:

    [
        1 => 'Admin', 
        2 => 'Manager', 
        3 => 'User'
    ]

    En la base de datos, guardaríamos el valor de la clave: 1, y por tanto, en las vistas index y show, cuando mostremos el valor de este campo, nos mostrará 1 en lugar de Admin. Para solucionarlo, disponemos del método displayUsingLabels():

    use Daguilarm\Belich\Fields\Types\Select;
    
    /**
     * Get the fields displayed by the resource.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return Illuminate\Support\Collection
     */
    public function fields(Request $request) {
        return [
            Select::make('Role', 'role')
                ->options([
                    1 => 'Admin', 
                    2 => 'Manager', 
                    3 => 'User'
                ])
                ->displayUsingLabels()
        ];
    }

    Este método mostrará en las vistas: index y show, el resultado Admin, mientras que la vista edit, asignará el valor 1, haciendo que nuestro campo select, funcione correctamente.

    También podemos definir el primer campo de nuestro select, con el método firstOption(). Veamos un ejemplo:

    use Daguilarm\Belich\Fields\Types\Select;
    
    /**
     * Get the fields displayed by the resource.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return Illuminate\Support\Collection
     */
    public function fields(Request $request) {
        return [
            // Ejemplo 1
            Select::make('Role', 'role')
                ->options([
                    1 => 'Admin', 
                    2 => 'Manager', 
                    3 => 'User'
                ])
                ->firstOption(),
            // Ejemplo 2
            Select::make('Images', 'image')
                ->options([
                    1 => 'admin.jpg', 
                    2 => 'manager.jpg', 
                    3 => 'user.jpg'
                ])
                ->firstOption('No image'),
            // Ejemplo 3
            Select::make('Color', 'color')
                ->options([
                    1 => 'blue', 
                    2 => 'red', 
                    3 => 'yellow'
                ])
                ->firstOption('No color', 0)
        ];
    }

    El ejemplo anterior, renderizará:

    <select>
        <option></option>
        <option value="1">Admin</option>
        <option value="2">Manager</option>
        <option value="3">User</option>
    </select>
    <select>
        <option>No image</option>
        <option value="1">admin.jpg</option>
        <option value="2">manager.jpg</option>
        <option value="3">user.jpg</option>
    </select>
    <select>
        <option value="0">No color</option>
        <option value="1">blue</option>
        <option value="2">red</option>
        <option value="3">yellow</option>
    </select>

    Campo Text

    Este campo adminite los siguientes métodos especiales:

    • withRelationship()

    El método: withRelationship(), se utiliza para mostrar en las vistas: index, show y edit, información adicional de una tabla relacional.

    Debe utilizarse sólo para mostrar información, nunca para crear o actualizar, para ello, disponemos de campos relacionales.

    Por ejemplo, imaginemos que nuestra tabla tiene información sobre vehículos, y que también disponemos de otra tabla con información de la ubicación GPS del vehículo. Lo que no queremos, es que el usuario pueda modificar la información del GPS, pero si queremos mostrarla junto con la información del vehículo. Es en estos casos, cuando puede utilizarse un campo Text con relaciones.

    use Daguilarm\Belich\Fields\Types\Text;
    
    /**
     * Get the fields displayed by the resource.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return Illuminate\Support\Collection
     */
    public function fields(Request $request) {
        return [
            Text::make('GPS', 'gps_location')
                ->withRelationship('location'),
        ]
    }

    El ejemplo anterior, buscará la información $field->location->gps_location.

    Este campo se mostrará en las vistas: index y show, se le añadirá el attributo disabled en la vista edit y se eliminará de la vista: create.

    Para evitar problemas n+1, debemos añadir la relación al modelo. Para ello, al definir el modelo de nuestro recurso, debemos hacer lo siguiente:

    /** @var string [Model path] */
    public static $model = '\App\Models\Car';
    
    /** @var array */
    public static $relationships = ['location'];

    Este campo se guarda automáticamente como string. Puede consultar la sección Tipos para modificar el valor.

    Campo TextArea

    Nos permite crear un campo de formulario: textarea. A continuación, un ejemplo mostrando todas las opciones posibles para poder ser comentadas una a una:

    use Daguilarm\Belich\Fields\Types\Text;
    
    /**
     * Get the fields displayed by the resource.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return Illuminate\Support\Collection
     */
    public function fields(Request $request) {
        return [
            TextArea::make('Telephone', 'user_telephone')
                ->count(200)
                ->rows(6)
                ->fullText()
                ->rules('required')
                ->addClass('testing-class'),
        ]
    }

    El campo textarea, soporta los siguientes métodos:

    • fullText(): Por defecto, las áreas de texto, muestran una cadena de texto acortado, utilizando javascript para mostrar el texto completo. Si quiere que el texto se muestre íntegro, por defecto, debe añadir este método.
    • fullTextOnIndex(): El texto se muestra completo en la vista: index, pero parcial en la vista: show.
    • fullTextOnShow(): El texto se muestra completo en la vista: show, pero parcial en la vista: index.
    • maxlength(): Nos permite definir el número máximo de caracteres del campo.
    • count(): Igual que maxlength(), pero además, muestra bajo el campo, el número de caracteres restantes hasta llegar al número máximo (figura 6).
    • rows(): nos permite definir el número de filas o líneas que tendrá nuestra área de texto.

    TextArea example

    fig 7: Ejemplo de textarea con caracteres restantes

    Este campo se guarda automáticamente como string. Puede consultar la sección Tipos para modificar el valor.

    Métodos no recomendados (O no funcionan o no tiene sentido utilizarlos)
  • defaultValue()
  • displayUsing()
  • prefix()
  • resolveUsing()
  • suffix()
  • Campo Time

    Es un alias para el campo HTML5 time. Su funcionamiento básico es el siguiente:

    use Daguilarm\Belich\Fields\Types\Time;
    
    /**
     * Get the fields displayed by the resource.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return Illuminate\Support\Collection
     */
    public function fields(Request $request) {
        return [
            Time::make('Time', 'time')
                ->min('09:00')
                ->max('22:00')
                ->step(1),
        ];
    }

    Permite los métodos:

    • min(), para determinar el valor mínimo.
    • max(), para determinar el valor máximo.
    • step(), el intervalo de incremento del valor.

    Campo Year

    Nos creará un campo para para gestionar las fechas. Para ello, se usurá el formato de sql para los años, es decir, un campo integer de cuatro dígitos.

    Belich automáticamente validará el formato al añadir el campo, usando Carbon\Carbon.

    use Daguilarm\Belich\Fields\Types\Year;
    
    /**
     * Get the fields displayed by the resource.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return Illuminate\Support\Collection
     */
    public function fields(Request $request) {
        return [
            Year::make('Year', 'billing_year'),
        ];
    }

    Este campo se guarda automáticamente como objeto Carbon\Carbon. Puede consultar la sección Tipos para modificar el valor.