laravel - delete - ¿Oculta dinámicamente ciertas columnas al devolver un objeto Eloquent como JSON?

eloquent orm

Question

¿Cómo ocultar dinámicamente ciertas columnas al devolver un objeto Eloquent como JSON? Por ejemplo, para ocultar la columna ''contraseña'':

$users = User::all();
return Response::json($users);

Soy consciente de que puedo establecer propiedades protegidas en el modelo ( $ ocultas o $ visibles ), pero ¿cómo las configuro dinámicamente? Es posible que desee ocultar o mostrar diferentes columnas en diferentes contextos.

Answer 1

Además de la respuesta de @ deczo, creo que la variable $hidden no está realmente diseñada para ser utilizada de forma dinámica. Es más para proteger datos específicos de una visualización incorrecta (como ''contraseña'').

Si desea columnas específicas, probablemente debería utilizar una declaración de selección y obtener las columnas específicas que desea.

Answer 2

De la documentación de Lavarel 5.3 :

Modificación temporal de la visibilidad del atributo

Si desea que algunos atributos ocultos normalmente makeVisible visibles en una instancia de modelo determinada, puede usar el método makeVisible . El método makeVisible devuelve la instancia del modelo para un encadenamiento de método conveniente:

return $user->makeVisible(''attribute'')->toArray();

Del mismo modo, si desea hacer que algunos atributos normalmente visibles se oculten en una instancia de modelo determinada, puede usar el método makeHidden .

return $user->makeHidden(''attribute'')->toArray();

Answer 3

En 5.4 puedes ocultar y mostrar atributos dinámicamente:

$model->makeVisible(''attribute'');

$model->makeHidden(''attribute'');

Laravel docs

Answer 4

He encontrado una solución completa para solucionar el problema con el uso de $ model-> setHidden (array $ columnas);

Digamos, por ejemplo, que le gustaría decidir en el controlador exactamente qué campos devolver. Actualizar solo lo oculto del modelo lo obliga a revisar cada modelo antes de devolver un conjunto de modelos, por ejemplo. El problema se agrava aún más cuando esos modelos tienen relaciones que a usted también le gustaría cambiar. Tiene que recorrer cada modelo, establecer el atributo oculto y luego, para cada uno, también establecer las relaciones ocultas. Que desastre.

Mi solución involucra la creación de un miembro estático para cada modelo que, cuando está presente, actualiza el atributo visible / oculto justo antes de la llamada a "toArray":

<?php

trait DynamicHiddenVisible {

    public static $_hidden = null;
    public static $_visible = null;

    public static function setStaticHidden(array $value) {
        self::$_hidden = $value;
        return self::$_hidden;
    }

    public static function getStaticHidden() {
        return self::$_hidden;
    }

    public static function setStaticVisible(array $value) {
        self::$_visible = $value;
        return self::$_visible;
    }

    public static function getStaticVisible() {
        return self::$_visible;
    }

    public static function getDefaultHidden() {
        return with(new static)->getHidden();
    }

    public static function geDefaultVisible() {
        return with(new static)->getVisible();
    }

    public function toArray()    {
        if (self::getStaticVisible())
            $this->visible = self::getStaticVisible();
        else if (self::getStaticHidden())
            $this->hidden = self::getStaticHidden();
        return parent::toArray();
    }

}

Como un bono adicional, expongo una forma al valor predeterminado / oculto del modelo que puede haber establecido en la clase de su modelo.

No olvides añadir el rasgo.

class Client extends Eloquent {
     use DynamicHiddenVisible;
}

Finalmente, en el controlador, antes de devolver su modelo, decida atributos visibles / ocultos:

public function getIndex($clientId) {
    // in this specific call, I would like to hide the "special_type" field of my Client model
    $hiddenFields = Client::getDefaultHidden();
    array_push($hiddenFields, "special_type");
    Client::setStaticHidden($hiddenFields);

    return Client::find($clientId)->toJson();
}

Answer 5

Hizo un paquete para esto que usa Políticas Modelo.

https://github.com/salomoni/authorized-attributes

Utilice el rasgo Salomoni/AuthorizedAttributes

<?php

namespace App;

use Illuminate/Database/Eloquent/Model;
use Salomoni/AuthorizedAttributes;

class Post extends Model
{
    use AuthorizedAttributes;

    /**
     * The attributes that should be hidden for serialization.
     *
     * @var array
     */
    protected $hidden = [''author_comments''];
}

Crea y registra una política modelo . Agregue métodos para los atributos ocultos en el caso de camello con el prefijo see .

namespace App/Policies;

use App/User;

class PostPolicy
{
    /**
     * Determine if a post author_comments-atrribute can be seen by the user.
     *
     * @param  /App/User  $user
     * @return bool
     */
    public function seeAuthorComments(User $user)
    {
        return $user->isAuthor();
    }
}

Answer 6

No creo que sea el trabajo del ORM preocuparse por la lógica de presentación, y eso es lo que es JSON. Siempre deberá convertir los datos a varios tipos, así como ocultar cosas y, a veces, crear una zona de búfer para cambiar el nombre de las cosas de forma segura.

Puedes hacer todo eso con Fractal que construí exactamente por esta razón.

<?php namespace App/Transformer;

use Acme/Model/Book;
use League/Fractal/TransformerAbstract;

class BookTransformer extends TransformerAbstract
{
    /**
     * List of resources possible to include
     *
     * @var array
     */
    protected $availableIncludes = [
        ''author''
    ];

    /**
     * Turn this item object into a generic array
     *
     * @return array
     */
    public function transform(Book $book)
    {
        return [
            ''id''    => (int) $book->id,
            ''title'' => $book->title,
            ''year''    => (int) $book->yr,
            ''links''   => [
                [
                    ''rel'' => ''self'',
                    ''uri'' => ''/books/''.$book->id,
                ]
            ],
        ];
    }

    /**
     * Include Author
     *
     * @return League/Fractal/ItemResource
     */
    public function includeAuthor(Book $book)
    {
        $author = $book->author;

        return $this->item($author, new AuthorTransformer);
    }
}

Incrustar (incluyendo) cosas puede ser un poco más de lo que necesita ahora, pero también puede ser muy útil.

Answer 7

Para la versión Laravel 5.3 o superior ,

Si desea que varios atributos queden ocultos o visibles temporalmente con una sola declaración, puede usar los model->makeVisible() y model->makeHidden() para pasar una array of attributes .

Por ejemplo, para ocultar múltiples atributos ,

$user->makeHidden(["attribute1", "attribute2", "attribute3"]);

Y para hacer visibles múltiples atributos ,

$user->makeVisible(["otherAttribute1", "otherAttribute2", "otherAttribute3"]);

Answer 8

$model->getHidden();
$model->setHidden(array $columns);

$model->setVisible(array $columns);