PaginateHelper::paginateData() - Code Metrics - Inspection of "Merge pull request #250 from KIClubinfo/v2.8.6" - KIClubinfo/upont - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 845964...864a7b )

by Louis

created 2017-06-21 12:55 UTC

PaginateHelper::paginateData() F

↳ Parent: PaginateHelper

Complexity

Conditions	16
Paths	1024

Size

Total Lines	80
Code Lines	52

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	80
rs	2.1086
c	0
b	0
f	0
cc	16
eloc	52
nc	1024
nop	2

How to fix Long Method Complexity

<?php

namespace KI\CoreBundle\Helper;

use Doctrine\ORM\EntityManager;
use Doctrine\ORM\EntityRepository;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\HttpFoundation\RequestStack;
use Symfony\Component\HttpFoundation\Response;

class PaginateHelper
{
    protected $manager;
    protected $request;

    public function __construct(EntityManager $manager)
function someFunction(ManagerRegistry $registry) {
    $em = $registry->getManager();
    $em->getConnection()->beginTransaction();
    try {
        // Do something.
        $em->getConnection()->commit();
    } catch (\Exception $ex) {
        $em->getConnection()->rollback();
        $em->close();

        throw $ex;
    }
}
    {
        $this->manager = $manager;
    }

    public function setRequest(RequestStack $requestStack)
    {
        $this->request = $requestStack->getCurrentRequest();
    }

    /**
     * En fonction de la requête, récupère les données utiles à la pagination
     * @param  EntityRepository $repository Le repository sur lequel effectuer les comptes
     * @return array                        Les données de pagination (nombre de pages, etc.)
     */
    public function paginateData(EntityRepository $repository, array $findBy = [])
    {
        $queryBuilder = $repository->createQueryBuilder('o');
        $request = $this->request->query;

        // On s'assure de bien recevoir des arrays
        foreach ($findBy as $key => $value) {
            $findBy[$key] = array($value);
        }

        // On récupère les paramètres de la requête
        $page  = $request->has('page') ? $request->get('page') : 1;
        $limit = $request->has('limit') ? $request->get('limit') : 100;
        $sort  = $request->has('sort') ? $request->get('sort') : null;

        if ($sort === null) {
            $sortBy = ['id' => 'DESC'];
        } else {
            $sortBy = [];

            foreach (explode(',', $sort) as $value) {
                $order = preg_match('/^\-.*/isU', $value) ? 'DESC' : 'ASC';
                $field = preg_replace('/^\-/isU', '', $value);
                $sortBy[$field] = $order;
            }
        }

        foreach ($request->all() as $key => $values) {
            if ($key != 'page' && $key != 'limit' && $key != 'sort') {
                $findBy[$key] = explode(',', $values);
            }
        }

        // On compte le nombre total d'entrées dans la BDD
        $queryBuilder->select('count(o.id)');
        foreach ($findBy as $key => $values){
            $andCount = 0;
            $and = '';
            foreach($values as $value){
                if($andCount > 0){
                    $and .= ' OR ';
                }
                $and .= 'o.' . $key . ' = :' . $key . $andCount;
                $queryBuilder->setParameter($key . $andCount, $value);

                $andCount++;
            }
            $queryBuilder->andWhere($and);
        }

        foreach($sortBy as $field => $order){
            $queryBuilder->addOrderBy('o.' . $field, $order);
        }

        $count = $queryBuilder->getQuery()->getSingleScalarResult();

        // On vérifie que l'utilisateur ne fasse pas de connerie avec les variables
        $totalPages = ceil($count/$limit);
        $limit = min($limit, 10000);
        $limit = max($limit, 1);
        $page  = min($page, $totalPages);
        $page  = max($page, 1);

        $results = $queryBuilder->select('o')
                    ->setMaxResults($limit)
                    ->setFirstResult(($page - 1)*$limit)
                    ->getQuery()
                    ->getResult();

        return [
            'findBy'     => $findBy,
            'sortBy'     => $sortBy,
            'limit'      => $limit,
            'offset'     => ($page - 1)*$limit,
            'page'       => $page,
            'totalPages' => $totalPages,
            'count'      => $count,
            'results'    => $results,
        ];
    }

    /**
     * Génère les headers de pagination et renvoie la réponse
     * @param  array   $results    Les résultats à paginer
     * @param  integer $limit      Le nombre d'objets par page
     * @param  integer $page       Le numéro de la page en cours
     * @param  integer $totalPages Le nombre total de pages
     * @param  integer $count      Le nombre total d'objets
     * @return Response
     */
    public function paginateView($results, $limit, $page, $totalPages, $count)
    {
        // On prend l'url de la requête
        $baseUrl = '<'.str_replace($this->request->getBaseUrl(), '', $this->request->getRequestUri());

        // On enlève tous les paramètres GET de type "page" et "limit" précédents s'il y en avait
        $baseUrl = preg_replace('/[\?&](page|limit)=\d+/', '', $baseUrl);
        $baseUrl .= !preg_match('/\?/', $baseUrl) ? '?' : '&';

        // On va générer les notres pour les links
        $baseUrl .= 'page=';
        $links = [];

        // First
        $links[] = $baseUrl.'1'.'&limit='.$limit.'>;rel=first';

        // Previous
        if ($page > 1) {
            $links[] = $baseUrl.($page - 1).'&limit='.$limit.'>;rel=previous';
        }

        // Self
        $links[] = $baseUrl.$page.'&limit='.$limit.'>;rel=self';

        // Next
        if ($page < $totalPages) {
            $links[] = $baseUrl.($page + 1).'&limit='.$limit.'>;rel=next';
        }

        // Last
        $links[] = $baseUrl.$totalPages.'&limit='.$limit.'>;rel=last';

        return [
            $results,
            $links,
            $count
        ];
    }
}


1		<?php
2
3		namespace KI\CoreBundle\Helper;
4
5		use Doctrine\ORM\EntityManager;
6		use Doctrine\ORM\EntityRepository;
7		use Symfony\Component\HttpFoundation\JsonResponse;
8		use Symfony\Component\HttpFoundation\RequestStack;
9		use Symfony\Component\HttpFoundation\Response;
10
11		class PaginateHelper
12		{
13		protected $manager;
14		protected $request;
15
16		public function __construct(EntityManager $manager)
		0 ignored issues – show Bug introduced 2016-01-22 12:38 UTC by Report Bug Copy Issue Report You have injected the EntityManager via parameter `$manager`. This is generally not recommended as it might get closed and become unusable. Instead, it is recommended to inject the ManagerRegistry and retrieve the EntityManager via `getManager()` each time you need it. The `EntityManager` might become unusable for example if a transaction is rolled back and it gets closed. Let’s assume that somewhere in your application, or in a third-party library, there is code such as the following: function someFunction(ManagerRegistry $registry) { $em = $registry->getManager(); $em->getConnection()->beginTransaction(); try { // Do something. $em->getConnection()->commit(); } catch (\Exception $ex) { $em->getConnection()->rollback(); $em->close(); throw $ex; } } If that code throws an exception and the `EntityManager` is closed. Any other code which depends on the same instance of the `EntityManager` during this request will fail. On the other hand, if you instead inject the `ManagerRegistry`, the `getManager()` method guarantees that you will always get a usable manager instance. Loading history...
17		{
18		$this->manager = $manager;
19		}
20
21		public function setRequest(RequestStack $requestStack)
22		{
23		$this->request = $requestStack->getCurrentRequest();
24		}
25
26		/**
27		* En fonction de la requête, récupère les données utiles à la pagination
28		* @param EntityRepository $repository Le repository sur lequel effectuer les comptes
29		* @return array Les données de pagination (nombre de pages, etc.)
30		*/
31		public function paginateData(EntityRepository $repository, array $findBy = [])
32		{
33		$queryBuilder = $repository->createQueryBuilder('o');
34		$request = $this->request->query;
35
36		// On s'assure de bien recevoir des arrays
37		foreach ($findBy as $key => $value) {
38		$findBy[$key] = array($value);
39		}
40
41		// On récupère les paramètres de la requête
42		$page = $request->has('page') ? $request->get('page') : 1;
43		$limit = $request->has('limit') ? $request->get('limit') : 100;
44		$sort = $request->has('sort') ? $request->get('sort') : null;
45
46		if ($sort === null) {
47		$sortBy = ['id' => 'DESC'];
48		} else {
49		$sortBy = [];
50
51		foreach (explode(',', $sort) as $value) {
52		$order = preg_match('/^\-.*/isU', $value) ? 'DESC' : 'ASC';
53		$field = preg_replace('/^\-/isU', '', $value);
54		$sortBy[$field] = $order;
55		}
56		}
57
58		foreach ($request->all() as $key => $values) {
59		if ($key != 'page' && $key != 'limit' && $key != 'sort') {
60		$findBy[$key] = explode(',', $values);
61		}
62		}
63
64		// On compte le nombre total d'entrées dans la BDD
65		$queryBuilder->select('count(o.id)');
66		foreach ($findBy as $key => $values){
67		$andCount = 0;
68		$and = '';
69		foreach($values as $value){
70		if($andCount > 0){
71		$and .= ' OR ';
72		}
73		$and .= 'o.' . $key . ' = :' . $key . $andCount;
74		$queryBuilder->setParameter($key . $andCount, $value);
75
76		$andCount++;
77		}
78		$queryBuilder->andWhere($and);
79		}
80
81		foreach($sortBy as $field => $order){
82		$queryBuilder->addOrderBy('o.' . $field, $order);
83		}
84
85		$count = $queryBuilder->getQuery()->getSingleScalarResult();
86
87		// On vérifie que l'utilisateur ne fasse pas de connerie avec les variables
88		$totalPages = ceil($count/$limit);
89		$limit = min($limit, 10000);
90		$limit = max($limit, 1);
91		$page = min($page, $totalPages);
92		$page = max($page, 1);
93
94		$results = $queryBuilder->select('o')
95		->setMaxResults($limit)
96		->setFirstResult(($page - 1)*$limit)
97		->getQuery()
98		->getResult();
99
100		return [
101		'findBy' => $findBy,
102		'sortBy' => $sortBy,
103		'limit' => $limit,
104		'offset' => ($page - 1)*$limit,
105		'page' => $page,
106		'totalPages' => $totalPages,
107		'count' => $count,
108		'results' => $results,
109		];
110		}
111
112		/**
113		* Génère les headers de pagination et renvoie la réponse
114		* @param array $results Les résultats à paginer
115		* @param integer $limit Le nombre d'objets par page
116		* @param integer $page Le numéro de la page en cours
117		* @param integer $totalPages Le nombre total de pages
118		* @param integer $count Le nombre total d'objets
119		* @return Response
120		*/
121		public function paginateView($results, $limit, $page, $totalPages, $count)
122		{
123		// On prend l'url de la requête
124		$baseUrl = '<'.str_replace($this->request->getBaseUrl(), '', $this->request->getRequestUri());
125
126		// On enlève tous les paramètres GET de type "page" et "limit" précédents s'il y en avait
127		$baseUrl = preg_replace('/[\?&](page\|limit)=\d+/', '', $baseUrl);
128		$baseUrl .= !preg_match('/\?/', $baseUrl) ? '?' : '&';
129
130		// On va générer les notres pour les links
131		$baseUrl .= 'page=';
132		$links = [];
133
134		// First
135		$links[] = $baseUrl.'1'.'&limit='.$limit.'>;rel=first';
136
137		// Previous
138	View Code Duplication	if ($page > 1) {
139		$links[] = $baseUrl.($page - 1).'&limit='.$limit.'>;rel=previous';
140		}
141
142		// Self
143		$links[] = $baseUrl.$page.'&limit='.$limit.'>;rel=self';
144
145		// Next
146	View Code Duplication	if ($page < $totalPages) {
147		$links[] = $baseUrl.($page + 1).'&limit='.$limit.'>;rel=next';
148		}
149
150		// Last
151		$links[] = $baseUrl.$totalPages.'&limit='.$limit.'>;rel=last';
152
153		return [
154		$results,
155		$links,
156		$count
157		];
158		}
159		}
160

KIClubinfo / upont

Push — master ( 845964...864a7b )

PaginateHelper::paginateData() F

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like