Paginator   A
last analyzed

Complexity

Total Complexity 21

Size/Duplication

Total Lines 226
Duplicated Lines 0 %

Coupling/Cohesion

Components 3
Dependencies 1

Importance

Changes 0
Metric Value
dl 0
loc 226
rs 10
c 0
b 0
f 0
wmc 21
lcom 3
cbo 1

14 Methods

Rating   Name   Duplication   Size   Complexity  
A __construct() 0 21 3
A jsonSerialize() 0 4 1
A validPage() 0 7 3
A validCurrent() 0 6 2
A getIterator() 0 4 1
A countQuery() 0 6 1
A totalItems() 0 4 1
A totalPages() 0 4 1
A nextPage() 0 4 2
A prevPage() 0 4 2
A count() 0 4 1
A page() 0 4 1
A getFields() 0 4 1
A getAlias() 0 4 1
1
<?php
2
/**
3
 * KumbiaPHP web & app Framework.
4
 *
5
 * LICENSE
6
 *
7
 * This source file is subject to the new BSD license that is bundled
8
 * with this package in the file LICENSE.txt.
9
 * It is also available through the world-wide-web at this URL:
10
 * http://wiki.kumbiaphp.com/Licencia
11
 * If you did not receive a copy of the license and are unable to
12
 * obtain it through the world-wide-web, please send an email
13
 * to [email protected] so we can send you a copy immediately.
14
 *
15
 * @category   Kumbia
16
 *
17
 * @copyright  2005 - 2016  Kumbia Team (http://www.kumbiaphp.com)
18
 * @license    http://wiki.kumbiaphp.com/Licencia     New BSD License
19
 */
20
21
namespace Kumbia\ActiveRecord;
22
23
/**
24
 * Implementación de paginador.
25
 */
26
class Paginator implements \IteratorAggregate, \Countable, \JsonSerializable
27
{
28
    /**
29
     * Número de página actual.
30
     *
31
     * @var int
32
     */
33
    protected $page;
34
35
    /**
36
     * Cantidad de items por página.
37
     *
38
     * @var int
39
     */
40
    protected $perPage;
41
42
    /**
43
     * Número de páginas totales.
44
     *
45
     * @var int
46
     */
47
    protected $totalPages;
48
49
    /**
50
     * Cantidad de items totales.
51
     *
52
     * @var int
53
     */
54
    protected $count;
55
56
    /**
57
     * Nombre del modelo a usar.
58
     *
59
     * @var string
60
     */
61
    protected $model;
62
63
    /**
64
     * Cadena SQL a ejecutar.
65
     *
66
     * @var string
67
     */
68
    protected $sql;
69
70
    /**
71
     * Párametros de la consulta.
72
     *
73
     * @var array|null
74
     */
75
    protected $values;
76
77
    /**
78
     * Items de pagina.
79
     *
80
     * @var array de objetos
81
     */
82
    private $items;
83
84
    /**
85
     * Constructor.
86
     *
87
     * @param string $model nombre de clase de modelo
88
     * @param string $sql consulta select sql
89
     * @param int $page numero de pagina
90
     * @param int $perPage cantidad de items por pagina
91
     * @param mixed $values valores
92
     */
93
    public function __construct($model, $sql, int $page, int $perPage, $values = null)
94
    {
95
        $this->perPage = $perPage;
96
        $this->page = $page;
97
98
        /*validacion*/
99
        $this->validPage();
100
101
        $this->model = $model;
102
103
        // Valores para consulta
104
        $this->values = ($values !== null && !is_array($values)) ?
105
        array_slice(func_get_args(), 4) : $values;
106
107
        $this->count = $this->countQuery($model, $sql);
108
        $this->totalPages = (int) max(1, ceil($this->count / $this->perPage));
109
        $this->validCurrent();
110
        // Establece el limit y offset
111
        $this->sql = QueryGenerator::query($model::getDriver(), 'limit', $sql, $perPage, ($page - 1) * $perPage);
112
        $this->items = $model::query($this->sql, $this->values)->fetchAll();
113
    }
114
115
    /**
116
     * Permite que al usar json_encode() con una instacia de Paginator funcione correctamente
117
     * retornando los items del paginador.
118
     */
119
    public function jsonSerialize()
120
    {
121
        return $this->items;
122
    }
123
124
    /**
125
     * Verifica que la pagina sea válida.
126
     */
127
    private function validPage()
128
    {
129
        //Si la página o por página es menor de 1 (0 o negativo)
130
        if ($this->page < 1 || $this->perPage < 1) {
131
            throw new \RangeException("La página $this->page no existe", 404);
132
        }
133
    }
134
135
    /**
136
     * Valida que la página actual.
137
     */
138
    private function validCurrent()
139
    {
140
        if ($this->page > $this->totalPages) {
141
            throw new \RangeException("La página $this->page no existe", 404);
142
        }
143
    }
144
145
    /**
146
     * (non-PHPdoc).
147
     *
148
     * @see IteratorAggregate::getIterator()
149
     */
150
    public function getIterator()
151
    {
152
        return new \ArrayIterator($this->items);
153
    }
154
155
    /**
156
     * Cuenta el número de resultados totales.
157
     *
158
     * @param string $model
159
     * @param string $sql
160
     *
161
     * @return int total de resultados
162
     */
163
    protected function countQuery($model, $sql)
164
    {
165
        $query = $model::query("SELECT COUNT(*) AS count FROM ($sql) AS t", $this->values)->fetch();
166
167
        return (int) $query->count;
168
    }
169
170
    /**
171
     * Total de items.
172
     *
173
     * @return int
174
     */
175
    public function totalItems()
176
    {
177
        return $this->count;
178
    }
179
180
    /**
181
     * Total de páginas.
182
     *
183
     * @return int
184
     */
185
    public function totalPages()
186
    {
187
        return $this->totalPages;
188
    }
189
190
    /**
191
     * Calcula el valor de la próxima página.
192
     *
193
     * @return int
194
     */
195
    public function nextPage()
196
    {
197
        return ($this->totalPages > $this->page) ? ($this->page + 1) : null;
198
    }
199
200
    /**
201
     * Calcula el valor de la página anterior.
202
     *
203
     * @return int
204
     */
205
    public function prevPage()
206
    {
207
        return ($this->page > 1) ? ($this->page - 1) : null;
208
    }
209
210
    /**
211
     * Items devueltos.
212
     *
213
     * @see Countable::countable()
214
     *
215
     * @return int
216
     */
217
    public function count()
218
    {
219
        return count($this->items);
220
    }
221
222
    /**
223
     * Página actual de paginador.
224
     *
225
     * @return int
226
     */
227
    public function page()
228
    {
229
        return $this->page;
230
    }
231
232
    /**
233
     * Campos del objeto.
234
     *
235
     * @return array
236
     */
237
    public function getFields()
238
    {
239
        return $this->items[0]->getFields();
240
    }
241
242
    /**
243
     * Alias de Campos del objeto.
244
     *
245
     * @return array
246
     */
247
    public function getAlias()
248
    {
249
        return $this->items[0]->getAlias();
250
    }
251
}
252