Laravel éloquent obtenir relation comte

- Je utiliser Laravel 5.3.

J'ai 2 tables :

Articles
---------
id
cat_id
title

Category
---------
id
parent_id
title

J'ai défini mes relations dans mes modèles :

//Article model
public function category()
{
    return $this->belongsTo(Category::class);
}

//Category model
public function children() 
{
    return $this->hasMany(Category::class, 'parent_id', 'id');
}

Est-il un moyen facile à l'aide Éloquent d'avoir une liste de catégories avec nombre d'articles. La difficulté est que je veux catégories de groupes où id_parent = 0, c'est à dire que je veux afficher seulement les catégories mères avec nombre d'articles dans les enfants.

J'ai essayé quelque chose comme ça :

    $category = new \App\Models\Category();
    $categoryTable = $category->getTable();

    return $category->leftJoin('article', 'article.cat_id', '=', 'category.id')
        ->whereIn('article.cat_id', function($query)
            {
                $query->select('cat_id')
                    ->from('categories')
                    ->where('categories.parent_id', ???)
                    ->orWhere($this->tableName .'.cat_id', $id);
            })
        ->groupBy('cat_id');

Mais je suis perdu...

Combien de niveaux de hiérarchie sera là, dans le tableau category?
Seulement 2 max, pas plus

OriginalL'auteur Vincent Decaux | 2016-12-15

laravel php

19

vous pouvez utiliser withCount(). Il est disponible à partir de 5.3 version

pour plus d'informations sur éloquent visite : https://laravel.com/docs/5.3/eloquent-relationships

Ah sympa ! il fonctionne, mais j'ai 2 relations ici. Il fonctionne avec le lien de l'article -> catégorie, mais j'ai besoin d'inclure les enfants aussi.
Ouais! Merci! Après, nous pouvons accéder à ces valeurs dans l'attribut de l'Entité ex: $category->articles_count

OriginalL'auteur kapil.dev

Vous pouvez utiliser le hasManyThrough() Éloquent méthode pour récupérer tous les enfants d'Articles, puis ajouter l'article comtes ensemble dans un joli petit getter. J'ai ajouté de la lecture à l' $appends tableau sur le modèle à l'aide de l'illustrer dans le Bricoleur de sortie.

class Category extends Model
{

    protected $appends = [
        'articleCount'
    ];

    public function articles()
    {
        return $this->hasMany(Article::class);
    }

    public function children()
    {
        return $this->hasMany(Category::class, 'parent_id');
    }

    public function childrenArticles()
    {
        return $this->hasManyThrough(Article::class, Category::class, 'parent_id');
    }

    public function getArticleCountAttribute()
    {
        return $this->articles()->count() + $this->childrenArticles()->count();
    }
}

Voici le Bricoleur de sortie:

Psy Shell v0.8.0 (PHP 7.0.6 — cli) by Justin Hileman
>>> $cat = App\Category::first();
=> App\Category {#677
     id: "1",
     name: "Cooking",
     parent_id: null,
     created_at: "2016-12-15 18:31:57",
     updated_at: "2016-12-15 18:31:57",
   }
>>> $cat->toArray();
=> [
     "id" => 1,
     "name" => "Cooking",
     "parent_id" => null,
     "created_at" => "2016-12-15 18:31:57",
     "updated_at" => "2016-12-15 18:31:57",
     "articleCount" => 79,
   ]
>>>

Si vous voulez restreindre votre Catégorie de requêtes pour ceux qui ont des enfants qui ont des articles, vous pouvez le faire en utilisant les has() méthode:

Category::has('children.articles')->get();

Voici plus d'informations sur le has() méthode:

https://laravel.com/docs/5.3/eloquent-relationships#querying-relationship-existence

Et la hasManyThrough() méthode:

https://laravel.com/docs/5.3/eloquent-relationships#has-many-through

OriginalL'auteur Carter Fort

2

Définir un articles() relation dans votre Category modèle:
```
public function articles() 
{
    return $this->hasMany(Article::class, 'cat_id');
}
```
Alors vous pouvez essayer:
```
Category::where('parent_id', 0)->withCount('articles')->get();
```
Mais comment faire pour que le comptage des articles dans la catégorie parent avec des enfants ?
Oui, mais j'aurai besoin du comte d'enfants des catégories trop. Je veux dire, si un article appartient à un des enfants de la catégorie, j'ai besoin de les compter.

OriginalL'auteur Amit Gupta
1

Cela devrait fonctionner:
```
$category
->where('categories.parent_id', 0)
->leftJoin('article', 'article.cat_id', '=', 'categories.id')
->select('categories.id', \DB::raw('COUNT(article.id)'))
->groupBy('categories.id')
->get();
```
La requête ci-dessus, vous obtiendrez les Id de catégorie et le nombre de tous les articles qui appartiennent à la catégorie.

Après la lecture de votre question et les commentaires encore une fois, si je comprends bien, vous voulez obtenir le nombre de tous les articles qui appartiennent à ces catégories (avec parent_id = 0) + le décompte des articles qui appartiennent à des sous-catégories (ceux avec parent_id = (id de la catégorie définie)).

Maintenant, je n'ai aucun moyen de tester facilement, mais je pense que quelque chose le long de ces lignes doit travailler.
```
$category
->where('categories.parent_id', 0)
->leftJoin('article', 'article.cat_id', '=', 'categories.id')
->leftJoin('categories as c2', 'c2.parent_id', '=', 'categories.id')
->leftJoin('article as a2', 'a2.cat_id', '=', 'c2.id')
->select('categories.id', \DB::raw('(COUNT(article.id)) + (COUNT(a2.id)) as count'))
->groupBy('categories.id')
->get();
```
Que beign dit, je pense que tu es mieux d'avoir une colonne nommée nombre de catégories et de les mettre à jour à chaque fois qu'un nouvel article est ajouté. Pour la performance.

OriginalL'auteur devk

Je suis sûr que quelqu'un est toujours en cours à travers cela, j'ai été en mesure de le résoudre de la manière suivante, supposons que j'ai un modèle d'Agent et d'un Calendrier de modèle, c'est à dire un agent peut avoir de nombreuses annexes:

class Schedule extends Model {
  public function agent() {
    return $this->belongsTo(Agent::class, 'agent_id');
  }
}

class Agent extends Model {
  public function user(){
    return $this->belongsTo(User::class);
  }

  public function schedules(){
    return $this->hasMany(Schedule::class);
  }
}

Bien certains agents peuvent ne pas avoir d'horaires attribués, donc, j'ai éliminé ceux d'avant l'appel de la with() méthode, comme ceci:

$agents = Agents::whereIn(
    'id', 
    Schedule::distinct()->pluck('agent_id')
)->with('schedules')->get();

Espérons que cette aide!.

OriginalL'auteur Carlos_E.

Vous devez vous connecter pour publier un commentaire.