Wie die Rückkehr der AJAX-Fehler aus einer Laravel-controller?

Baue ich noch eine REST-API mit Laravel 5.

In Laravel 5, Sie können eine Unterklasse App\Http\Requests\Request zu definieren, die die Validierungsregeln, die erfüllt sein müssen, bevor eine route bearbeitet werden. Zum Beispiel:

<?php

namespace App\Http\Requests;

use App\Http\Requests\Request;

class BookStoreRequest extends Request {

    public function authorize() {
        return true;
    }

    public function rules() {
        return [
            'title' => 'required',
            'author_id' => 'required'
        ];
    }
}

Wenn ein client lädt die entsprechende route über einen AJAX-request, und die BookStoreRequest feststellt, dass die Anforderung nicht erfüllt die Regeln, wird es automatisch wieder den Fehler(s) als JSON-Objekt. Zum Beispiel:

{
  "title": [
    "The title field is required."
  ]
}

Jedoch die Request::rules() Methode kann nur Validierung der input—und auch wenn die Eingabe gültig ist, andere Arten von Fehlern, die auftreten könnten nach der Anfrage bereits angenommen und übergeben an den controller. Zum Beispiel, sagen wir mal, dass der controller benötigt zum schreiben der neuen Buch die Informationen in eine Datei aus irgendeinem Grund—aber die Datei kann nicht geöffnet werden:

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;

use App\Http\Requests;
use App\Http\Controllers\Controller;

use App\Http\Requests\BookCreateRequest;

class BookController extends Controller {

    public function store( BookStoreRequest $request ) {

        $file = fopen( '/path/to/some/file.txt', 'a' );

        //test to make sure we got a good file handle
        if ( false === $file ) {
            //HOW CAN I RETURN AN ERROR FROM HERE?
        }

        fwrite( $file, 'book info goes here' );
        fclose( $file );

        //inform the browser of success
        return response()->json( true );

    }

}

Natürlich könnte ich einfach die()aber das ist super hässlich. Ich würde lieber zurück, mein Fehler-Nachricht im selben format wie die Validierung Fehler. Wie diese:

{
  "myErrorKey": [
    "A filesystem error occurred on the server. Please contact your administrator."
  ]
}

Konnte ich konstruiere meine eigene JSON-Objekts und Rückgabe,—aber sicher Laravel unterstützt das nativ.

Was ist die beste /sauberste Weg, dies zu tun? Oder gibt es einen besseren Weg, um zurückzukehren-Laufzeit (im Gegensatz zu validieren-Zeit) Fehler, die aus einer Laravel REST API?

InformationsquelleAutor der Frage greenie2600 | 2016-02-11

17

Können Sie stellen Sie den status-code in Ihre json-Antwort wie folgt:
```
return Response::json(['error' => 'Error msg'], 404); //Status code here
```
Oder nur durch die Verwendung der Helfer-Funktion:
```
return response()->json(['error' => 'Error msg'], 404); //Status code here
```
InformationsquelleAutor der Antwort Jilson Thomas

Können Sie es in vielerlei Hinsicht tun.

Ersten, können Sie die einfache response()->json() indem Sie einen status-code:

return response()->json( /** response **/, 401 );

Oder, in einer komplexen Weise, um sicherzustellen, dass jeder Fehler einer json-Antwort, die Sie einrichten können eine exception-handler zu fangen, eine Besondere Ausnahme und json zurückgeben.

Öffnen App\Exceptions\Handler die folgenden Schritte aus:

class Handler extends ExceptionHandler
{
    /**
     * A list of the exception types that should not be reported.
     *
     * @var array
     */
    protected $dontReport = [
        HttpException::class,
        HttpResponseException::class,
        ModelNotFoundException::class,
        NotFoundHttpException::class,
        //Don't report MyCustomException, it's only for returning son errors.
        MyCustomException::class
    ];

    public function render($request, Exception $e)
    {
        //This is a generic response. You can the check the logs for the exceptions
        $code = 500;
        $data = [
            "error" => "We couldn't hadle this request. Please contact support."
        ];

        if($e instanceof MyCustomException) {
            $code = $e->getStatusCode();
            $data = $e->getData();
        }

        return response()->json($data, $code);
    }
}

Dies wird wieder eine json-für jede Ausnahme in der Anwendung.
Nun erstellen wir MyCustomException zum Beispiel in app/Ausnahmen:

class MyCustomException extends Exception {

    protected $data;
    protected $code;

    public static function error($data, $code = 500)
    {
        $e = new self;
        $e->setData($data);
        $e->setStatusCode($code);

        throw $e;
    }

    public function setStatusCode($code)
    {
        $this->code = $code;
    }

    public function setData($data)
    {
        $this->data = $data;
    }


    public function getStatusCode()
    {
        return $this->code;
    }

    public function getData()
    {
        return $this->data;
    }
}

Können wir jetzt einfach verwenden MyCustomException oder-ohne Ausnahme-auszudehnen MyCustomException Rückgabe eines json Fehler.

public function store( BookStoreRequest $request ) {

    $file = fopen( '/path/to/some/file.txt', 'a' );

    //test to make sure we got a good file handle
    if ( false === $file ) {
        MyCustomException::error(['error' => 'could not open the file, check permissions.'], 403);

    }

    fwrite( $file, 'book info goes here' );
    fclose( $file );

    //inform the browser of success
    return response()->json( true );

}

Nun nicht nur Ausnahmen, die über MyCustomException wird wieder eine json-Fehler, aber auch jede andere exception geworfen, im Allgemeinen.

InformationsquelleAutor der Antwort Blue Genie

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.