icon-search icon-social
icon-menu
 

Laravel 5

Mit den in Laravel 5 eingeführten Form Requests, hast du als Entwickler endlich die Möglichkeit deine Formulare, vor dem Call der Action zu validieren. Dabei finde ich es persönlich am Besten, das die Validierung endlich raus aus dem Controller ist (wenn man keine Drittanbieter Libs, wie zum Beispiel Ardent benutzt).

Und in diese Form Requests, möchte ich dir heute eine Einführung geben. Außerdem habe ich noch ein bis zwei kleinere Nebenthemen für dich. Und zwar:

  1. Eine kleine Einführung in die .env Dateien, welche Laravel 5 nun unterstützt.
  2. Und wie du mittels Repositories, deine Datenschicht flexibel aufbauen kannst. Wo ich mich von Philips Lösung auf Culltt.com inspirieren lassen habe.

Okay, denn mal los.

Environment Dateien in Laravel 5 – .env

Wenn du dich schon mal ein bisschen mit der neuen Verzeichnisstruktur in Laravel 5 auseinandergesetzt hast, wird dir vielleicht eine Datei namens: .env aufgefallen sein. Wie du dir denken kannst, wird diese verwendet um, wie im einen meiner ersten Tutorials beschrieben die verschiedenen Projekt Stacks zu nutzen, so möchtest du Beispielsweise, auf einem Staging System keine SQLite Datenbank verwenden, sondern direkt eine MySQL, wie es im Produktiv Betrieb auch vorgesehen ist, dies kannst du ganz bequem über die Environment Dateien (.env) tun.

APP_ENV=local APP_DEBUG=true APP_KEY=SomeRandomString CACHE_DRIVER=file SESSION_DRIVER=file

1

2

3

4

5

6

APP_ENV=local

APP_DEBUG=true

APP_KEY=SomeRandomString

CACHE_DRIVER=file

SESSION_DRIVER=file

Wichtig dabei ist nur, das deine Konfigurationsdateien die Daten auch aus dem .env File holen. Standardmäßig, macht Laravel 5 das schon, wenn du zum Beispiel mal in die $ROOT/config/app.php nach debug suchst, wirst du folgendes finden:

‚debug‘ => env(‚APP_DEBUG‘),

1 ‚debug’=>env(‚APP_DEBUG‘),

An der Stelle, wird die Konfiguration für debug aus der Environment Variable APP_DEBUG geholt. Genial oder?

Grundsätzlich, kannst du aber nach wie vor, deine Konfigurationen ganz bequem über die Stacks verwalten, dazu solltest du in der .env Datei einfach nur den aktuellen Stack via APP_ENV setzen. Z.B.:

APP_ENV=local|staging|production

1 APP_ENV=local|staging|production

Dabei solltest du aber nicht vergessen, das evtl. Anpassungen an deinen Konfigurationsdateien von nöten sind.

Eine Repository Schicht für die Modelle bauen

Okay, dieser Part wird etwas komplexer, aber du fragst dich sicher, warum noch eine Schicht, vor die eigentlichen Modelle? Nun die Frage ist berechtigt, aber genauso einfach zu beantworten – Du bist flexibler, was die persistente Schicht angeht.

Angenommen, du entwickelst ein Projekt auf Basis von SQL (ob nun MySQL oder SQLite, sei erst mal dahingestellt) und im Laufe des Projektes, werden die Daten nicht mehr persistent in einer SQL Datenbank vorgehalten sondern in einer noSQL Datenbank wie CouchDB oder in einer XML Datei. Dann müsstest du mit ziemlich viel Aufwand, die Modelle umstricken und könntest erstmal nicht wieder zurück auf die Ausgangslösung.

Mit einer eigenen Repository Schicht, kannst du ganz einfach Model Schicht wechseln. Klingt erstmal interessant nicht wahr? Ist aber alles noch sehr theoretisch, deshalb zeige ich dir erstmal, wie du das nachbauen kannst. 😉

Den StorageServiceProvider bereitstellen

Dazu erstelle in dem Verzeichnis $ROOT/app/Providers eine Klasse: StorageServiceProvider.php mit folgendem Inhalt:

<?php namespace Laravel5Tutorial\Providers; use Illuminate\Support\ServiceProvider; class StorageServiceProvider extends ServiceProvider { /** * Register the application services. * * @return void */ public function register() { $this->app->bind( ‚Laravel5Tutorial\Storage\Task\TaskRepository‘, ‚Laravel5Tutorial\Storage\Task\EloquentTaskRepository‘ ); } }

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

<?phpnamespaceLaravel5Tutorial\Providers;

useIlluminate\Support\ServiceProvider;

classStorageServiceProviderextendsServiceProvider{

/**

* Register the application services.

*

* @return void

*/

publicfunctionregister()

{

        $this->app->bind(

            ‚Laravel5Tutorial\Storage\Task\TaskRepository‘,

            ‚Laravel5Tutorial\Storage\Task\EloquentTaskRepository‘

        );

}

}

Dieser Service Provider, wird später deine ganzen Repositories der Applikation bekannt machen. Das passiert jetzt hier in diesem kleinen Beispiel in der register Methode, die von Laravel automatisch beim Initialisieren des Service Providers aufgerufen wird.

Wenn du den Provider jetzt in deine $ROOT/config/app.php einfügst:

/* * Application Service Providers… */ ‚Laravel5Tutorial\Providers\AppServiceProvider‘, ‚Laravel5Tutorial\Providers\BusServiceProvider‘, ‚Laravel5Tutorial\Providers\ConfigServiceProvider‘, ‚Laravel5Tutorial\Providers\EventServiceProvider‘, ‚Laravel5Tutorial\Providers\RouteServiceProvider‘, ‚Laravel5Tutorial\Providers\StorageServiceProvider‘

1

2

3

4

5

6

7

8

9

/*

* Application Service Providers…

*/

‚Laravel5Tutorial\Providers\AppServiceProvider‘,

‚Laravel5Tutorial\Providers\BusServiceProvider‘,

‚Laravel5Tutorial\Providers\ConfigServiceProvider‘,

‚Laravel5Tutorial\Providers\EventServiceProvider‘,

‚Laravel5Tutorial\Providers\RouteServiceProvider‘,

‚Laravel5Tutorial\Providers\StorageServiceProvider‘

sollte deine Applikation meckern, das die beiden definierten Klasse(Interfaces) nicht bekannt sind. Diese baust du jetzt. 🙂

Modell und Repository bauen

Zu aller erst solltest du die Migration erstellen, das geht genauso wie in Laravel 4 via:

$ php artisan make:migration create_tasks_table

1 $php artisan make:migration create_tasks_table

Legt eine neue Migrationsklasse in $ROOT/database/migrations/ an, die wie folgt heißen sollte: YYYY_MM_DD_HHIISS_create_tasks_table.php.

Dieser Migration füge jetzt (für den Anfang) zwei Felder hinzu:

  • description – string 255
  • status – enum [open, closed]

Die fertige Migration sollte wie folgt aussehen:

<?php use Illuminate\Database\Schema\Blueprint; use Illuminate\Database\Migrations\Migration; class CreateTasksTable extends Migration { /** * Run the migrations. * * @return void */ public function up() { Schema::create(‚tasks‘, function(Blueprint $oTable){ $oTable->increments(‚id‘); $oTable->string(‚description‘); $oTable->enum(’status‘,[‚open‘, ‚closed‘])->default(‚open‘); $oTable->timestamps(); }); } /** * Reverse the migrations. * * @return void */ public function down() { Schema::drop(‚tasks‘); } }

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

<?php

useIlluminate\Database\Schema\Blueprint;

useIlluminate\Database\Migrations\Migration;

classCreateTasksTableextendsMigration{

/**

* Run the migrations.

*

* @return void

*/

publicfunctionup()

{

Schema::create(‚tasks‘,function(Blueprint$oTable){

$oTable->increments(‚id‘);

$oTable->string(‚description‘);

$oTable->enum(’status‘,[‚open‘,’closed‘])->default(‚open‘);

$oTable->timestamps();

});

}

/**

* Reverse the migrations.

*

* @return void

*/

publicfunctiondown()

{

Schema::drop(‚tasks‘);

}

}

Okay, und nun das Model:

$ php artisan make:model Task

1 $php artisan make:model Task

Legt in $ROOT/app (Achtung, das ist neu in Laravel 5!) eine Klasse Task.php an.

Welche am Ende wie folgt aussehen sollte:

<?php namespace Laravel5Tutorial; use Illuminate\Database\Eloquent\Model; class Task extends Model { protected $fillable = [‚description‘, ’status‘]; }

1

2

3

4

5

6

7

8

9

<?phpnamespaceLaravel5Tutorial;

useIlluminate\Database\Eloquent\Model;

classTaskextendsModel{

protected$fillable=[‚description‘,’status‘];

}

Im Grunde deklarierst du hier nur, das die Felder description und status massasignable sind.

Okay, das ist schon mal die halbe Miete, bis zu deiner Repository Schicht in Laravel 5.

Jetzt erstelle bitte innerhalb von $ROOT/app/ ein Verzeichnis: Storage/Task. Das kannst du auf *nix Systemen z.B. wie folgt tun:

$ mkdir -p app/Storage/Task

1 $mkdir-papp/Storage/Task

Der -p Parameter, baut die Verzeichnisse rekursiv. Dabei musst du natürlich aufpassen, dass du dich im $ROOT Verzeichnis, des Projektes befindest. 😉

In diesem Verzeichnis lege bitte zu erst ein Interface namens: TaskRepository.php an.

Welches, wir folgt aufgebaut werden sollte:

<?php namespace Laravel5Tutorial\Storage\Task; interface TaskRepository { public function all(); public function find($iId); public function create($aInput); public function paginate($iLimit = 15); }

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

<?php

namespaceLaravel5Tutorial\Storage\Task;

interfaceTaskRepository{

publicfunctionall();

publicfunctionfind($iId);

publicfunctioncreate($aInput);

publicfunctionpaginate($iLimit=15);

}

Demzufolge sind folgende Methoden in die Klassen oder Traits, welche das Interface inkludieren anzulegen:

  • all – holt alle Tasks
  • find – fetcht einen Task
  • create – legt einen neuen Task an
  • und paginate – paginiert die Collection.

Im Grunde baust du hier, wie du sicher schon erkannt hast, einen Wrapper auf, der die wichtigsten Methoden aus Eloquent “ersetzt”.

Demnach sollte dein Eloquent Repository: EloquentTaskRepository wie folgt aufgebaut werden:

<?php namespace Laravel5Tutorial\Storage\Task; use Laravel5Tutorial\Task; class EloquentTaskRepository implements TaskRepository { public function all() { return Task::all(); } public function find( $iId ) { return Task::find($iId); } public function create( $aInput ) { return Task::create($aInput); } public function paginate($iLimit = 15) { return Task::paginate($iLimit); } }

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

<?php

namespaceLaravel5Tutorial\Storage\Task;

useLaravel5Tutorial\Task;

classEloquentTaskRepositoryimplementsTaskRepository{

publicfunctionall(){

returnTask::all();

}

publicfunctionfind($iId){

returnTask::find($iId);

}

publicfunctioncreate($aInput){

returnTask::create($aInput);

}

publicfunctionpaginate($iLimit=15){

returnTask::paginate($iLimit);

}

}

Wie du siehst, wird hier einfach die Methode an das Eloquent Methode weitergereicht. Wenn du Lust hast, kannst du das Ganze ja auch noch mal refaktorieren, das sollte recht einfach mit magischen Methoden funktionieren. Ich persönlich bin da aber kein Freund von, weil ich denn keine Codevervollständigung in der IDE habe und testen lässt sich das Ganze schon mal viel schwerer.

Und, was sagst du, hast du verstanden, worums geht? Wenn du jetzt, wie oben angedeutet, auf ein noSQL Backend umsteigen würdest und deine Wrapperklasse dazu: CouchTaskRepository zum Beispiel existiert, könntest du den StorageServiceProvider wie folgt anpassen:

public function register() { $this->app->bind( ‚Laravel5Tutorial\Storage\Task\TaskRepository‘, ‚Laravel5Tutorial\Storage\Task\CouchTaskRepository‘ ); }

1

2

3

4

5

6

7

publicfunctionregister()

{

    $this->app->bind(

        ‚Laravel5Tutorial\Storage\Task\TaskRepository‘,

        ‚Laravel5Tutorial\Storage\Task\CouchTaskRepository‘

    );

}

und hättest mal eben über eine kleine Codeänderung dein Datenbackend geändert ohne auch nur einen Handschlag an die Controller oder Ähnliches vorzunehmen. Genial oder? 🙂

Den Form Request und deinen Task Planer bauen

Okay, aber nun kommen wir zum eigentlichen Thema, dieses Blog Beitrags. Ich werde dir zeigen, wie du einen kleinen Task Planer baust und dabei die Form Requests rudimentär erklären. Ganz so in die Tiefe will ich bei diesem Thema gar nicht gehen, weil sich vieles auch wieder durch learning by doing selber beigebracht werden sollte.

Die Form Request Klasse bauen

Form Requests können sehr einfach via Artisan Kommando gebaut werden:

$ php artisan make:request TaskRequest

1 $php artisan make:request TaskRequest

Dieses Kommando legt in: $ROOT/app/Http/Requests eine Klasse TaskRequest.php an, welche von Request.php ableitet und ein sehr rudimentäres Skelett vorgibt.

In der authorize Methode, wird geprüft ob der User autorisiert ist diesen Request auszuführen, in deinem Fall reicht es, wenn du da erst mal true zurückgibst.

In der rules Methode, definierst du die Regeln für den Request, also welche Regeln, auf welche Felder angewendet werden sollen. Die Regeln, werden wie im Laravel Validator definiert. Auf der verlinkten Seite, wird auch kurz auf die Form Requests eingegangen, aber ich zeige dir das lieber mal am lebendem Objekt. 😉  Demnach definierst du folgende Regeln:

  • description – erforderlich und zwischen 3 und 255 Zeichen
  • status – hat open oder closed

Die fertige Klasse sollte wie folgt aussehen:

<?php namespace Laravel5Tutorial\Http\Requests; class TaskRequest extends Request { /** * Determine if the user is authorized to make this request. * * @return bool */ public function authorize() { return true; } /** * Get the validation rules that apply to the request. * * @return array */ public function rules() { return [ ‚description‘ => ‚required|min:3|max:255′, ’status‘ => ‚in:open,closed‘ ]; } }

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

<?phpnamespaceLaravel5Tutorial\Http\Requests;

classTaskRequestextendsRequest{

/**

* Determine if the user is authorized to make this request.

*

* @return bool

*/

publicfunctionauthorize()

{

returntrue;

}

/**

* Get the validation rules that apply to the request.

*

* @return array

*/

publicfunctionrules()

{

return[

‚description’=>’required|min:3|max:255‘,

’status’=>’in:open,closed‘

];

}

}

Achtung: Kurz noch etwas wichtiges zu den Form Requests, sollte die Validierung zu Fehlern führen, leitet Laravel dich direkt auf die vorrige Seite zurück mit einem Errors Objekt für die View Schicht, aber da gehe ich gleich noch genauer drauf ein. Willst du das ändern, bietet sich die Methode: response an.

public function response() { /** * Mein Stoff, wenn die Validierung schief läuft. */ }

1

2

3

4

5

6

publicfunctionresponse()

{

    /**

     * Mein Stoff, wenn die Validierung schief läuft.

     */

}

Die Regeln können auch alternativ als Property gesetzt werden:

protected $rules = [ ‚description‘ => ‚required|min:3|max:255′, ’status‘ => ‚in:open,closed‘ ];

1

2

3

4

protected$rules=[

    ‚description’=>’required|min:3|max:255‘,

    ’status’=>’in:open,closed‘

];

Belasse es aber erstmal bei der Methode.

Den Controller bereitstellen

Der Controller, welcher unter: $ROOT/app/Http/Controllers abgelegt wird, ist wie in Laravel gewohnt sehr schlank und hat erstmal nur die wesentlichen Bestandteile, die du für das heutige Tutorial benötigst. Der Controller soll eine paginierte Liste und das Erstellen eines neuen Tasks ermöglichen. Dabei wirst du die Dependency Injection Möglichkeit von Laravel 5 nutzen, welche wie schon angedeutet Laravel ein wenig magisch macht. 😉

Wie gesagt, lege in oben stehendes Verzeichnis eine Controller Klasse: TasksController.php, mit den drei Methoden: 

  • __construct – initialisiert: EloquentTaskRepository und stellt dieses dem protected Property $_oTask zur Verfügung
  • getIndex
  • postsStore – initialisiert: TaskRequest

Der Konstruktor stellt dir wie gesagt ein Objekt der Klasse EloquentTaskRepository zur Verfügung und hängt dieses an das protected Property $_oTask:

/** * @var EloquentTaskRepository */ protected $_oTask; public function __construct(EloquentTaskRepository $oTask) { $this->_oTask = $oTask; }

1

2

3

4

5

6

7

8

/**

* @var EloquentTaskRepository

*/

protected$_oTask;

publicfunction__construct(EloquentTaskRepository$oTask){

$this->_oTask=$oTask;

}

Die Initialisierung nimmt wie schon aus Laravel 4 gewohnt Laravel selber vor, was das Binding an der Stelle extrem vereinfacht, obwohl das sicher auch etwas an Performance kostet, aber das wäre jetzt ein anderes und zu weit führendes Thema.

In der getIndex() Methode, gibst du erstmal einfach ein view tasks zurück, welches als Daten die Tasks paginiert bereitstellt:

/** * Display a listing of the resource. * * @return Response */ public function getIndex() { return view(‚tasks‘, [‚tasks‘ => $this->_oTask->paginate()]); }

1

2

3

4

5

6

7

8

9

/**

* Display a listing of the resource.

*

* @return Response

*/

publicfunctiongetIndex()

{

returnview(‚tasks‘,[‚tasks’=>$this->_oTask->paginate()]);

}

Wie du hier siehst, stellt Laravel 5 neue Hilfsfunktionen zur Verfügung, die deinen Code noch schlanker machen sollten. 😉

Die postStore Methode ist noch so ziemlich das “Aufwändigste” am ganzen Controller, aber ab hier wird’s mit Laravel 5 endlich wirklich spannend, weil du direkt den Form Request, den du gebaut hast, als Parameter vorgibst und ist die Validierung innerhalb dieses Form Requests fehlerhaft, wird die gesamte Logik der Methode nicht ausgeführt, das ist fürs spätere Debugging evtl. mal gut zu wissen. 🙂

/** * Store a newly created resource in storage. * * @return Response */ public function postStore(TaskRequest $oRequest) { $this->_oTask->create($oRequest->all()); \Session::flash(’success‘, ‚Aufgabe erfolgreich angelegt‘); return redirect(‚tasks‘); }

1

2

3

4

5

6

7

8

9

10

11

/**

* Store a newly created resource in storage.

*

* @return Response

*/

publicfunctionpostStore(TaskRequest$oRequest)

{

$this->_oTask->create($oRequest->all());

\Session::flash(’success‘,’Aufgabe erfolgreich angelegt‘);

returnredirect(‚tasks‘);

}

Hier wird, im Grunde nichts weiter gemacht, als ein neuer Task angelegt und eine Flash Message, das der Task erfolgreich angelegt wurde gesetzt. Danach wird direkt auf die Task Liste redirected.

Thats it! Extrem einfach und ziemlich cool!

Die View und Route anlegen

Zu guter Letzt fehlt dir eigentlich nur noch die View, die dir das Ganze auch mal in hübsch im Browser ausgibt und eine Route, damit du auch zu deiner Task Liste kommst.

Wie ich ja schon erwähnte, hat man sich bei Laravel dazu entschlossen, die Verzeichnisstruktur ein wenig zu ändern und hat dabei im Grunde alles, was nicht irgendwie zur Applikation als Klasse beiträgt (bis auf die route.php), aus dem $ROOT/app – Verzeichnis verbannt und dazu zählen nun mal auch die Templates, deshalb muss man diese jetzt unterhalb von $ROOT/resources/views ablegen.

Lege dort jetzt bitte wie oben schon genannt, das Template: tasks.blade.php, mit folgendem Inhalt an:

@extends(‚app‘) @section(‚content‘) @if (count($errors)) <div class=“alert alert-danger“ role=“alert“> <span class=“sr-only“>Fehler:</span> @foreach($errors->getMessages() as $error) @foreach($error as $message) {{{$message}}} @endforeach @endforeach </div> @endif @if(Session::has(’success‘)) <div class=“alert alert-success“ role=“alert“> <span class=“sr-only“>Super:</span> {{{Session::get(’success‘)}}} </div> @endif <div class=“container“> <div class=“row“> <div class=“col-md-10 col-md-offset-1″> <div class=“panel panel-default“> <div class=“panel-heading“>Aufgaben</div> <div class=“panel-body“> @if (count($tasks) > 0) <ul class=“task-list“> @foreach($tasks as $task) <li class=“task-list-item“> <input type=“checkbox“ class=“task-list-item-checkbox“ data-task-id=“{{{$task->id}}}“> {{{$task->description}}} </li> @endforeach </ul> @else <span class=“bg-info“>Keine Aufgaben vorhanden.</span> @endif </div> </div> </div> <div class=“col-md-10 col-md-offset-1″> <div class=“panel panel-info“> <div class=“panel-heading“>Neue Aufgabe anlegen</div> <div class=“panel-body“> <form class=“form-inline“ action=“{{{url(‚tasks/store‘)}}}“ method=“post“> <input type=“hidden“ name=“_token“ value=“{{{csrf_token()}}}“> <div class=“form-group{{$errors->has(‚description‘) ? ‚ has-error‘ : “}}“> <label class=“sr-only“ for=“description“>Beschreibgung</label> <input type=“text“ class=“form-control“ id=“description“ name=“description“ placeholder=“Aufgaben Beschreibung“> </div> <button type=“submit“ class=“btn btn-default“>Anlegen</button> </form> </div> </div> </div> </div> </div> @endsection

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

53

54

55

56

57

58

59

@extends(‚app‘)

@section(‚content‘)

    @if(count($errors))

        <div class=“alert alert-danger“role=“alert“>

            <span class=“sr-only“>Fehler:</span>

            @foreach($errors->getMessages()as$error)

                @foreach($erroras$message)

                    {{{$message}}}

                @endforeach

            @endforeach

        </div>

    @endif

    @if(Session::has(’success‘))

        <div class=“alert alert-success“role=“alert“>

            <span class=“sr-only“>Super:</span>

            {{{Session::get(’success‘)}}}

        </div>

    @endif

    <div class=“container“>

        <div class=“row“>

            <div class=“col-md-10 col-md-offset-1″>

                <div class=“panel panel-default“>

                    <div class=“panel-heading“>Aufgaben</div>

                    <div class=“panel-body“>

                        @if(count($tasks)>0)

                            <ul class=“task-list“>

                            @foreach($tasksas$task)

                                <li class=“task-list-item“>

                                    <input type=“checkbox“class=“task-list-item-checkbox“data-task-id=“{{{$task->id}}}“>

                                    {{{$task->description}}}

                                </li>

                            @endforeach

                            </ul>

                        @else

                            <span class=“bg-info“>Keine Aufgaben vorhanden.</span>

                        @endif

                    </div>

                </div>

            </div>

            <div class=“col-md-10 col-md-offset-1″>

                <div class=“panel panel-info“>

                    <div class=“panel-heading“>Neue Aufgabe anlegen</div>

                    <div class=“panel-body“>

                        <form class=“form-inline“action=“{{{url(‚tasks/store‘)}}}“method=“post“>

                            <input type=“hidden“name=“_token“value=“{{{csrf_token()}}}“>

                            <div class=“form-group{{$errors->has(‚description‘) ? ‚ has-error‘ : “}}“>

                                <label class=“sr-only“for=“description“>Beschreibgung</label>

                                <input type=“text“class=“form-control“id=“description“name=“description“placeholder=“Aufgaben Beschreibung“>

                            </div>

                            <button type=“submit“class=“btn btn-default“>Anlegen</button>

                        </form>

                    </div>

                </div>

            </div>

        </div>

    </div>

@endsection

Damit die von mir verwendeten Klassen nun auch ihre Wirkung zeigen, musst du ein mal die Datei: $ROOT/resources/assets/less/app.less, wie folgt erweitern:

@import „bootstrap/bootstrap“; @btn-font-weight: 300; @font-family-sans-serif: „Roboto“, Helvetica, Arial, sans-serif; body, label, .checkbox label { font-weight: 300; } .task-list-item { list-style-type: none; } ul.task-list { padding-left: 0; }

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

@import „bootstrap/bootstrap“;

@btn-font-weight:300;

@font-family-sans-serif:“Roboto“,Helvetica,Arial,sans-serif;

body, label, .checkbox label {

font-weight:300;

}

.task-list-item {

    list-style-type:none;

}

ul.task-list {

  padding-left:0;

}

Führe danach das Gulp Kommando: less aus und die Klassen stehen in deiner app.css zur Verfügung.

Solltest du kein Gulp haben, kannst du natürlich auch die Datei: $ROOT/public/css/app.css mit folgenden Klassen erweitern:

… .task-list-item { list-style-type: none; } ul.task-list { padding-left: 0; }

1

2

3

4

5

6

7

8

.task-list-item {

    list-style-type:none;

}

ul.task-list {

  padding-left:0;

}

So jetzt noch die Route anlegen und denn hast du es auch geschafft. 😉

Dazu öffne die Datei: $ROOT/app/Http/routes.php und ändere den Route::controllers Part, wie folgt:

Route::controllers([ ‚auth‘ => ‚Auth\AuthController‘, ‚password‘ => ‚Auth\PasswordController‘, ‚tasks‘ => ‚TasksController‘ ]);

1

2

3

4

5

Route::controllers([

‚auth’=>’Auth\AuthController‘,

‚password’=>’Auth\PasswordController‘,

‚tasks’=>’TasksController‘

]);

Fazit

Was mir gerade mal so auffällt, wenn ich den Beitrag noch mal gegenlese, das eigentliche Thema: Form Requests, wurde ziemlich kurz behandelt, aber für einen Einstieg sollte es reichen und nebenbei, habe ich dir ja noch gezeigt, wie du deine Modelle ziemlich cool um eine Repository Schicht erweiterst und was du mit den Environment Dateien in Laravel 5 anfangen kannst.

Viele Grüße

Eure Laravel Agentur

 

Filed Under

Author

Next Post

Previous Post