Descargar smokescreen laravel php - smokescreen laravel php Descarga del código fuente

smokescreen laravel php

Otras categorias

4.0.0

Descargar

Cortina de humo laravel

Descripción general

Laravel Smokescreen es un paquete para transformar sus modelos Laravel y otras entidades.

Transforme las respuestas de la API
Transforme las cargas útiles de trabajos y eventos
Mínimo calderín y bootstrap
Admite relaciones complejas para datos integrados
Apoya la carga entusiasta de las relaciones.
Permite transformar diferentes tipos de recursos.
Puede manejar la serialización a formatos personalizables.

Este paquete integra estrechamente el paquete rexlabs/smokescreen (Vanilla PHP) con el marco de trabajo de Laravel, para proporcionar la comodidad y un texto mínimo al trabajar con aplicaciones de Laravel.

Uso

 <?php
class MyController extends Controller
{
    public function index ()
    {
        return Smokescreen:: transform (Post:: paginate ());
    }
    
     public function show ( Post $ post )
     {
        return Smokescreen:: transform ( $ post );
     }
}

laravel-smokescreen se inicia en el contenedor de aplicaciones de Laravel, por lo que también puedes escribir sugerencias para inyectarlo en el constructor o los métodos de tu controlador.
Se recomienda usar la fachada (como arriba) dentro de los métodos del controlador, usar sugerencias de tipo en las clases de servicio (si es necesario)
También puedes usarlo directamente desde el contenedor a través de app('smokescreen') como se muestra arriba.
Dado que implementamos la interfaz Responsable , simplemente puede devolver la cortina de humo desde cualquier método de controlador.

Requisitos

PHP >= 7.0
Laravel >= 5.5

Instalación

Este paquete está actualmente alojado en el repositorio de empaquetadores privado de RexSoftware. Primero asegúrese de haber configurado su composer.json para usar este repositorio.

Instalar paquete

composer require rexlabs/laravel-smokescreen

Este paquete se descubrirá automáticamente y no es necesaria ninguna configuración adicional.

Configuración

Para publicar el archivo de configuración en su carpeta app/config , ejecute el siguiente comando:

php artisan vendor:publish --provider= ' RexlabsLaravelSmokescreenProvidersServiceProvider --tag=config '

Esto creará config/smokescreen.php :

 <?php
return [
    // Set the default namespace for resolving transformers when
    // they are not explicitly provided.
    ' transformer_namespace ' => ' AppTransformers ' ,
    
    // Override the default serializer to be used.
    // If not specified - the Smokescreen DefaultSerializer will be used.
    ' default_serializer ' => null ,

    // Set the default request parameter key which is parsed for
    // the list of includes.
    ' include_key ' => ' include ' ,
];

API

transform(): establece el recurso a transformar

$smokescreen->transform(mixed $resource, mixed $transformer = null);

 <?php
$ smokescreen -> transform (Post:: find ( 1 ));
$ smokescreen -> transform (Post:: all ());
$ smokescreen -> transform (Post:: paginate ());
$ smokescreen -> transform (Post:: find ( 1 ), new SomeOtherTransformer );

La cortina de humo determinará automáticamente el tipo de recurso que se está transformando.
También inferirá la clase Transformer que se utilizará si no se proporciona.

item(): establece el recurso de un solo elemento para transformarlo

$smokescreen->item(mixed $item, mixed $transformer = null);

 <?php
$ smokescreen -> item (Post:: find ( 1 ));
$ smokescreen -> item (Post:: find ( 1 ), new SomeOtherTransformer );

Similar a transform() pero solo acepta un elemento.

colección(): establece el recurso de colección que se transformará

$smokescreen->collection(mixed $collection, mixed $transformer = null);

 <?php
$ smokescreen -> collection (Post:: all ());
$ smokescreen -> collection (Post:: paginate ());
$ smokescreen -> collection (Post:: paginate (), new SomeOtherTransformer );

Similar a transform() pero solo acepta una colección.

transformWith(): configura el transformador para usar en el recurso previamente configurado

$smokescreen->transformWith(TransformerInterface|callable $transformer);

 <?php
$ smokescreen -> transform (Post:: find ( 1 ))
    -> transformWith ( new SomeOtherTransformer );

Es una alternativa a pasar el transformador directamente a los métodos de recursos.

serializeWith(): anula el serializador que se utilizará

 <?php
$ smokescreen -> serializeWith ( new MyCustomSerializer );

Solo necesita configurar esto si planea usar una serialización diferente a la predeterminada.
Proporcionamos DefaultSerializer como valor predeterminado, devuelve colecciones anidadas en un nodo "data" y un recurso de elemento sin ningún anidamiento.
Su serializador personalizado debe implementar la interfaz SerializerInterface .

loadRelationsVia(): anula el cargador de relaciones predeterminado de Laravel

$smokescreen->loadRelationsVia(RelationsLoaderInterface $loader);

 <?php
$ smokescreen -> loadRelationsVia ( new MyRelationsLoader );

Sólo necesita configurar esto si planea usar un cargador diferente al predeterminado,
Proporcionamos RelationsLoader como valor predeterminado que carga ansiosamente las relaciones para los recursos de recopilación.
Su cargador personalizado debe implementar la interfaz RelationsLoaderInterface y proporcionar un método load() .

resolveTransformerVia(): anula el solucionador de transformador predeterminado

$smokescreen->loadTransformersVia(TransformerResolverInterface $loader);

 <?php
$ smokescreen -> loadTransformersVia ( new MyTransformerResolver );

El solucionador se utiliza cuando un transformador no está definido explícitamente en un recurso.
El solucionador predeterminado en este paquete intenta encontrar una clase de transformador coincidente dentro de la ruta definida en la ruta smokescreen.transformer_namespace y la crea una instancia a través del contenedor de la aplicación.
Solo necesita configurar esto si planea usar un solucionador diferente al predeterminado.
Su solucionador personalizado debe implementar la interfaz TransformersLoaderInterface y proporcionar un método resolve(ResourceInterface) .

respuesta (): accede al objeto de respuesta generado

$response = $smokescreen->response(int $statusCode = 200, array $headers = [], int $options = 0);

 <?php
$ smokescreen -> response ()
    -> header ( ' X-Custom-Header ' , ' boo ' )
    -> setStatusCode ( 405 );

Este método devuelve un objeto IlluminateHttpJsonResponse por lo que no se puede encadenar.
Se pueden aplicar todos los métodos JsonResponse compatibles.
Aún puedes devolver response() directamente desde tu controlador ya que es un objeto JsonResponse .
Alternativamente, puede usar withResponse($callback) para aplicar cambios y aún admitir la capacidad de encadenamiento.
Nota: la primera llamada a response() almacena en caché el resultado para que todo el conjunto de datos no se vuelva a generar cada vez, esto significa que se ignorará cualquier parámetro que se pase en llamadas posteriores. Puede utilizar clearResponse() o manipular el objeto JsonResponse directamente.

FreshResponse(): genera un nuevo objeto de respuesta

$response = $smokescreen->freshResponse(int $statusCode = 200, array $headers = [], int $options = 0);

A diferencia de response() este método devuelve un objeto JsonResponse nuevo y no almacenado en caché (llamando primero clearResponse() ).
Este método devuelve un objeto IlluminateHttpJsonResponse por lo que no se puede encadenar. Consulte withResponse() para conocer un método encadenable.
Se pueden aplicar todos los métodos JsonResponse compatibles.

withResponse(): aplica cambios al objeto de respuesta generado

$smokescreen->withResponse(callable $apply);

 <?php
$ smokescreen -> withResponse ( function ( JsonResponse $ response ) {
    $ response -> header ( ' X-Crypto-Alert ' , ' all your coins are worthless! ' );
});

Proporcionar una devolución de llamada que acepte un objeto JsonResponse y manipule la respuesta.
Este método se puede encadenar a diferencia de response()

clearResponse(): borra cualquier respuesta almacenada en caché

$smokescreen->clearResponse();

 <?php
$ smokescreen -> response ();       // Data is generated, response object is built and cached
$ smokescreen -> response ( 500 );    // NOPE - Cached, wont be changed!
$ smokescreen -> clearResponse ();
$ smokescreen -> response ( 500 );    // Response is re-generated

Restablecer cualquier objeto de respuesta almacenado en caché

Transformadores

Transformador de ejemplo

 <?php
class PostTransformer extends AbstractTransformer
{
    protected $ includes = [
        ' user ' => ' default|relation:user|method:includeTheDamnUser ' ,
        ' comments ' => ' relation ' ,
    ];

    public function transform ( Post $ post ): array
    {
        return [
            ' id ' => $ post -> id ,
            ' user ' => $ this -> when ( $ post -> user_id , [
                ' id ' => $ post -> user_id ,
            ]),
            ' title ' => $ post -> title ,
            ' summary ' => $ post -> summary ,
            ' body ' => $ post -> body ,
            ' created_at ' => utc_datetime ( $ post -> created_at ),
            ' updated_at ' => utc_datetime ( $ post -> updated_at ),
        ];
    }

    public function includeTheDamnUser ( Post $ post )
    {
        return $ this -> item ( $ post -> user ); // Infer Transformer
    }

    public function includeComments ( Post $ post )
    {
        return $ this -> collection ( $ post -> comments , new CommentTransformer );
    }
}

Declaras tus inclusiones disponibles a través de la matriz $includes
Cada inclusión acepta 0 o más de las siguientes directivas:
- default : esta inclusión siempre está habilitada independientemente de las inclusiones solicitadas
- relation : Indica que una relación debe cargarse con entusiasmo. Si el nombre de la relación es diferente, especifíquelo como relation:othername
- method : de forma predeterminada, la clave de inclusión está asignada para include{IncludeKey} puede proporcionar el método que se utilizará en su lugar.
Su método transform() debería devolver una matriz.
Defina sus métodos de inclusión en el formato include{IncludeKey}(Model) : deben devolver una collection() o un item()
when() es un método auxiliar simple que acepta una condición y devuelve el valor dado cuando es verdadero o nulo (por defecto) cuando es falso. En el ejemplo anterior, el nodo "user" será null si no hay user_id establecido en el objeto $post .