Tutoriel pour apprendre à créer une application Laravel

Les articles (back-end)

Maurice Chavelli

Dans le précédent tutoriel, on a vu comment sont gérés les articles et leurs commentaires au niveau du front-end. Nous allons à présent nous intéresser à la face cachée, non pas de la force, mais de l'application pour la gestion des articles par les administrateurs et les rédacteurs.

Si les administrateurs doivent avoir un accès total à tous les articles, commentaires et médias, les rédacteurs doivent être limités à leur propre production. Il ne serait pas judicieux de les laisser modifier l'article d'un autre rédacteur. Quant aux utilisateurs de base, ils ne doivent évidemment avoir accès à rien de tout cela.

Voyons comment cela est réalisé dans l'application.

Commentez

- Titre : Tutoriel pour apprendre à créer une application Laravel

- Auteur : Maurice Chavelli

- Parution : 21 décembre 2017

- Licence : Copyright ® 2017 Laravel. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

Sommaire

- I. Le panneau

- II. Le tri

- III. Publication et vu

- IV. Créer un article

- IV-A. Le formulaire

- IV-B. La validation

- IV-C. L'enregistrement

- V. Modifier un article

- V-A. Le formulaire

- V-B. La validation

- V-C. L'enregistrement

- VI. Supprimer un article

- VII. Les commentaires

- VII-A. Supprimer un commentaire

- VII-B. Valider l'utilisateur

- VII-C. Marquer le commentaire

- VIII. Remerciements

I - Le panneau

Sur son tableau de bord, l'administrateur trouve un bloc qui concerne les articles :

Il peut ainsi savoir combien il y a d'articles et combien il y en a de nouveaux.

On a déjà vu que le tableau de bord est géré par la méthode admin du contrôleur AdminController :

1. /**

2. * Show the admin panel.

3. *

4. * @param  App\Repositories\ContactRepository $contact_gestion

5. * @param  App\Repositories\BlogRepository $blog_gestion

6. * @param  App\Repositories\CommentRepository $comment_gestion

7. * @return Response

8. */

9. public function admin(

10. ContactRepository $contact_gestion,

11. BlogRepository $blog_gestion,

12. CommentRepository $comment_gestion)

13. {

14. $nbrMessages = $contact_gestion->getNumber();

15. $nbrUsers = $this->user_gestion->getNumber();

16. $nbrPosts = $blog_gestion->getNumber();

17. $nbrComments = $comment_gestion->getNumber();

19. return view('back.index', compact('nbrMessages', 'nbrUsers', 'nbrPosts', 'nbrComments'));

20. }

Et que les quantités sont déterminées dans la méthode getNumber du repository de base BaseRepository :

1. /**

2. * Get number of records.

3. *

4. * @return array

5. */

6. public function getNumber()

7. {

8. $total = $this->model->count();

10. $new = $this->model->whereSeen(0)->count();

12. return compact('total', 'new');

13. }

Et que tout ça est envoyé dans la vue resources/views/back/index.blade.php.

Pour accéder à la gestion des articles, l'administrateur peut cliquer sur le bloc ou utiliser le menu latéral :

Il dispose alors d'une vue globale sur les articles existants :

Un rédacteur aboutit directement à cette page et ne dispose que de ses articles.

À ce niveau les actions possibles sont :

- trier les articles par titre, date, publication, auteur et vu ;

- publier ou dépublier un article ;

- marquer un article vu ou non vu ;

- voir un article ;

- modifier un article ;

- supprimer un article ;

- créer un article.

Nous allons voir comment est traitée chacune de ces possibilités mise à part la visualisation d'un article qui se contente de le générer dans le front-end.

II - Le tri

Lorsque les articles ne sont pas triés, on a les deux petits sélecteurs qui apparaissent :

Lorsqu'on clique sur les sélecteurs, on passe en tri décroissant et seul le sélecteur inférieur apparaît :

Lorsqu'on clique à nouveau, on passe en mode tri croissant et seul le sélecteur supérieur apparaît :

Ces actions sont gérées en Ajax pour ne pas avoir à recharger la page, mais juste le tableau.

Il y a évidemment un traitement en JavaScript pour gérer le visuel et s'occuper de la requête Ajax :

1. // Sorting gestion

2. $('a.order').click(function(e) {

3. e.preventDefault();

4. // Sorting direction

5. var sens;

6. if($('span', this).hasClass('fa-unsorted')) sens = 'aucun';

7. else if ($('span', this).hasClass('fa-sort-desc')) sens = 'desc';

8. else if ($('span', this).hasClass('fa-sort-asc')) sens = 'asc';

9. // Set to zero

10. $('a.order span').removeClass().addClass('fa fa-fw fa-unsorted');

11. // Adjust selected

12. $('span', this).removeClass();

13. var tri;

14. if(sens == 'aucun' || sens == 'asc') {

15. $('span', this).addClass('fa fa-fw fa-sort-desc');

16. tri = 'desc';

17. } else if(sens == 'desc') {

18. $('span', this).addClass('fa fa-fw fa-sort-asc');

19. tri = 'asc';

20. }

21. // Wait icon

22. $('.breadcrumb li').append('<span id="tempo" class="fa fa-refresh fa-spin"></span>');

23. // Send ajax

24. $.ajax({

25. url: 'blog/order',

26. type: 'GET',

27. dataType: 'json',

28. data: "name=" + $(this).attr('name') + "&sens=" + tri

29. })

30. .done(function(data) {

31. $('tbody').html(data.view);

32. $('.link').html(data.links);

33. $('#tempo').remove();

34. })

35. .fail(function() {

36. $('#tempo').remove();

37. alert('{{ trans('back/blog.fail') }}');

38. });

39. })

C'est la méthode indexOrder du contrôleur BlogController qui reçoit la requête :

1. /**

2. * Display a listing of the resource.

3. *

4. * @param  Illuminate\Http\Request $request

5. * @return Response

6. */

7. public function indexOrder(Request $request)

8. {

9. $statut = $this->user_gestion->getStatut();

10. $posts = $this->blog_gestion->index(

11. 10,

12. $statut == 'admin' ? null : $request->user()->id,

13. $request->name,

14. $request->sens

15. );

17. $links = $posts->appends([

18. 'name' => $request->name,

19. 'sens' => $request->sens

20. ]);

22. if($request->ajax()) {

23. return response()->json([

24. 'view' => view('back.blog.table', compact('statut', 'posts'))->render(),

25. 'links' => $links->setPath('order')->render()

26. ]);

27. }

29. $links->setPath('')->render();

31. $order = (object)[

32. 'name' => $request->name,

33. 'sens' => 'sort-' . $request->sens

34. ];

36. return view('back.blog.index', compact('posts', 'links', 'order'));

37. }

On a un middleware pour protéger cette méthode :

$this->middleware('redac', ['except' => ['indexFront', 'show', 'tag', 'search']]);

On veut que ce soit au moins un rédacteur (redac).

C'est la méthode index du repository BlogRepository qui gère au niveau de la base :

1. /**

2. * Get post collection.

3. *

4. * @param  int     $n

5. * @param  int     $user_id

6. * @param  string  $orderby

7. * @param  string  $direction

8. * @return Illuminate\Support\Collection

9. */

10. public function index($n, $user_id = null, $orderby = 'created_at', $direction = 'desc')

11. {

12. $query = $this->model

13. ->select('posts.id', 'posts.created_at', 'title', 'posts.seen', 'active', 'user_id', 'slug', 'username')

14. ->join('users', 'users.id', '=', 'posts.user_id')

15. ->orderBy($orderby, $direction);

17. if($user_id)

18. {

19. $query->where('user_id', $user_id);

20. }

22. return $query->paginate($n);

23. }

On transmet les paramètres nécessaires :

- $n : nombre de pages pour la pagination ;

- $user_id : identifiant si on a affaire à un rédacteur (pour sélectionner uniquement ses articles), sinon null ;

- $orderby : champ de tri ;

- $direction : direction de tri.

Le contrôleur retourne le code généré de la vue :

En voici le code :

1. @foreach ($posts as $post)

2. <tr {!! !$post->seen && session('statut') == 'admin'? 'class="warning"' : '' !!}>

3. <td class="text-primary"><strong>{{ $post->title }}</strong></td>

4. <td>{{ $post->created_at }}</td>

5. <td>{!! Form::checkbox('active', $post->id, $post->active) !!}</td>

6. @if(session('statut') == 'admin')

7. <td>{{ $post->username }}</td>

8. <td>{!! Form::checkbox('seen', $post->id, $post->seen) !!}</td>

9. @endif

10. <td>{!! link_to('blog/' . $post->slug, trans('back/blog.see'), ['class' => 'btn btn-success btn-block btn']) !!}</td>

11. <td>{!! link_to_route('blog.edit', trans('back/blog.edit'), [$post->id], ['class' => 'btn btn-warning btn-block']) !!}</td>

12. <td>

13. {!! Form::open(['method' => 'DELETE', 'route' => ['blog.destroy', $post->id]]) !!}

14. {!! Form::destroy(trans('back/blog.destroy'), trans('back/blog.destroy-warning')) !!}

15. {!! Form::close() !!}

16. </td>

17. </tr>

18. @endforeach

On récupère donc côté client tout le HTML pour régénérer le tableau des articles. Dans le JavaScript :

1. .done(function(data) {

2. $('tbody').html(data.view);

3. $('.link').html(data.links);

4. $('#tempo').remove();

5. })

On remplace le HTML, on régénère les liens de pagination et on supprime la petite animation d'attente de résultat de l'action.

III - Publication et vu

L'administrateur ou le rédacteur dispose pour chaque article d'une case à cocher pour publier ou dépublier un article :

Cette action est aussi gérée en Ajax et on a une petite animation en attendant qu'elle s'effectue :

Voici le code JavaScript qui gère côté client :

1. // Active gestion

2. $(document).on('change', ':checkbox[name="active"]', function() {

3. $(this).hide().parent().append('<i class="fa fa-refresh fa-spin"></i>');

4. var token = $('input[name="_token"]').val();

5. $.ajax({

6. url: '{{ url('postactive') }}' + '/' + this.value,

7. type: 'PUT',

8. data: "active=" + this.checked + "&_token=" + token

9. })

10. .done(function() {

11. $('.fa-spin').remove();

12. $('input:checkbox[name="active"]:hidden').show();

13. })

14. .fail(function() {

15. $('.fa-spin').remove();

16. chk = $('input:checkbox[name="active"]:hidden');

17. chk.show().prop('checked', chk.is(':checked') ? null:'checked').parents('tr').toggleClass('warning');

18. alert('{{ trans('back/blog.fail') }}');

19. });

20. });

C'est la méthode updateActive du contrôleur BlogController qui reçoit la requête :

1. /**

2. * Update "active" for the specified resource in storage.

3. *

4. * @param  Illuminate\Http\Request $request

5. * @param  int  $id

6. * @return Response

7. */

8. public function updateActive(

9. Request $request,

10. $id)

11. {

12. $this->blog_gestion->updateActive($request->all(), $id);

14. return response()->json();

15. }

Cette méthode est protégée par middleware comme on l'a vu pour la précédente.

C'est la méthode updateActive du repository BlogRepository qui gère au niveau de la base :

1. /**

2. * Update "active" in post.

3. *

4. * @param  array  $inputs

5. * @param  int    $id

6. * @return void

7. */

8. public function updateActive($inputs, $id)

9. {

10. $post = $this->getById($id);

11. $post->active = $inputs['active'] == 'true';

12. $post->save();

13. }

Le contrôleur renvoie une réponse JSON et le JavaScript agit selon la réussite ou l'échec.

Je ne détaille pas le fonctionnement pour les cases à cocher « Vu » puisque le code est quasiment identique à celui de la publication.

IV - Créer un article

IV-A - Le formulaire

Le formulaire de création d'un article est affiché par action sur le bouton « Ajouter un article » ou à partir du menu latéral :

C'est la méthode create du contrôleur BlogController qui reçoit la requête :

1. /**

2. * Show the form for creating a new resource.

3. *

4. * @return Response

5. */

6. public function create()

7. {

8. $url = config('medias.url');

10. return view('back.blog.create')->with(compact('url'));

11. }

On voit qu'on va chercher l'URL pour le gestionnaire de médias dans la configuration.

Le contrôleur génère alors la vue :

Si vous regardez le code de cette vue, vous n'allez pas trouver grand-chose :

1. @extends('back.blog.template')

3. @section('form')

4. {!! Form::open(['url' => 'blog', 'method' => 'post', 'class' => 'form-horizontal panel']) !!}

5. @stop

En effet le reste du code est commun avec la vue pour la modification des articles. D'où la présence du template (resources/views/back/blog/template.blade.php) dont voici la partie du code qui génère le formulaire :

1. <div class="col-sm-12">

2. @yield('form')

4. <div class="form-group checkbox pull-right">

5. <label>

6. {!! Form::checkbox('active') !!}

7. {{ trans('back/blog.published') }}

8. </label>

9. </div>

11. {!! Form::control('text', 0, 'title', $errors, trans('back/blog.title')) !!}

13. <div class="form-group {!! $errors->has('slug') ? 'has-error' : '' !!}">

14. {!! Form::label('slug', trans('back/blog.permalink'), ['class' => 'control-label']) !!}

15. {!! url('/') . '/ ' . Form::text('slug', null, ['id' => 'permalien']) !!}

16. <small class="text-danger">{!! $errors->first('slug') !!}</small>

17. </div>

19. {!! Form::control('textarea', 0, 'summary', $errors, trans('back/blog.summary')) !!}

20. {!! Form::control('textarea', 0, 'content', $errors, trans('back/blog.content')) !!}

21. {!! Form::control('text', 0, 'tags', $errors, trans('back/blog.tags'), isset($tags)? implode(',', $tags) : '') !!}

23. {!! Form::submit(trans('front/form.send')) !!}

25. {!! Form::close() !!}

26. </div>

Avec cet aspect :

Le permalien est géré dynamiquement avec une fonction JavaScript :

1. $("#title").keyup(function(){

2. var str = sansAccent($(this).val());

3. str = str.replace(/[^a-zA-Z0-9\s]/g,"");

4. str = str.toLowerCase();

5. str = str.replace(/\s/g,'-');

6. $("#permalien").val(str);

7. });

Sont créées également deux zones de saisie (pour le sommaire et pour le contenu) avec CKEditor dont je vous ai déjà parlé dans un précédent tutoriel. J'ai évoqué dans le même tutoriel l'intégration de FileManager.

Enfin une zone permet la saisie des tags.

IV-B - La validation

La soumission du formulaire aboutit à la méthode store du contrôleur BlogController :

1. /**

2. * Store a newly created resource in storage.

3. *

4. * @param  App\Http\Requests\PostRequest $request

5. * @return Response

6. */

7. public function store(PostRequest $request)

8. {

9. $this->blog_gestion->store($request->all(), $request->user()->id);

11. return redirect('blog')->with('ok', trans('back/blog.stored'));

12. }

On a évidemment une validation assurée par la requête de formulaire PostRequest :

1. <?php namespace App\Http\Requests;

3. use App\Models\Post;

5. class PostRequest extends Request {

7. /**

8. * Get the validation rules that apply to the request.

9. *

10. * @return array

11. */

12. public function rules()

13. {

14. $id = $this->blog ? ',' . $this->blog : '';

15. return [

16. 'title' => 'required|max:255',

17. 'summary' => 'required|max:65000',

18. 'content' => 'required|max:65000',

19. 'slug' => 'required|unique:posts,slug' . $id,

20. 'tags' => 'tags'

21. ];

22. }

24. }

Les règles de validation sont classiques, mise à part celle qui concerne les tags. Il est fait appel à la règle « tags » qui n'est pas une règle de base de Laravel, mais constituée spécifiquement pour l'application.

Il y a une classe spéciale pour les règles de validation ajoutées :

Elle ne comporte qu'une règle :

1. <?php namespace app\Services;

3. use Illuminate\Validation\Validator;

5. class Validation extends Validator {

7. public function validateTags($attribute, $value, $parameters)

8. {

9. return preg_match("/^[A-Za-z0-9-éèàù]{1,50}?(,[A-Za-z0-9-éèàù]{1,50})*$/", $value);

10. }

12. }

Pour que cette classe soit connue de Laravel, on la déclare dans la méthode boot du provider AppServiceProvider :

1. public function boot()

2. {

3. Validator::resolver(function($translator, $data, $rules, $messages)

4. {

5. return new Validation($translator, $data, $rules, $messages);

6. });

7. }

Le message est prévu dans resources/lang/fr et en/validation.php. Ainsi en cas de mauvaise saisie on obtient ce résultat :

Le reste de la validation est classique.

Nota : il aurait été possible de prévoir l'expression régulière directement dans les règles de validation de la requête de formulaire, mais j'ai préféré montrer un exemple de réalisation de règle spécifique.

IV-C - L'enregistrement

Si la validation se passe bien le contrôleur fait appel à la méthode store du repository BlogRepository :

1. /**

2. * Create a post.

3. *

4. * @param  array  $inputs

5. * @param  int    $user_id

6. * @return void

7. */

8. public function store($inputs, $user_id)

9. {

10. $post = new $this->model;

11. $post = $this->savePost($post, $inputs, $user_id);

13. // Tags gestion

14. if(array_key_exists('tags',  $inputs) && $inputs['tags'] != '') {

16. $tags = explode(',', $inputs['tags']);

18. foreach ($tags as $tag) {

19. $tag_ref = $this->tag->whereTag($tag)->first();

20. if(is_null($tag_ref)) {

21. $tag_ref = new $this->tag();

22. $tag_ref->tag = $tag;

23. $post->tags()->save($tag_ref);

24. } else {

25. $post->tags()->attach($tag_ref->id);

26. }

27. }

28. }

29. }

Il est fait ici appel à une méthode commune avec la modification d'un article :

1. /**

2. * Create or update a post.

3. *

4. * @param  App\Models\Post $post

5. * @param  array  $inputs

6. * @param  bool   $user_id

7. * @return App\Models\Post

8. */

9. private function savePost($post, $inputs, $user_id = null)

10. {

11. $post->title = $inputs['title'];

12. $post->summary = $inputs['summary'];

13. $post->content = $inputs['content'];

14. $post->slug = $inputs['slug'];

15. $post->active = isset($inputs['active']);

16. if($user_id) $post->user_id = $user_id;

18. $post->save();

20. return $post;

21. }

La gestion la plus délicate concerne évidemment les tags. Il faut faire une boucle pour les traiter tous, vérifier s'ils existent déjà dans la base, et enfin les attacher à l'article.

V - Modifier un article

La modification d'un article a évidemment beaucoup de code en commun avec la création d'un article.

V-A - Le formulaire

C'est cette fois la méthode edit du contrôleur BlogController qui est utilisée :

1. /**

2. * Show the form for editing the specified resource.

3. *

4. * @param  App\Repositories\UserRepository $user_gestion

5. * @param  int  $id

6. * @return Response

7. */

8. public function edit(

9. UserRepository $user_gestion,

10. $id)

11. {

12. $post = $this->blog_gestion->getByIdWithTags($id);

14. $this->authorize('change', $post);

16. $url = config('medias.url');

18. return view('back.blog.edit',  array_merge($this->blog_gestion->edit($post), compact('url')));

19. }

Il faut aller chercher les informations existantes (titre, sommaire, contenu, tags…) avec la méthode GetByIdWithTags du repository BlogRepository :

1. /**

2. * Get post collection.

3. *

4. * @param  int  $id

5. * @return array

6. */

7. public function GetByIdWithTags($id)

8. {

9. return $this->model->with('tags')->findOrFail($id);

10. }

Remarquez la précaution prise pour limiter la modification d'un article à son créateur :

$this->authorize('change', $post);

On trouve la méthode correspondante dans app/Policies/PostPolicy.php :

1. /**

2. * Determine if the given post can be changed by the user.

3. *

4. * @param  \App\Models\User  $user

5. * @param  \App\Models\Post  $post

6. * @return bool

7. */

8. public function change(User $user, Post $post)

9. {

10. return $user->id === $post->user_id;

11. }

D'autre part un administrateur a tous les droits et peut aussi modifier un article même s'il ne lui appartient pas :

1. /**

2. * Grant all abilities to administrator.

3. *

4. * @param  \App\Models\User  $user

5. * @param  string  $ability

6. * @return bool

7. */

8. public function before(User $user, $ability)

9. {

10. if ($user->isAdmin()) {

11. return true;

12. }

13. }

Le contrôleur génère la vue :

Avec aussi peu de code que pour la création :

1. @extends('back.blog.template')

3. @section('form')

4. {!! Form::model($post, ['route' => ['blog.update', $post->id], 'method' => 'put', 'class' => 'form-horizontal panel']) !!}

5. @stop

Cette fois, on a Form::model pour avoir nos champs de saisie automatiquement complétés par le modèle $post. Le formulaire est évidemment le même avec les champs complétés.

V-B - La validation

La validation est presque identique puisqu'elle utilise la même requête de formulaire que nous avons déjà vue ci-dessus (PostRequest). Comment est-ce qu'on fait la différence ? Tout simplement, en testant la présence du paramètre blog dans la requête :

1. public function rules()

2. {

3. $id = $this->blog ? ',' . $this->blog : '';

4. return [

5. 'title' => 'required|max:255',

6. 'summary' => 'required|max:65000',

7. 'content' => 'required|max:65000',

8. 'slug' => 'required|unique:posts,slug' . $id,

9. 'tags' => 'tags'

10. ];

11. }

Si on a ce paramètre, alors on ajoute l'id de l'article en cours de modification pour ne pas tomber sur une erreur de validation parasite parce que le slug existe forcément déjà dans la base.

V-C - L'enregistrement

Si la validation se passe bien le contrôleur fait appel à la méthode update du repository BlogRepository :

1. /**

2. * Update a post.

3. *

4. * @param  array  $inputs

5. * @param  App\Models\Post $post

6. * @return void

7. */

8. public function update($inputs, $post)

9. {

10. $post = $this->savePost($post, $inputs);

12. // Tag gestion

13. $tags_id = [];

14. if(array_key_exists('tags',  $inputs) && $inputs['tags'] != '') {

16. $tags = explode(',', $inputs['tags']);

18. foreach ($tags as $tag) {

19. $tag_ref = $this->tag->whereTag($tag)->first();

20. if(is_null($tag_ref)) {

21. $tag_ref = new $this->tag();

22. $tag_ref->tag = $tag;

23. $tag_ref->save();

24. }

25. array_push($tags_id, $tag_ref->id);

26. }

27. }

29. $post->tags()->sync($tags_id);

30. }

On se retrouve avec un code très proche de celui pour la création.

VI - Supprimer un article

La suppression d'un article s'effectue à partir du bouton « Supprimer » de la liste des articles :

C'est cette fois la méthode destroy du contrôleur BlogController qui est utilisée :

1. /**

2. * Remove the specified resource from storage.

3. *

4. * @param  int  $id

5. * @return Response

6. */

7. public function destroy($id)

8. {

9. $post = $this->blog_gestion->getById($id);

11. $this->authorize('change', $post);

13. $this->blog_gestion->destroy($post);

15. return redirect('blog')->with('ok', trans('back/blog.destroyed'));

16. }

On a la même autorisation que pour la modification.

Le contrôleur appelle la méthode destroy du repository BlogRepository :

1. /**

2. * Destroy a post.

3. *

4. * @param  App\Models\Post $post

5. * @return void

6. */

7. public function destroy($post)

8. {

9. $post->tags()->detach();

11. $post->delete();

12. }

On commence par détacher les tags et ensuite on supprime l'article.

Ensuite le contrôleur redirige sur la même page avec un message en session :

VII - Les commentaires

L'administrateur dispose également sur son tableau de bord d'un bloc pour les commentaires :

Le code pour afficher le bloc est identique à celui que l'on a vu pour les articles.

Il y a également dans le menu un lien vers les commentaires :

Voici le panneau de gestion des commentaires :

L'administrateur peut ici :

- supprimer un commentaire ;

- valider l'utilisateur pour les commentaires ;

- marquer le commentaire comme « lu ».

La vue utilisée est celle-ci :

L'affichage des commentaires est assuré par une boucle :

1. @foreach ($comments as $comment)

2. <div class="panel {!! $comment->seen? 'panel-default' : 'panel-warning' !!}">

3. <div class="panel-heading {!! $comment->user->valid? '' : 'border-red' !!}">

4. <table class="table">

5. <thead>

6. <tr>

7. <th class="col-lg-3">{{ trans('back/comments.author') }}</th>

8. <th class="col-lg-3">{{ trans('back/comments.date') }}</th>

9. <th class="col-lg-3">{{ trans('back/comments.post') }}</th>

10. <th class="col-lg-1">{{ trans('back/comments.valid') }}</th>

11. <th class="col-lg-1">{{ trans('back/comments.seen') }}</th>

12. <th class="col-lg-1"></th>

13. </tr>

14. </thead>

15. <tbody>

16. <tr>

17. <td class="text-primary"><strong>{{ $comment->user->username }}</strong></td>

18. <td>{{ $comment->created_at }}</td>

19. <td>{{ $comment->post->title }}</td>

20. <td>{!! Form::checkbox('valide', $comment->user->id, $comment->user->valid) !!}</td>

21. <td>{!! Form::checkbox('seen', $comment->id, $comment->seen) !!}</td>

22. <td>

23. {!! Form::open(['method' => 'DELETE', 'route' => ['comment.destroy', $comment->id]]) !!}

24. {!! Form::destroy(trans('back/comments.destroy'), trans('back/comments.destroy-warning'), 'btn-xs') !!}

25. {!! Form::close() !!}

26. </td>

27. </tr>

28. </tbody>

29. </table>

30. </div>

31. <div class="panel-body">

32. {!! $comment->content !!}

33. </div>

34. </div>

35. @endforeach

VII-A - Supprimer un commentaire

La suppression d'un commentaire est assurée par la méthode destroy du contrôleur CommentController :

1. /**

2. * Remove the specified resource from storage.

3. *

4. * @param  Illuminate\Http\Request $request

5. * @param  int  $id

6. * @return Response

7. */

8. public function destroy(

9. Request $request,

10. $id)

11. {

12. $this->comment_gestion->destroy($id);

14. if($request->ajax())

15. {

16. return response()->json(['id' => $id]);

17. }

19. return redirect('comment');

20. }

Nous avons déjà vu cette méthode lorsque nous avons étudié le front-end. La requête était alors effectuée en Ajax. Dans la partie administration, on la fait de façon classique.

C'est la méthode destroy du repository de base Baserepository qui assure la suppression dans la base :

1. /**

2. * Destroy a model.

3. *

4. * @param  int $id

5. * @return void

6. */

7. public function destroy($id)

8. {

9. $this->getById($id)->delete();

10. }

VII-B - Valider l'utilisateur

Par sécurité un utilisateur nouvellement inscrit ne voit pas apparaître ses commentaires, il faut qu'un administrateur le valide. Évidemment une fois que cette action est effectuée tous les autres commentaires apparaissent immédiatement.

Tant qu'un utilisateur n'est pas validé, tous ses commentaires apparaissent bordés de rouge :

Le changement s'effectue par action sur la case à cocher « valide ». La requête est envoyée en Ajax :

1. // Valide gestion

2. $(":checkbox[name='valide']").change(function() {

3. var cases = $(":checkbox[name='valide'][value='" + this.value + "']");

4. cases.prop('checked', this.checked);

5. cases.parents('.panel-heading').toggleClass('border-red');

6. cases.hide().parent().append('<i class="fa fa-refresh fa-spin"></i>');

7. var token = $('input[name="_token"]').val();

8. $.ajax({

9. url: '{!! url('uservalid') !!}' + '/' + this.value,

10. type: 'PUT',

11. data: "valid=" + this.checked + "&_token=" + token

12. })

13. .done(function() {

14. $('.fa-spin').remove();

15. $('input[type="checkbox"]:hidden').show();

16. })

17. .fail(function() {

18. $('.fa-spin').remove();

19. var cases = $('input[type="checkbox"]:hidden');

20. cases.parents('.panel-heading').toggleClass('border-red');

21. cases.show().prop('checked', cases.is(':checked') ? null:'checked');

22. alert('{{ trans('back/comments.fail') }}');

23. });

24. });

Une petite animation signifie à l'administrateur que l'action est en cours :

La requête arrive à la méthode valid du contrôleur CommentController :

1. /**

2. * Validate an user

3. *

4. * @param  Illuminate\Http\Request $request

5. * @param  App\Repositories\UserRepository $user_gestion

6. * @param  int  $id

7. * @return Response

8. */

9. public function valid(

10. Request $request,

11. UserRepository $user_gestion,

12. $id)

13. {

14. $user_gestion->valide($request->input('valid'), $id);

16. return response()->json();

17. }

C'est finalement la méthode valide du repository UserRepository qui assure la modification dans la base :

1. /**

2. * Valid user.

3. *

4. * @param  bool  $valid

5. * @param  int   $id

6. * @return void

7. */

8. public function valide($valid, $id)

9. {

10. $user = $this->getById($id);

11. $user->valid = $valid == 'true';

12. $user->save();

13. }

VII-C - Marquer le commentaire

Un commentaire non lu apparaît avec un fond jaune :

Le changement s'effectue par action sur la case à cocher « Vu ». La requête est envoyée en Ajax selon un principe identique à celui de la validation de l'utilisateur.

La requête arrive à la méthode updateSeen du contrôleur CommentController :

1. /**

2. * Update "seen" in the specified resource in storage.

3. *

4. * @param  Illuminate\Http\Request $request

5. * @param  int  $id

6. * @return Response

7. */

8. public function updateSeen(

9. Request $request,

10. $id)

11. {

12. $this->comment_gestion->update($request->input('seen'), $id);

14. return response()->json();

15. }

C'est finalement la méthode update du repository CommentRepository qui assure la modification dans la base :

1. /**

2. * Update a comment.

3. *

4. * @param  bool  $vu

5. * @param  int   $id

6. * @return void

7. */

8. public function update($seen, $id)

9. {

10. $comment = $this->getById($id);

11. $comment->seen = $seen == 'true';

12. $comment->save();

13. }

Nous avons ainsi fait le tour de la gestion des articles côté back-end.

VIII - Remerciements

Nous remercions Maurice Chavelli qui nous autorise à publier ce tutoriel.

Nous tenons également à remercier Winjerome pour la mise au gabarit et Claude Leloup pour la relecture orthographique.