Laravel Verifica se esiste un modello correlato

Ho un modello eloquente che ha un modello correlato:

public function option() {
    return $this->hasOne('RepairOption', 'repair_item_id');
}

public function setOptionArrayAttribute($values)
{
    $this->option->update($values);
}

Quando creo il modello, non ha necessariamente un modello correlato. Quando lo aggiorno, potrei aggiungere un'opzione o no.

Quindi devo controllare se esiste il modello correlato, per aggiornarlo o crearlo, rispettivamente:

$model = RepairItem::find($id);
if (Input::has('option')) {
    if (<related_model_exists>) {
        $option = new RepairOption(Input::get('option'));
        $option->repairItem()->associate($model);
        $option->save();
        $model->fill(Input::except('option');
    } else {
       $model->update(Input::all());
    }
};

Dov'è <related_model_exists>il codice che sto cercando.

In php 7.2+ non è possibile utilizzare countl'oggetto relazione, quindi non esiste un metodo completo per tutte le relazioni. Utilizzare invece il metodo di query come @tremby fornito di seguito:

$model->relation()->exists()

soluzione generica che funziona su tutti i tipi di relazione ( pre php 7.2 ):

if (count($model->relation))
{
  // exists
}

Questo funzionerà per ogni relazione poiché restituiscono proprietà dinamiche Modelo Collection. Entrambi implementano ArrayAccess.

Quindi va così:

relazioni singole: hasOne / belongsTo/ morphTo/morphOne

// no related model
$model->relation; // null
count($model->relation); // 0 evaluates to false

// there is one
$model->relation; // Eloquent Model
count($model->relation); // 1 evaluates to true

a molte relazioni: hasMany / belongsToMany/ morphMany/ morphToMany/morphedByMany

// no related collection
$model->relation; // Collection with 0 items evaluates to true
count($model->relation); // 0 evaluates to false

// there are related models
$model->relation; // Collection with 1 or more items, evaluates to true as well
count($model->relation); // int > 0 that evaluates to true

Un oggetto Relation passa chiamate di metodo sconosciute a un generatore di query Eloquent , impostato per selezionare solo gli oggetti correlati. A sua volta, quel Builder passa chiamate di metodo sconosciute alla sua query Builder sottostante .

Ciò significa che è possibile utilizzare i metodi exists()o count()direttamente da un oggetto relazione:

$model->relation()->exists(); // bool: true if there is at least one row
$model->relation()->count(); // int: number of related rows

Nota le parentesi dopo relation: ->relation()è una chiamata di funzione (ottenere l'oggetto relazione), al contrario della ->relationquale un getter di proprietà magiche impostato per te da Laravel (ottenere l'oggetto / gli oggetti correlati).

L'utilizzo del countmetodo sull'oggetto relazione (ovvero l'uso delle parentesi) sarà molto più rapido rispetto a fare $model->relation->count()o count($model->relation)((a meno che la relazione non sia già stata caricata con entusiasmo) poiché esegue una query di conteggio anziché estrarre tutti i dati per eventuali oggetti correlati dal database, solo per contarli. Allo stesso modo, l'utilizzo existsnon richiede neanche di estrarre i dati del modello.

Sia exists()e count()il lavoro su tutti i tipi di relazione che ho provato, così almeno belongsTo, hasOne, hasMany, e belongsToMany.

Preferisco usare il existsmetodo:

RepairItem::find($id)->option()->exists()

per verificare se esiste un modello correlato o meno. Funziona bene su Laravel 5.2

Dopo Php 7.1 , la risposta accettata non funzionerà per tutti i tipi di relazioni.

Perché a seconda del tipo di relazione, Eloquent restituirà a Collection, a Modelo Null. E in Php 7.1 count(null) lancerà un error.

Quindi, per verificare l'esistenza della relazione è possibile utilizzare:

Per relazioni singole: ad esempio hasOneebelongsTo

if(!is_null($model->relation)) {
   ....
}

Per relazioni multiple: Ad esempio: hasManyebelongsToMany

if ($model->relation->isNotEmpty()) {
   ....
}

Non sono sicuro che questo sia cambiato in Laravel 5, ma la risposta accettata usando count($data->$relation)non ha funzionato per me, poiché l'atto stesso di accedere alla proprietà della relazione ha causato il suo caricamento.

Alla fine, un semplice ha isset($data->$relation)fatto il trucco per me.

È possibile utilizzare il metodo relationshipLoaded sull'oggetto modello. Questo mi ha salvato la pancetta così speriamo che aiuti qualcun altro. Mi è stato dato questo suggerimento quando ho posto la stessa domanda sui Laracasts.

Come ha già detto Hemerson Varela in Php 7.1 count(null), lancerà errore hasOneritorna nullse non esiste alcuna riga. Dato che hai una hasOnerelazione, utilizzerei il emptymetodo per verificare:

$model = RepairItem::find($id);
if (!empty($temp = $request->input('option'))) {
   $option = $model->option;

   if(empty($option)){
      $option = $model->option()->create();
   }

   $option->someAttribute = temp;
   $option->save();
};

Ma questo è superfluo. Non è necessario verificare l'esistenza della relazione, per determinare se è necessario effettuare una updateo una createchiamata. Usa semplicemente il metodo updateOrCreate . Ciò equivale a quanto sopra:

$model = RepairItem::find($id);
if (!empty($temp = $request->input('option'))) {  
   $model->option()
         ->updateOrCreate(['repair_item_id' => $model->id],
                          ['option' => $temp]);
}

Ho dovuto refactificare completamente il mio codice quando ho aggiornato la mia versione di PHP alla versione 7.2+ a causa del cattivo utilizzo della funzione count ($ x). Questo è un vero dolore ed è anche estremamente spaventoso in quanto ci sono centinaia di usi, in diversi scenari e non esiste una regola adatta a tutti.

Regole che ho seguito per refactoring tutto, esempi:

$ x = Auth :: user () -> posts-> find (6); (controlla se l'utente ha un post id = 6 usando -> find ())

[FAILS] if(count($x)) { return 'Found'; } 
[GOOD] if($x) { return 'Found'; }

$ x = Auth :: user () -> profilo-> dipartimenti; (controlla se il profilo ha alcuni dipartimenti, possono esserci molti dipartimenti)

[FAILS] if(count($x)) { return 'Found'; }
[GOOD] if($x->count()) { return 'Found'; }

$ x = Auth :: user () -> profile-> get (); (controlla se l'utente ha un profilo dopo aver usato un -> get ())

[FAILS] if(count($x)) { return 'Found'; }
[GOOD] if($x->count()) { return 'Found'; }

Spero che questo possa aiutare, anche 5 anni dopo che la domanda è stata posta, questo post di StackOverflow mi ha aiutato molto!