PostController - Code Metrics - Inspection of "#43 feat: add api docs for post actions" - cslant/blog-api-package - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — main (#51)

unknown

created 2025-03-13 04:24 UTC

PostController A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	354
Duplicated Lines	0 %

Importance

Changes	10
Bugs	3	Features	3

Metric	Value
wmc	5
eloc	243
c	10
b	3
f	3
dl	0
loc	354
rs	10

3 Methods

Rating	Name	Size	Complexity
B	index()	80	1
B	findBySlug()	88	3
B	getFilters()	161	1

<?php

namespace CSlant\Blog\Api\Http\Controllers;

use Botble\Base\Http\Responses\BaseHttpResponse;
filter:
    dependency_paths: ["lib/*"]
use CSlant\Blog\Api\Enums\StatusEnum;
use CSlant\Blog\Api\Http\Resources\ListPostResource;
use CSlant\Blog\Api\Http\Resources\PostResource;
use CSlant\Blog\Api\OpenApi\Schemas\Resources\Post\PostListResourceSchema;
use CSlant\Blog\Api\OpenApi\Schemas\Resources\Post\PostModelResourceSchema;
use CSlant\Blog\Core\Facades\Base\SlugHelper;
use CSlant\Blog\Core\Http\Controllers\Base\BasePostController;
use CSlant\Blog\Core\Models\Post;
use CSlant\Blog\Core\Models\Slug;
use CSlant\Blog\Core\Supports\Base\FilterPost;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use Illuminate\Http\Resources\Json\JsonResource;
use OpenApi\Attributes\Get;
use OpenApi\Attributes\Items;
use OpenApi\Attributes\JsonContent;
use OpenApi\Attributes\Parameter;
use OpenApi\Attributes\Property;
use OpenApi\Attributes\Response;
use OpenApi\Attributes\Schema;

/**
 * Class PostController
 *
 * @package CSlant\Blog\Api\Http\Controllers
 *
 * @group Blog API
 *
 * @authenticated
 *
 * @method BaseHttpResponse httpResponse()
 * @method BaseHttpResponse setData(mixed $data)
 * @method BaseHttpResponse|JsonResource|JsonResponse|RedirectResponse toApiResponse()
 */
class PostController extends BasePostController
{
    /**
     * @group Blog API
     *
     * @param  Request  $request
     *
     * @return BaseHttpResponse|JsonResource|JsonResponse|RedirectResponse
     */
    #[
        Get(
            path: "/posts",
            operationId: "postGetAllWithFilter",
            description: "Get all posts with pagination (10 items per page by default, page 1 by default)

    This API will get records from the database and return them as a paginated list. 
    The default number of items per page is 10 and the default page number is 1. You can change these values by passing the `per_page` and `page` query parameters.
            ",
            summary: "Get all posts with pagination",
            tags: ["Post"],
            parameters: [
                new Parameter(
                    name: 'per_page',
                    description: 'Number of items per page',
                    in: 'query',
                    required: false,
                    schema: new Schema(type: 'integer', default: 10)
                ),
                new Parameter(
                    name: 'page',
                    description: 'Page number',
                    in: 'query',
                    required: false,
                    schema: new Schema(type: 'integer', default: 1)
                ),
            ],
            responses: [
                new Response(
                    response: 200,
                    description: "Get posts successfully",
                    content: new JsonContent(
                        properties: [
                            new Property(
                                property: 'error',
                                description: 'Error status',
                                type: 'boolean',
                                default: false
                            ),
                            new Property(
                                property: "data",
                                description: "Data of model",
                                type: "array",
                                items: new Items(ref: PostListResourceSchema::class)
                            ),
                        ]
                    )
                ),
                new Response(
                    ref: \CSlant\Blog\Api\OpenApi\Responses\Errors\BadRequestResponseSchema::class,
                    response: 400,
                ),
                new Response(
                    ref: \CSlant\Blog\Api\OpenApi\Responses\Errors\ErrorNotFoundResponseSchema::class,
                    response: 404,
                ),
                new Response(
                    ref: \CSlant\Blog\Api\OpenApi\Responses\Errors\InternalServerResponseSchema::class,
                    response: 500,
                ),
            ]
        )
    ]
    public function index(Request $request): BaseHttpResponse|JsonResponse|JsonResource|RedirectResponse
    {
        $data = $this
            ->postRepository
            ->advancedGet([
                'with' => ['tags', 'categories', 'author', 'slugable'],
                'condition' => ['status' => StatusEnum::PUBLISHED->value],
                'paginate' => [
                    'per_page' => $request->integer('per_page', 10),
                    'current_paged' => $request->integer('page', 1),
                ],
            ]);

        return $this
            ->httpResponse()
            ->setData(ListPostResource::collection($data))
            ->toApiResponse();
    }

    /**
     * @param  string  $slug
     *
     * @group Blog
     * @queryParam slug Find by slug of post.
     * @return BaseHttpResponse|JsonResource|JsonResponse|RedirectResponse
     */
    #[
        Get(
            path: "/posts/{slug}",
            operationId: "postFilterBySlug",
            description: "Get the post by slug
            
    This API will get records from the database and return the post by slug.
            ",
            summary: "Get post by slug",
            tags: ["Post"],
            parameters: [
                new Parameter(
                    name: 'slug',
                    description: 'Post slug',
                    in: 'path',
                    required: true,
                    schema: new Schema(type: 'string', example: 'php')
                ),
            ],
            responses: [
                new Response(
                    response: 200,
                    description: "Get post successfully",
                    content: new JsonContent(
                        properties: [
                            new Property(
                                property: 'error',
                                description: 'Error status',
                                type: 'boolean',
                                default: false
                            ),
                            new Property(
                                property: "data",
                                ref: PostModelResourceSchema::class,
                                description: "Data of model",
                                type: "object",
                            ),
                        ]
                    )
                ),
                new Response(
                    ref: \CSlant\Blog\Api\OpenApi\Responses\Errors\BadRequestResponseSchema::class,
                    response: 400,
                ),
                new Response(
                    ref: \CSlant\Blog\Api\OpenApi\Responses\Errors\ErrorNotFoundResponseSchema::class,
                    response: 404,
                ),
                new Response(
                    ref: \CSlant\Blog\Api\OpenApi\Responses\Errors\InternalServerResponseSchema::class,
                    response: 500,
                ),
            ]
        )
    ]
    public function findBySlug(string $slug): BaseHttpResponse|JsonResponse|JsonResource|RedirectResponse
    {
        /** @var Slug $slug */
        $slug = SlugHelper::getSlug($slug, SlugHelper::getPrefix(Post::getBaseModel()));

        if (!$slug) {

            return $this
                ->httpResponse()
                ->setError()
                ->setCode(404)
                ->setMessage('Not found');
        }

        $post = Post::query()
            ->with(['tags', 'categories', 'author'])
            ->where([
                'id' => $slug->reference_id,
                'status' => StatusEnum::PUBLISHED,
            ])
            ->first();

        if (!$post) {
            return $this
                ->httpResponse()
                ->setError()
                ->setCode(404)
                ->setMessage('Not found');
        }

        return $this
            ->httpResponse()
            ->setData(new PostResource($post))
            ->toApiResponse();
    }

    /**
     * @param  Request  $request
     *
     * @return BaseHttpResponse|JsonResource|JsonResponse|RedirectResponse
     */
    #[
        Get(
            path: "/posts/filters",
            operationId: "postGetWithFilter",
            description: "Get all posts with pagination (10 items per page by default, page 1 by default)
            
    This API will get records from the database and return them as a paginated list. 
    The default number of items per page is 10 and the default page number is 1. You can change these values by passing the `per_page` and `page` query parameters.
            ",
            summary: "Get posts by filter with pagination",
            tags: ["Post"],
            parameters: [
                new Parameter(
                    name: 'categories',
                    description: 'Filter of items categories',
                    in: 'query',
                    required: false,
                    schema: new Schema(
                        type: 'array',
                        default: null,
                        items: new Items(type: 'integer')
                    )
                ),
                new Parameter(
                    name: 'categories_exclude',
                    description: 'Filter of items categories exclude',
                    in: 'query',
                    required: false,
                    schema: new Schema(
                        type: 'array',
                        default: null,
                        items: new Items(type: 'integer')
                    )
                ),
                new Parameter(
                    name: 'exclude',
                    description: 'Filter of items exclude',
                    in: 'query',
                    required: false,
                    schema: new Schema(
                        type: 'array',
                        default: null,
                        items: new Items(type: 'integer')
                    )
                ),
                new Parameter(
                    name: 'include',
                    description: 'Filter of items include',
                    in: 'query',
                    required: false,
                    schema: new Schema(
                        type: 'array',
                        default: null,
                        items: new Items(type: 'integer')
                    )
                ),
                new Parameter(
                    name: 'author',
                    description: 'Filter of items author',
                    in: 'query',
                    required: false,
                    schema: new Schema(
                        type: 'array',
                        default: null,
                        items: new Items(type: 'integer')
                    )
                ),
                new Parameter(
                    name: 'author_exclude',
                    description: 'Filter of items author exclude',
                    in: 'query',
                    required: false,
                    schema: new Schema(
                        type: 'array',
                        default: null,
                        items: new Items(type: 'integer')
                    )
                ),
                new Parameter(
                    name: 'featured',
                    description: 'Filter of items featured',
                    in: 'query',
                    required: false,
                    schema: new Schema(
                        type: 'array',
                        default: null,
                        items: new Items(type: 'integer')
                    )
                ),
                new Parameter(
                    name: 'search',
                    description: 'Filter of items search in name and description',
                    in: 'query',
                    required: false,
                    schema: new Schema(
                        type: 'array',
                        default: null,
                        items: new Items(type: 'integer')
                    )
                ),
                new Parameter(
                    name: 'per_page',
                    description: 'Number of items per page',
                    in: 'query',
                    required: false,
                    schema: new Schema(type: 'integer', default: 10)
                ),
                new Parameter(
                    name: 'page',
                    description: 'Page number',
                    in: 'query',
                    required: false,
                    schema: new Schema(type: 'integer', default: 1)
                ),
            ],
            responses: [
                new Response(
                    response: 200,
                    description: "Get posts successfully",
                    content: new JsonContent(
                        properties: [
                            new Property(
                                property: 'error',
                                description: 'Error status',
                                type: 'boolean',
                                default: false
                            ),
                            new Property(
                                property: "data",
                                description: "Data of model",
                                type: "array",
                                items: new Items(ref: PostListResourceSchema::class)
                            ),
                        ]
                    )
                ),
                new Response(
                    ref: \CSlant\Blog\Api\OpenApi\Responses\Errors\BadRequestResponseSchema::class,
                    response: 400,
                ),
                new Response(
                    ref: \CSlant\Blog\Api\OpenApi\Responses\Errors\ErrorNotFoundResponseSchema::class,
                    response: 404,
                ),
                new Response(
                    ref: \CSlant\Blog\Api\OpenApi\Responses\Errors\InternalServerResponseSchema::class,
                    response: 500,
                ),
            ]
        )
    ]
    public function getFilters(Request $request): BaseHttpResponse|JsonResponse|JsonResource|RedirectResponse
    {
        $filters = FilterPost::setFilters($request->input());

        $data = $this->postRepository->getFilters((array) $filters);

        return $this
            ->httpResponse()
            ->setData(ListPostResource::collection($data))
            ->toApiResponse();
    }
}


1			<?php
2
3			namespace CSlant\Blog\Api\Http\Controllers;
4
5			use Botble\Base\Http\Responses\BaseHttpResponse;
			0 ignored issues – show Bug introduced 2025-02-08 07:12 UTC by Report Bug Copy Issue Report The type `Botble\Base\Http\Responses\BaseHttpResponse` was not found. Maybe you did not declare it correctly or list all dependencies? The issue could also be caused by a filter entry in the build configuration. If the path has been excluded in your configuration, e.g. `excluded_paths: ["lib/"]`, you can move it to the dependency path list as follows: filter: dependency_paths: ["lib/"] For further information see https://scrutinizer-ci.com/docs/tools/php/php-scrutinizer/#list-dependency-paths Loading history...
6			use CSlant\Blog\Api\Enums\StatusEnum;
7			use CSlant\Blog\Api\Http\Resources\ListPostResource;
8			use CSlant\Blog\Api\Http\Resources\PostResource;
9			use CSlant\Blog\Api\OpenApi\Schemas\Resources\Post\PostListResourceSchema;
10			use CSlant\Blog\Api\OpenApi\Schemas\Resources\Post\PostModelResourceSchema;
11			use CSlant\Blog\Core\Facades\Base\SlugHelper;
12			use CSlant\Blog\Core\Http\Controllers\Base\BasePostController;
13			use CSlant\Blog\Core\Models\Post;
14			use CSlant\Blog\Core\Models\Slug;
15			use CSlant\Blog\Core\Supports\Base\FilterPost;
16			use Illuminate\Http\JsonResponse;
17			use Illuminate\Http\RedirectResponse;
18			use Illuminate\Http\Request;
19			use Illuminate\Http\Resources\Json\JsonResource;
20			use OpenApi\Attributes\Get;
21			use OpenApi\Attributes\Items;
22			use OpenApi\Attributes\JsonContent;
23			use OpenApi\Attributes\Parameter;
24			use OpenApi\Attributes\Property;
25			use OpenApi\Attributes\Response;
26			use OpenApi\Attributes\Schema;
27
28			/**
29			* Class PostController
30			*
31			* @package CSlant\Blog\Api\Http\Controllers
32			*
33			* @group Blog API
34			*
35			* @authenticated
36			*
37			* @method BaseHttpResponse httpResponse()
38			* @method BaseHttpResponse setData(mixed $data)
39			* @method BaseHttpResponse\|JsonResource\|JsonResponse\|RedirectResponse toApiResponse()
40			*/
41			class PostController extends BasePostController
42			{
43			/**
44			* @group Blog API
45			*
46			* @param Request $request
47			*
48			* @return BaseHttpResponse\|JsonResource\|JsonResponse\|RedirectResponse
49			*/
50			#[
51			Get(
52			path: "/posts",
53			operationId: "postGetAllWithFilter",
54			description: "Get all posts with pagination (10 items per page by default, page 1 by default)
55
56			This API will get records from the database and return them as a paginated list.
57			The default number of items per page is 10 and the default page number is 1. You can change these values by passing the `per_page` and `page` query parameters.
58			",
59			summary: "Get all posts with pagination",
60			tags: ["Post"],
61			parameters: [
62			new Parameter(
63			name: 'per_page',
64			description: 'Number of items per page',
65			in: 'query',
66			required: false,
67			schema: new Schema(type: 'integer', default: 10)
68			),
69			new Parameter(
70			name: 'page',
71			description: 'Page number',
72			in: 'query',
73			required: false,
74			schema: new Schema(type: 'integer', default: 1)
75			),
76			],
77			responses: [
78			new Response(
79			response: 200,
80			description: "Get posts successfully",
81			content: new JsonContent(
82			properties: [
83			new Property(
84			property: 'error',
85			description: 'Error status',
86			type: 'boolean',
87			default: false
88			),
89			new Property(
90			property: "data",
91			description: "Data of model",
92			type: "array",
93			items: new Items(ref: PostListResourceSchema::class)
94			),
95			]
96			)
97			),
98			new Response(
99			ref: \CSlant\Blog\Api\OpenApi\Responses\Errors\BadRequestResponseSchema::class,
100			response: 400,
101			),
102			new Response(
103			ref: \CSlant\Blog\Api\OpenApi\Responses\Errors\ErrorNotFoundResponseSchema::class,
104			response: 404,
105			),
106			new Response(
107			ref: \CSlant\Blog\Api\OpenApi\Responses\Errors\InternalServerResponseSchema::class,
108			response: 500,
109			),
110			]
111			)
112			]
113			public function index(Request $request): BaseHttpResponse\|JsonResponse\|JsonResource\|RedirectResponse
114			{
115			$data = $this
116			->postRepository
117			->advancedGet([
118			'with' => ['tags', 'categories', 'author', 'slugable'],
119			'condition' => ['status' => StatusEnum::PUBLISHED->value],
120			'paginate' => [
121			'per_page' => $request->integer('per_page', 10),
122			'current_paged' => $request->integer('page', 1),
123			],
124			]);
125
126			return $this
127			->httpResponse()
128			->setData(ListPostResource::collection($data))
129			->toApiResponse();
130			}
131
132			/**
133			* @param string $slug
134			*
135			* @group Blog
136			* @queryParam slug Find by slug of post.
137			* @return BaseHttpResponse\|JsonResource\|JsonResponse\|RedirectResponse
138			*/
139			#[
140			Get(
141			path: "/posts/{slug}",
142			operationId: "postFilterBySlug",
143			description: "Get the post by slug
144
145			This API will get records from the database and return the post by slug.
146			",
147			summary: "Get post by slug",
148			tags: ["Post"],
149			parameters: [
150			new Parameter(
151			name: 'slug',
152			description: 'Post slug',
153			in: 'path',
154			required: true,
155			schema: new Schema(type: 'string', example: 'php')
156			),
157			],
158			responses: [
159			new Response(
160			response: 200,
161			description: "Get post successfully",
162			content: new JsonContent(
163			properties: [
164			new Property(
165			property: 'error',
166			description: 'Error status',
167			type: 'boolean',
168			default: false
169			),
170			new Property(
171			property: "data",
172			ref: PostModelResourceSchema::class,
173			description: "Data of model",
174			type: "object",
175			),
176			]
177			)
178			),
179			new Response(
180			ref: \CSlant\Blog\Api\OpenApi\Responses\Errors\BadRequestResponseSchema::class,
181			response: 400,
182			),
183			new Response(
184			ref: \CSlant\Blog\Api\OpenApi\Responses\Errors\ErrorNotFoundResponseSchema::class,
185			response: 404,
186			),
187			new Response(
188			ref: \CSlant\Blog\Api\OpenApi\Responses\Errors\InternalServerResponseSchema::class,
189			response: 500,
190			),
191			]
192			)
193			]
194			public function findBySlug(string $slug): BaseHttpResponse\|JsonResponse\|JsonResource\|RedirectResponse
195			{
196			/** @var Slug $slug */
197			$slug = SlugHelper::getSlug($slug, SlugHelper::getPrefix(Post::getBaseModel()));
198
199			if (!$slug) {
			0 ignored issues – show introduced 2025-01-08 17:23 UTC by Report Bug Copy Issue Report `$slug` is of type `CSlant\Blog\Core\Models\Slug`, thus it always evaluated to `true`. Loading history...
200			return $this
201			->httpResponse()
202			->setError()
203			->setCode(404)
204			->setMessage('Not found');
205			}
206
207			$post = Post::query()
208			->with(['tags', 'categories', 'author'])
209			->where([
210			'id' => $slug->reference_id,
211			'status' => StatusEnum::PUBLISHED,
212			])
213			->first();
214
215			if (!$post) {
216			return $this
217			->httpResponse()
218			->setError()
219			->setCode(404)
220			->setMessage('Not found');
221			}
222
223			return $this
224			->httpResponse()
225			->setData(new PostResource($post))
226			->toApiResponse();
227			}
228
229			/**
230			* @param Request $request
231			*
232			* @return BaseHttpResponse\|JsonResource\|JsonResponse\|RedirectResponse
233			*/
234			#[
235			Get(
236			path: "/posts/filters",
237			operationId: "postGetWithFilter",
238			description: "Get all posts with pagination (10 items per page by default, page 1 by default)
239
240			This API will get records from the database and return them as a paginated list.
241			The default number of items per page is 10 and the default page number is 1. You can change these values by passing the `per_page` and `page` query parameters.
242			",
243			summary: "Get posts by filter with pagination",
244			tags: ["Post"],
245			parameters: [
246			new Parameter(
247			name: 'categories',
248			description: 'Filter of items categories',
249			in: 'query',
250			required: false,
251			schema: new Schema(
252			type: 'array',
253			default: null,
254			items: new Items(type: 'integer')
255			)
256			),
257			new Parameter(
258			name: 'categories_exclude',
259			description: 'Filter of items categories exclude',
260			in: 'query',
261			required: false,
262			schema: new Schema(
263			type: 'array',
264			default: null,
265			items: new Items(type: 'integer')
266			)
267			),
268			new Parameter(
269			name: 'exclude',
270			description: 'Filter of items exclude',
271			in: 'query',
272			required: false,
273			schema: new Schema(
274			type: 'array',
275			default: null,
276			items: new Items(type: 'integer')
277			)
278			),
279			new Parameter(
280			name: 'include',
281			description: 'Filter of items include',
282			in: 'query',
283			required: false,
284			schema: new Schema(
285			type: 'array',
286			default: null,
287			items: new Items(type: 'integer')
288			)
289			),
290			new Parameter(
291			name: 'author',
292			description: 'Filter of items author',
293			in: 'query',
294			required: false,
295			schema: new Schema(
296			type: 'array',
297			default: null,
298			items: new Items(type: 'integer')
299			)
300			),
301			new Parameter(
302			name: 'author_exclude',
303			description: 'Filter of items author exclude',
304			in: 'query',
305			required: false,
306			schema: new Schema(
307			type: 'array',
308			default: null,
309			items: new Items(type: 'integer')
310			)
311			),
312			new Parameter(
313			name: 'featured',
314			description: 'Filter of items featured',
315			in: 'query',
316			required: false,
317			schema: new Schema(
318			type: 'array',
319			default: null,
320			items: new Items(type: 'integer')
321			)
322			),
323			new Parameter(
324			name: 'search',
325			description: 'Filter of items search in name and description',
326			in: 'query',
327			required: false,
328			schema: new Schema(
329			type: 'array',
330			default: null,
331			items: new Items(type: 'integer')
332			)
333			),
334			new Parameter(
335			name: 'per_page',
336			description: 'Number of items per page',
337			in: 'query',
338			required: false,
339			schema: new Schema(type: 'integer', default: 10)
340			),
341			new Parameter(
342			name: 'page',
343			description: 'Page number',
344			in: 'query',
345			required: false,
346			schema: new Schema(type: 'integer', default: 1)
347			),
348			],
349			responses: [
350			new Response(
351			response: 200,
352			description: "Get posts successfully",
353			content: new JsonContent(
354			properties: [
355			new Property(
356			property: 'error',
357			description: 'Error status',
358			type: 'boolean',
359			default: false
360			),
361			new Property(
362			property: "data",
363			description: "Data of model",
364			type: "array",
365			items: new Items(ref: PostListResourceSchema::class)
366			),
367			]
368			)
369			),
370			new Response(
371			ref: \CSlant\Blog\Api\OpenApi\Responses\Errors\BadRequestResponseSchema::class,
372			response: 400,
373			),
374			new Response(
375			ref: \CSlant\Blog\Api\OpenApi\Responses\Errors\ErrorNotFoundResponseSchema::class,
376			response: 404,
377			),
378			new Response(
379			ref: \CSlant\Blog\Api\OpenApi\Responses\Errors\InternalServerResponseSchema::class,
380			response: 500,
381			),
382			]
383			)
384			]
385			public function getFilters(Request $request): BaseHttpResponse\|JsonResponse\|JsonResource\|RedirectResponse
386			{
387			$filters = FilterPost::setFilters($request->input());
388
389			$data = $this->postRepository->getFilters((array) $filters);
390
391			return $this
392			->httpResponse()
393			->setData(ListPostResource::collection($data))
394			->toApiResponse();
395			}
396			}
397

cslant / blog-api-package

Pull Request — main (#51)

PostController A

Complexity

Size/Duplication

Importance

3 Methods

Duplication Side-by-Side

Filter issues like