Просмотр файла app/Controllers/Admin/ArticleController.php

Конкурс дизайнеров на 15000 рублей
Свежие Креативы и море позитива !!!
Размер файла: 10.61Kb 
  1. <?php
  2.  
  3. declare(strict_types=1);
  4.  
  5. namespace App\Controllers\Admin;
  6.  
  7. use App\Classes\Validator;
  8. use App\Models\Article;
  9. use App\Models\Blog;
  10. use App\Models\User;
  11. use Exception;
  12. use Illuminate\Http\Request;
  13.  
  14. class ArticleController extends AdminController
  15. {
  16.     /**
  17.      * Главная страница
  18.      *
  19.      * @return string
  20.      */
  21.     public function index(): string
  22.     {
  23.         $categories = Blog::query()
  24.             ->where('parent_id', 0)
  25.             ->orderBy('sort')
  26.             ->with('children', 'new', 'children.new')
  27.             ->get();
  28.  
  29.         return view('admin/blogs/index', compact('categories'));
  30.     }
  31.  
  32.     /**
  33.      * Создание раздела
  34.      *
  35.      * @param Request   $request
  36.      * @param Validator $validator
  37.      *
  38.      * @return void
  39.      */
  40.     public function create(Request $request, Validator $validator): void
  41.     {
  42.         if (! isAdmin(User::BOSS)) {
  43.             abort(403, __('errors.forbidden'));
  44.         }
  45.  
  46.         $name = $request->input('name');
  47.  
  48.         $validator->equal($request->input('token'), $_SESSION['token'], __('validator.token'))
  49.             ->length($name, 3, 50, ['name' => __('validator.text')]);
  50.  
  51.         if ($validator->isValid()) {
  52.             $max = Blog::query()->max('sort') + 1;
  53.  
  54.             /** @var Blog $category */
  55.             $category = Blog::query()->create([
  56.                 'name'  => $name,
  57.                 'sort'  => $max,
  58.             ]);
  59.  
  60.             setFlash('success', __('blogs.category_success_created'));
  61.             redirect('/admin/blogs/edit/' . $category->id);
  62.         } else {
  63.             setInput($request->all());
  64.             setFlash('danger', $validator->getErrors());
  65.         }
  66.  
  67.         redirect('/admin/blogs');
  68.     }
  69.  
  70.     /**
  71.      * Редактирование раздела
  72.      *
  73.      * @param int       $id
  74.      * @param Request   $request
  75.      * @param Validator $validator
  76.      *
  77.      * @return string
  78.      */
  79.     public function edit(int $id, Request $request, Validator $validator): string
  80.     {
  81.         if (! isAdmin(User::BOSS)) {
  82.             abort(403, __('errors.forbidden'));
  83.         }
  84.  
  85.         /** @var Blog $category */
  86.         $category = Blog::query()->with('children')->find($id);
  87.  
  88.         if (! $category) {
  89.             abort(404, __('blogs.category_not_exist'));
  90.         }
  91.  
  92.         $categories = Blog::query()
  93.             ->where('parent_id', 0)
  94.             ->orderBy('sort')
  95.             ->get();
  96.  
  97.         if ($request->isMethod('post')) {
  98.             $parent = int($request->input('parent'));
  99.             $name   = $request->input('name');
  100.             $sort   = int($request->input('sort'));
  101.             $closed = empty($request->input('closed')) ? 0 : 1;
  102.  
  103.             $validator->equal($request->input('token'), $_SESSION['token'], __('validator.token'))
  104.                 ->length($name, 3, 50, ['title' => __('validator.text')])
  105.                 ->notEqual($parent, $category->id, ['parent' => __('blogs.category_not_exist')]);
  106.  
  107.             if (! empty($parent) && $category->children->isNotEmpty()) {
  108.                 $validator->addError(['parent' => __('blogs.category_has_subcategories')]);
  109.             }
  110.  
  111.             if ($validator->isValid()) {
  112.                 $category->update([
  113.                     'parent_id' => $parent,
  114.                     'name'      => $name,
  115.                     'sort'      => $sort,
  116.                     'closed'    => $closed,
  117.                 ]);
  118.  
  119.                 setFlash('success', __('blogs.category_success_edited'));
  120.                 redirect('/admin/blogs');
  121.             } else {
  122.                 setInput($request->all());
  123.                 setFlash('danger', $validator->getErrors());
  124.             }
  125.         }
  126.  
  127.         return view('admin/blogs/edit', compact('categories', 'category'));
  128.     }
  129.  
  130.     /**
  131.      * Удаление раздела
  132.      *
  133.      * @param int       $id
  134.      * @param Request   $request
  135.      * @param Validator $validator
  136.      *
  137.      * @return void
  138.      * @throws Exception
  139.      */
  140.     public function delete(int $id, Request $request, Validator $validator): void
  141.     {
  142.         if (! isAdmin(User::BOSS)) {
  143.             abort(403, __('errors.forbidden'));
  144.         }
  145.  
  146.         /** @var Blog $category */
  147.         $category = Blog::query()->with('children')->find($id);
  148.  
  149.         if (! $category) {
  150.             abort(404, __('blogs.category_not_exist'));
  151.         }
  152.  
  153.         $validator->equal($request->input('token'), $_SESSION['token'], __('validator.token'))
  154.             ->true($category->children->isEmpty(), __('blogs.category_has_subcategories'));
  155.  
  156.         $article = Article::query()->where('category_id', $category->id)->first();
  157.         if ($article) {
  158.             $validator->addError(__('blogs.articles_in_category'));
  159.         }
  160.  
  161.         if ($validator->isValid()) {
  162.             $category->delete();
  163.  
  164.             setFlash('success', __('blogs.category_success_deleted'));
  165.         } else {
  166.             setFlash('danger', $validator->getErrors());
  167.         }
  168.  
  169.         redirect('/admin/blogs');
  170.     }
  171.  
  172.     /**
  173.      * Пересчет данных
  174.      *
  175.      * @param Request $request
  176.      *
  177.      * @return void
  178.      */
  179.     public function restatement(Request $request): void
  180.     {
  181.         if (! isAdmin(User::BOSS)) {
  182.             abort(403, __('errors.forbidden'));
  183.         }
  184.  
  185.         if ($request->input('token') === $_SESSION['token']) {
  186.             restatement('blogs');
  187.  
  188.             setFlash('success', __('main.success_recounted'));
  189.         } else {
  190.             setFlash('danger', __('validator.token'));
  191.         }
  192.  
  193.         redirect('/admin/blogs');
  194.     }
  195.  
  196.     /**
  197.      * Список блогов
  198.      *
  199.      * @param int $id
  200.      *
  201.      * @return string
  202.      */
  203.     public function blog(int $id): string
  204.     {
  205.         $category = Blog::query()->with('parent')->find($id);
  206.  
  207.         if (! $category) {
  208.             abort(404, __('blogs.category_not_exist'));
  209.         }
  210.  
  211.         $articles = Article::query()
  212.             ->where('category_id', $id)
  213.             ->orderByDesc('created_at')
  214.             ->with('user')
  215.             ->paginate(setting('blogpost'));
  216.  
  217.         return view('admin/blogs/blog', compact('articles', 'category'));
  218.     }
  219.  
  220.     /**
  221.      * Редактирование статьи
  222.      *
  223.      * @param int       $id
  224.      * @param Request   $request
  225.      * @param Validator $validator
  226.      *
  227.      * @return string
  228.      */
  229.     public function editArticle(int $id, Request $request, Validator $validator): string
  230.     {
  231.         /** @var Article $article */
  232.         $article = Article::query()->find($id);
  233.  
  234.         if (! $article) {
  235.             abort(404, __('blogs.article_not_exist'));
  236.         }
  237.  
  238.         if ($request->isMethod('post')) {
  239.             $title = $request->input('title');
  240.             $text  = $request->input('text');
  241.             $tags  = $request->input('tags');
  242.  
  243.             $validator
  244.                 ->equal($request->input('token'), $_SESSION['token'], __('validator.token'))
  245.                 ->length($title, 3, 50, ['title' => __('validator.text')])
  246.                 ->length($text, 100, setting('maxblogpost'), ['text' => __('validator.text')])
  247.                 ->length($tags, 2, 50, ['tags' => __('blogs.article_error_tags')]);
  248.  
  249.             if ($validator->isValid()) {
  250.                 $article->update([
  251.                     'title' => $title,
  252.                     'text'  => $text,
  253.                     'tags'  => $tags,
  254.                 ]);
  255.  
  256.                 clearCache(['statArticles', 'recentArticles']);
  257.                 setFlash('success', __('blogs.article_success_edited'));
  258.                 redirect('/articles/' . $article->id);
  259.             } else {
  260.                 setInput($request->all());
  261.                 setFlash('danger', $validator->getErrors());
  262.             }
  263.         }
  264.  
  265.         return view('admin/blogs/edit_blog', compact('article'));
  266.     }
  267.  
  268.     /**
  269.      * Перенос статьи
  270.      *
  271.      * @param int       $id
  272.      * @param Request   $request
  273.      * @param Validator $validator
  274.      *
  275.      * @return string
  276.      */
  277.     public function moveArticle(int $id, Request $request, Validator $validator): string
  278.     {
  279.         /** @var Article $article */
  280.         $article = Article::query()->find($id);
  281.  
  282.         if (! $article) {
  283.             abort(404, __('blogs.article_not_exist'));
  284.         }
  285.  
  286.         if ($request->isMethod('post')) {
  287.             $cid = int($request->input('cid'));
  288.  
  289.             /** @var Blog $category */
  290.             $category = Blog::query()->find($cid);
  291.  
  292.             $validator
  293.                 ->equal($request->input('token'), $_SESSION['token'], __('validator.token'))
  294.                 ->notEmpty($category, ['cid' => __('blogs.category_not_exist')]);
  295.  
  296.             if ($category) {
  297.                 $validator->empty($category->closed, ['cid' => __('blogs.category_closed')]);
  298.                 $validator->notEqual($article->category_id, $category->id, ['cid' => __('blogs.article_error_moving')]);
  299.             }
  300.  
  301.             if ($validator->isValid()) {
  302.                 // Обновление счетчиков
  303.                 $category->increment('count_articles');
  304.                 Blog::query()->where('id', $article->category_id)->decrement('count_articles');
  305.  
  306.                 $article->update([
  307.                     'category_id' => $category->id,
  308.                 ]);
  309.  
  310.                 setFlash('success', __('blogs.article_success_moved'));
  311.                 redirect('/articles/' . $article->id);
  312.             } else {
  313.                 setInput($request->all());
  314.                 setFlash('danger', $validator->getErrors());
  315.             }
  316.         }
  317.  
  318.         $categories = Blog::query()
  319.             ->where('parent_id', 0)
  320.             ->with('children')
  321.             ->orderBy('sort')
  322.             ->get();
  323.  
  324.         return view('admin/blogs/move_blog', compact('article', 'categories'));
  325.     }
  326.  
  327.     /**
  328.      * Удаление статьи
  329.      *
  330.      * @param int       $id
  331.      * @param Request   $request
  332.      * @param Validator $validator
  333.      *
  334.      * @return void
  335.      * @throws Exception
  336.      */
  337.     public function deleteArticle(int $id, Request $request, Validator $validator): void
  338.     {
  339.         $page = int($request->input('page', 1));
  340.  
  341.         /** @var Article $article */
  342.         $article = Article::query()->find($id);
  343.  
  344.         if (! $article) {
  345.             abort(404, __('blogs.article_not_exist'));
  346.         }
  347.  
  348.         $validator->equal($request->input('token'), $_SESSION['token'], __('validator.token'));
  349.  
  350.         if ($validator->isValid()) {
  351.             $article->comments()->delete();
  352.             $article->delete();
  353.  
  354.             $article->category->decrement('count_articles');
  355.  
  356.             clearCache(['statArticles', 'recentArticles']);
  357.             setFlash('success', __('blogs.article_success_deleted'));
  358.         } else {
  359.             setFlash('danger', $validator->getErrors());
  360.         }
  361.  
  362.         redirect('/admin/blogs/' . $article->category_id . '?page=' . $page);
  363.     }
  364. }