PostController::findBySlug() - 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-12 17:00 UTC

PostController::findBySlug() B

↳ Parent: PostController

Complexity

Conditions	3
Paths	3

Size

Total Lines	89
Code Lines	63

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	0	Features	1

Metric	Value
eloc	63
c	2
b	0
f	1
dl	0
loc	89
rs	8.8072
cc	3
nc	3
nop	1

How to fix Long Method

<?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\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",
            security: [['sanctum' => []]],
            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',
                                properties: [
                                    new Property(
                                        property: 'post',
                                        ref: PostListResourceSchema::class,
                                        description: 'Post',
                                        type: 'object'
                                    ),
                                ],
                                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 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",
            security: [['sanctum' => []]],
            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",
            security: [['sanctum' => []]],
            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',
                                properties: [
                                    new Property(
                                        property: 'post',
                                        ref: PostListResourceSchema::class,
                                        description: 'Post',
                                        type: 'object'
                                    ),
                                ],
                                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 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\JsonContent;
22			use OpenApi\Attributes\Parameter;
23			use OpenApi\Attributes\Property;
24			use OpenApi\Attributes\Response;
25			use OpenApi\Attributes\Schema;
26
27			/**
28			* Class PostController
29			*
30			* @package CSlant\Blog\Api\Http\Controllers
31			*
32			* @group Blog API
33			*
34			* @authenticated
35			*
36			* @method BaseHttpResponse httpResponse()
37			* @method BaseHttpResponse setData(mixed $data)
38			* @method BaseHttpResponse\|JsonResource\|JsonResponse\|RedirectResponse toApiResponse()
39			*/
40			class PostController extends BasePostController
41			{
42			/**
43			* @group Blog API
44			*
45			* @param Request $request
46			*
47			* @return BaseHttpResponse\|JsonResource\|JsonResponse\|RedirectResponse
48			*/
49			#[
50			Get(
51			path: "/posts",
52			operationId: "postGetAllWithFilter",
53			description: "Get all posts with pagination (10 items per page by default, page 1 by default)
54
55			This API will get records from the database and return them as a paginated list.
56			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.
57			",
58			summary: "Get all posts with pagination",
59			security: [['sanctum' => []]],
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',
92			properties: [
93			new Property(
94			property: 'post',
95			ref: PostListResourceSchema::class,
96			description: 'Post',
97			type: 'object'
98			),
99			],
100			type: 'object'
101			),
102			]
103			)
104			),
105			new Response(
106			ref: \CSlant\Blog\Api\OpenApi\Responses\Errors\BadRequestResponseSchema::class,
107			response: 400,
108			),
109			new Response(
110			ref: \CSlant\Blog\Api\OpenApi\Responses\Errors\ErrorNotFoundResponseSchema::class,
111			response: 404,
112			),
113			new Response(
114			ref: \CSlant\Blog\Api\OpenApi\Responses\Errors\InternalServerResponseSchema::class,
115			response: 500,
116			),
117			]
118			)
119			]
120			public function index(Request $request): BaseHttpResponse\|JsonResponse\|JsonResource\|RedirectResponse
121			{
122			$data = $this
123			->postRepository
124			->advancedGet([
125			'with' => ['tags', 'categories', 'author', 'slugable'],
126			'condition' => ['status' => StatusEnum::PUBLISHED->value],
127			'paginate' => [
128			'per_page' => $request->integer('per_page', 10),
129			'current_paged' => $request->integer('page', 1),
130			],
131			]);
132
133			return $this
134			->httpResponse()
135			->setData(ListPostResource::collection($data))
136			->toApiResponse();
137			}
138
139			/**
140			* @param string $slug
141			*
142			* @group Blog
143			* @queryParam slug Find by slug of post.
144			* @return BaseHttpResponse\|JsonResource\|JsonResponse\|RedirectResponse
145			*/
146			#[
147			Get(
148			path: "/posts/{slug}",
149			operationId: "postFilterBySlug",
150			description: "Get the post by slug
151
152			This API will get records from the database and return the post by slug.
153			",
154			summary: "Get post by slug",
155			security: [['sanctum' => []]],
156			tags: ["Post"],
157			parameters: [
158			new Parameter(
159			name: 'slug',
160			description: 'Post slug',
161			in: 'path',
162			required: true,
163			schema: new Schema(type: 'string', example: 'php')
164			),
165			],
166			responses: [
167			new Response(
168			response: 200,
169			description: "Get post successfully",
170			content: new JsonContent(
171			properties: [
172			new Property(
173			property: 'error',
174			description: 'Error status',
175			type: 'boolean',
176			default: false
177			),
178			new Property(
179			property: "data",
180			ref: PostModelResourceSchema::class,
181			description: "Data of model",
182			type: "object",
183			),
184			]
185			)
186			),
187			new Response(
188			ref: \CSlant\Blog\Api\OpenApi\Responses\Errors\BadRequestResponseSchema::class,
189			response: 400,
190			),
191			new Response(
192			ref: \CSlant\Blog\Api\OpenApi\Responses\Errors\ErrorNotFoundResponseSchema::class,
193			response: 404,
194			),
195			new Response(
196			ref: \CSlant\Blog\Api\OpenApi\Responses\Errors\InternalServerResponseSchema::class,
197			response: 500,
198			),
199			]
200			)
201			]
202			public function findBySlug(string $slug): BaseHttpResponse\|JsonResponse\|JsonResource\|RedirectResponse
203			{
204			/** @var Slug $slug */
205			$slug = SlugHelper::getSlug($slug, SlugHelper::getPrefix(Post::getBaseModel()));
206
207			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...
208			return $this
209			->httpResponse()
210			->setError()
211			->setCode(404)
212			->setMessage('Not found');
213			}
214
215			$post = Post::query()
216			->with(['tags', 'categories', 'author'])
217			->where([
218			'id' => $slug->reference_id,
219			'status' => StatusEnum::PUBLISHED,
220			])
221			->first();
222
223			if (!$post) {
224			return $this
225			->httpResponse()
226			->setError()
227			->setCode(404)
228			->setMessage('Not found');
229			}
230
231			return $this
232			->httpResponse()
233			->setData(new PostResource($post))
234			->toApiResponse();
235			}
236
237			/**
238			* @param Request $request
239			*
240			* @return BaseHttpResponse\|JsonResource\|JsonResponse\|RedirectResponse
241			*/
242			#[
243			Get(
244			path: "/posts/filters",
245			operationId: "postGetWithFilter",
246			description: "Get all posts with pagination (10 items per page by default, page 1 by default)
247
248			This API will get records from the database and return them as a paginated list.
249			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.
250			",
251			summary: "Get posts by filter with pagination",
252			security: [['sanctum' => []]],
253			tags: ["Post"],
254			parameters: [
255			new Parameter(
256			name: 'per_page',
257			description: 'Number of items per page',
258			in: 'query',
259			required: false,
260			schema: new Schema(type: 'integer', default: 10)
261			),
262			new Parameter(
263			name: 'page',
264			description: 'Page number',
265			in: 'query',
266			required: false,
267			schema: new Schema(type: 'integer', default: 1)
268			),
269			],
270			responses: [
271			new Response(
272			response: 200,
273			description: "Get posts successfully",
274			content: new JsonContent(
275			properties: [
276			new Property(
277			property: 'error',
278			description: 'Error status',
279			type: 'boolean',
280			default: false
281			),
282			new Property(
283			property: 'data',
284			description: 'Data',
285			properties: [
286			new Property(
287			property: 'post',
288			ref: PostListResourceSchema::class,
289			description: 'Post',
290			type: 'object'
291			),
292			],
293			type: 'object'
294			),
295			]
296			)
297			),
298			new Response(
299			ref: \CSlant\Blog\Api\OpenApi\Responses\Errors\BadRequestResponseSchema::class,
300			response: 400,
301			),
302			new Response(
303			ref: \CSlant\Blog\Api\OpenApi\Responses\Errors\ErrorNotFoundResponseSchema::class,
304			response: 404,
305			),
306			new Response(
307			ref: \CSlant\Blog\Api\OpenApi\Responses\Errors\InternalServerResponseSchema::class,
308			response: 500,
309			),
310			]
311			)
312			]
313			public function getFilters(Request $request): BaseHttpResponse\|JsonResponse\|JsonResource\|RedirectResponse
314			{
315			$filters = FilterPost::setFilters($request->input());
316
317			$data = $this->postRepository->getFilters((array) $filters);
318
319			return $this
320			->httpResponse()
321			->setData(ListPostResource::collection($data))
322			->toApiResponse();
323			}
324			}
325

cslant / blog-api-package

Pull Request — main (#51)

PostController::findBySlug() B

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like