Discussion :

[grunk]

Salut à tous,

Actuelment j'ai un modèle que je récupère ainsi :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

$settings = Setting::where(['name' => Setting::LAST_SYNC])->firstOrFail();

Sauf que ce qui m'intéresse réellement c'est pas de récupérer un modèle complet mais uniquement la valeur correspondante. Et comme je vais avoir besoin de la récupérer à plusieurs endroit je me suis dit qu'il serait plus simple d'avoir une méthode dans mon model du style :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Setting extends Model
{
    protected $guarded = [];
    const LAST_SYNC = 'lastsync';
 
    public static function getLastSyncDate() {
        $value = self::select('value')->where(['name' => self::LAST_SYNC])->first();
        return $value->value;
    }
}
//
// Ailleurs dans le code
 
$lastsync = Setting::getLastSyncDate();

Sauf que ,
- Je ne peut pas appeler self::select , il attends une instance du model et non un appel static.
- J'ai l'impression que c'est pas très "laravel" comme fonctionnement.

Quel serait la bonne façon de faire ?

[MaitrePylos]

Bonjour, ce que tu cherche à faire , ce sont des scope : https://laravel.com/docs/6.x/eloquent#local-scopes

Donc dans ton cas un truc du genre

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
 
 protected $guarded = [];
    const LAST_SYNC = 'lastsync';
 
    public function scopeLastSyncDate($query) {
        return $query->where(['name' => self::LAST_SYNC])->first();
    }

[grunk]

Merci,

ca pourrait convenir , par contre je suis obligé de retourner une instance de queryBuilder et non la valeur que je recherche.
Du coupca m'obligerait à faire la petite gymnastique de conversion en datetime un peu partout. Pas dramatique , mais pas tip top non plus

J'ai contourné la problématique statique via :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
public static function getLastSyncDate(): DateTime {
        try {
            $value = (new static)::select('value')->where(['name' => self::LAST_SYNC])->firstOrFail();
            $dt = new DateTime($value->value);
        } catch(Exception $e) {
            $dt = null;
        }
        return $dt;
    }

Par contre d'un point de vue purement conceptuel , je pense que c'est pas vraiment sa place dans le model.
Et le (new static) me parrait pas hyper propre

[Invité]

Ca pique les yeux.

La scope méthode te sert à complet ta query.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
/**
     * @param \Illuminate\Database\Eloquent\Builder $query
     * @return \Illuminate\Database\Eloquent\Builder
     */
    public function ScopeActive($query)
    {
        return $query->where('products.status', '=', 'active');
    }

Son utilisation sera donc:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
Model::with(['translate'])->active()->get()

tu peux aussi considerer une scope méthode complete mais qui peu en meme temps chainer ton requête de model.
exemple issu d'un dev

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
 
public function ScopeOuiKO(Builder $builder)
    {
        return $builder
            ->leftJoin('orders_items','orders_items.order_id', '=', 'orders.id')
            ->leftJoin('products_versions', 'products_versions.id', '=', 'orders_items.product_version_id')
            ->leftJoin('products_versions_attributes', 'products_versions_attributes.product_version_id', '=', 'products_versions.id')
            ->leftJoin('attributes', static function($join) {
                $join
                    ->on('attributes.id', '=', 'products_versions_attributes.attribute_id')
                    ->where('attributes.attribute_group_id', '!=', 5); // Not attributes boolean
            })
            ->leftJoin('attributes_translate', static function($join){
                $join
                    ->on('attributes_translate.attribute_id', '=', 'attributes.id')
                    ->where('attributes_translate.culture_id', '=', 1);
            })
            ->leftJoin('products', 'products.id', '=', 'products_versions.product_id')
            ->leftJoin('products_translate', static function($join){
                $join
                    ->on('products_translate.product_id', '=', 'products.id')
                    ->where('products_translate.culture_id', '=', 1);
            })
 
            ->leftJoin('shippings_options_prices', 'shippings_options_prices.id', '=', 'orders.shipping_price_id')
            ->leftJoin('shippings_options', 'shippings_options.id', '=', 'shippings_options_prices.shipping_option_id')
            ->leftJoin('shippings_options_translate', static function($join){
                $join
                    ->on('shippings_options_translate.shipping_option_id', '=', 'shippings_options.id')
                    ->where('shippings_options_translate.culture_id', '=', 1);
            })
 
            //->whereIn('orders.status', ['confirmed','prepared','shipped','cancelled'])
            ->where('orders.status', '!=','cart')
            ->where('orders.pay', '=', 1)
            ->whereNull('exported_at')
            ->groupBy(['orders.order_number', 'products_versions.reference','orders_items.personalize'])
            ->select([
                'orders.order_number AS number',
                'orders.pay_date AS date',
                DB::raw('IFNULL(CONCAT(products_translate.label, \' - \', attributes_translate.label), products_translate.label) as article'),
                'orders_items.personalize as pseudo',
                'products_versions.reference AS sku',
                'orders_items.quantity AS quantité',
                'shippings_options_translate.label AS livraison',
                'orders.shipping_country AS pays',
                'products_versions.weight as poids',
                'orders.pay_type as paiement',
                'orders.status'
            ])
            ;
    }

Son utilisation sera donc:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
Model::->ouiKO()->get() or ->first()
ou
Model::->ouiKO()->where('champ', 'blabla')->get() or ->first()

[grunk]

Sauf que encore une fois ce que j'aimerais c'est récupérer une valeur (en l’occurrence un datetime) issue de ma bdd et pas un Builder qu'un scope m'impose de retourner.
Donc après la vraie bonne solution c'est surement de passer par un scope qui retourne un builder et d'avoir encore à coté une classe helper qui va m'extraire le datetime issue de ce scope. Un peu lourdingue mais la sépration des responsabilités est bien là.

En fait plus j'avance avec Laravel plus je me rend compte que l'ORM est super pour CRUD basique mais dès qu'on rentre dans les fonctionnement avancé ca devient compliqué et ou pas performant du tout et on fini par revenir sur de la requête manuelle.

[Invité]

Si tu cherche à faire un simple select sur un champ ta pas besoin de faire un Scope

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
Model::select('ton champ')->first();