source: branches/1.2/workflow/inc/local/classes/class.wf_date.php @ 1349

Revision 1349, 19.8 KB checked in by niltonneto, 15 years ago (diff)

Ticket #561 - Inclusão do módulo Workflow faltante nessa versão.

  • Property svn:executable set to *
Line 
1<?php
2/**
3 * Corresponde ao formato de data armazenado na configuração (d/m/Y ou Y/m/d)
4 * @name DATE_FORMAT_LOCAL
5 */
6define('DATE_FORMAT_LOCAL', 'd/m/Y');
7/**
8 * maior número inteiro
9 * @name DATE_FORMAT_LOCAL
10 */
11define('LONG_MAX', is_int(2147483648) ? 9223372036854775807 : 2147483647);
12/**
13 * Formato de data customizado
14 * @name DATE_FORMAT_LOCAL
15 */
16define('DATE_FORMAT_CUSTOM', 'CUSTOM');
17
18/**
19 * Classe para manipulação e realização de cálculos com datas
20 * @author Marcos Pont
21 * @author Carlos Eduardo Nogueira Gonçalves
22 * @version 1.0
23 * @license http://www.gnu.org/copyleft/gpl.html GPL
24 * @package Workflow
25 * @subpackage local
26 */
27class wf_date
28{
29
30        /**
31         * Construtora da classe wf_date
32         * @return object Objeto da classe wf_date
33         * @access public
34         */
35        function wf_date()
36        {
37        }
38
39        /**
40         * Verifica se uma determinada data é válida
41         * @access public
42         * @param string $date Data a ser validada
43         * @return boolean
44         */
45        function isValid($date) {
46                $regs = array();
47                if ($this->isEuroDate($date, $regs)) {
48                        list(, $day, $month, $year) = $regs;
49                } else if ($this->isUsDate($date, $regs) || $this->isSqlDate($date, $regs)) {
50                        list(, $year, $month, $day) = $regs;
51                } else {
52                        return FALSE;
53                }
54                if ($year < 0 || $year > 9999) {
55                        return FALSE;
56                } else {
57                        return (checkdate($month, $day, $year));
58                }
59        }
60        /**
61         *      Verifica se um valor de time zone é válido
62         *      @access public
63         *      @param  string $tz      Valor de time zone
64         *      @return boolean
65         */     
66        function isValidTZ($tz) {
67                return preg_match("/^(((\+|\-)[0-9]{2}\:[0-9]{2})|(UT|GMT|EST|EDT|CST|CDT|MST|MDT|PST|PDT)|([A-IK-Y]{1}))$/", $tz);
68        }
69       
70        /**
71         * Verifica se uma data está no formato europeu dd[/-.]mm[/-.]YYYY[ HH:mm:ss]
72         * @param array &$regs Vetor para onde retornam os valores destacados de dia, mês e ano
73         * @access public
74         * @return boolean
75         */
76        function isEuroDate($date, &$regs) {
77                $date = trim($date);
78                if (ereg("^([0-9]{1,2})(/|\-|\.)([0-9]{1,2})(/|\-|\.)([0-9]{4})([[:space:]]([0-9]{1,2}):([0-9]{1,2}):?([0-9]{1,2})?)?$", $date, $matches)) {
79                        $regs = array(
80                                $matches[0],
81                                $matches[1], $matches[3], $matches[5],
82                                $matches[7], $matches[8], $matches[9]
83                        );
84                        return TRUE;
85                }
86                return FALSE;
87        }
88       
89        /**
90         * Verifica se uma data está no formato americano YYYY[/-.]mm[/-.]dd[ HH:mm:ss]
91         * @param string $date Data a ser verificada
92         * @param array &$regs Vetor para onde retornam os valores destacados de dia, mês e ano
93         * @access public
94         * @return boolean
95         */     
96        function isUsDate($date, &$regs) {
97                $date = trim($date);
98                if (ereg("^([0-9]{4})(/|\-|\.)([0-9]{1,2})(/|\-|\.)([0-9]{1,2})([[:space:]]([0-9]{1,2}):([0-9]{1,2}):?([0-9]{1,2})?)?$", $date, $matches)) {
99                        $regs = array(
100                                $matches[0],
101                                $matches[1], $matches[3], $matches[5],
102                                $matches[7], $matches[8], $matches[9]
103                        );
104                        return TRUE;
105                }
106                return FALSE;
107        }
108       
109        /**
110         * Verifica se uma data está no formato SQL YYYY-mm-dd
111         * @param string $date Data a ser verificada
112         * @param array &$regs Vetor para onde retornam os valores destacados de dia, mês e ano
113         * @access public
114         * @return boolean
115         */
116        function isSqlDate($date, &$regs) {
117                $date = trim($date);
118                if (ereg("^([0-9]{4})-([0-9]{1,2})-([0-9]{1,2})([[:space:]]([0-9]{1,2}):([0-9]{1,2}):?([0-9]{1,2})?)?$", $date, $matches)) {
119                        $regs = array(
120                                $matches[0],
121                                $matches[1], $matches[2], $matches[3],
122                                $matches[5], $matches[6], $matches[7]
123                        );
124                        return TRUE;                   
125                }
126                return FALSE;
127        }
128       
129        /**
130         * Verifica se uma data é posterior à data atual
131         * @access public
132         * @param string $date Data a ser verificada
133         * @return boolean
134         */
135        function isFuture($date) {
136                $daysFrom = $this->dateToDays($date);
137                $daysTo = $this->dateToDays();
138                return ($daysFrom > $daysTo);
139        }
140       
141        /**
142         * Verifica se uma data é anterior à data atual
143         * @access public
144         * @param string date Data a ser verificada
145         * @return boolean
146         */
147        function isPast($date) {
148                $daysFrom = $this->dateToDays($date);
149                $daysTo = $this->dateToDays();
150                return ($daysTo > $daysFrom);
151        }
152       
153        /**
154         * Calcula o dia seguinte em relação à data atual
155         * @access public
156         * @return string Data calculada
157         */
158        function tomorrow() {
159                return $this->nextDay();
160        }
161       
162        /**
163         * Verifica se um determinado valor é NULL
164         * @param mixed $value Valor a testar
165         * @param boolean $strict Considerar o tipo do dado
166         * @access public
167         * @return boolean
168         */
169        function isNull($value, $strict = FALSE) {
170                return ($strict) ? (NULL === $value) : (NULL == $value);
171        }       
172       
173        /**
174         * Calcula a data imediatamente posterior a uma determinada data
175         * @access public
176         * @param string $date Data base
177         * @return string Dia seguinte calculado
178         */
179        function nextDay($date=NULL) {
180                if ($this->isNull($date)) {
181                        $date = $this->localDate();
182                }
183                return $this->futureDate($date, 1);
184        }
185       
186        /**
187         * Calcula uma data no futuro, a partir de um número de dias, meses e anos
188         * @access public
189         * @param string $date Data original
190         * @param iny $days Número de dias no futuro
191         * @param int $months Número de meses no futuro
192         * @param int $years Número de anos no futuro
193         * @return string Data calculada no formato original
194         */
195        function futureDate($date, $days = 0, $months = 0, $years = 0) {
196                // Captura o formato e os elementos da data base
197                $regs = array();               
198                if ($this->isEuroDate($date, $regs)) {
199                        list(, $day, $month, $year) = $regs;
200                        $dateFormat = "EURO";
201                } else if ($this->isSqlDate($date, $regs)) {
202                        list(, $year, $month, $day) = $regs;
203                        $dateFormat = "SQL";
204                } else if ($this->isUsDate($date, $regs)) {
205                        list(, $year, $month, $day) = $regs;
206                        $dateFormat = "US";
207                } else {                       
208                        return NULL;
209                }
210                // Calcula o número de dias da data original
211                $daysFrom = $this->dateToDays($date);
212                $daysInc = 0;
213                // Adiciona os anos
214                $years = intval($years);
215                for ($i = 1; $i <= $years; $i++) {
216                        $year++;
217                        $daysInc += ($this->isLeapYear($year)) ? 366 : 365;
218                }
219                // Adiciona os meses de acordo com o número de dias em cada um
220                $months = intval($months);
221                for ($i = 1; $i <= $months; $i++) {
222                        $mTemp = $i % 12 - 1;
223                        $yTemp = intval($i / 12);
224                        if (($month + $mTemp) > 12) {
225                                $yTemp++;
226                                $mTemp = ($month + $mTemp) - 12;
227                        } else {
228                                $mTemp = $month + $mTemp;
229                        }
230                        $daysInc += $this->daysInMonth($mTemp, $year + $yTemp);
231                }
232                // Adiciona os dias
233                $daysInc += intval($days);
234                // Retorna a data calculada no formato original
235                return $this->daysToDate($daysFrom + $daysInc, $dateFormat);                           
236        }
237       
238        /**
239         * Calcula o dia anterior em relação à data atual
240         * @access public
241         * @return string Data calculada
242         */
243        function yesterday() {
244                return $this->prevDay();
245        }
246       
247        /**
248         * Calcula a data imediatamente anterior a uma determinada data
249         * @access public
250         * @param string $date Data base
251         * @return string Dia anterior calculado
252         */
253        function prevDay($date=NULL) {
254                if ($this->isNull($date)) {
255                        $date = $this->localDate();
256                }
257                return $this->pastDate($date, 1);
258        }
259       
260        /**
261         * Calcula uma data no passado, a partir de um número de dias, meses e anos
262         * @param string $date Data original
263         * @param int $days Número de dias no passado
264         * @param int $months Número de meses no passado
265         * @param int $years Número de anos no passado
266         * @return string Data calculada no formato original
267         * @access public
268         */
269        function pastDate($date, $days=0, $months=0, $years=0) {
270                // Captura o formato e os elementos da data base
271                $regs = array();
272                if ($this->isEuroDate($date, $regs)) {
273                        list(, $day, $month, $year) = $regs;
274                        $dateFormat = 'EURO';
275                } else if ($this->isSqlDate($date, $regs)) {
276                        list(, $year, $month, $day) = $regs;
277                        $dateFormat = 'SQL';
278                } else if ($this->isUsDate($date, $regs)) {
279                        list(, $year, $month, $day) = $regs;
280                        $dateFormat = 'US';
281                } else {
282                        return NULL;
283                }
284                // Calcula o número de dias da data original
285                $daysFrom = $this->dateToDays($date);
286                $daysDec = 0;
287                // Adiciona os anos
288                for ($i = 1; $i <= $years; $i++) {
289                        $s = ($this->isLeapYear($year)) ? 366 : 365;
290                        $daysDec += ($this->isLeapYear($year)) ? 366 : 365;
291                        $year--;                       
292                }               
293                // Adiciona os meses de acordo com os dias de cada mês
294                for ($i = 1; $i <= $months; $i++) {
295                        $mTemp = $i % 12;
296                        $yTemp = intval($i / 12);
297                        if (($month - $mTemp) <= 0) {
298                                $yTemp++;
299                                $mTemp = 12 + ($month - $mTemp);
300                        } else {
301                                $mTemp = $month - $mTemp;
302                        }
303                        $daysDec += $this->daysInMonth($mTemp, $year - $yTemp);
304                }
305                // Adiciona os dias
306                $daysDec += $days;
307                // Retorna a data calculada no formato original
308                return $this->daysToDate($daysFrom - $daysDec, $dateFormat);
309        }
310       
311        /**
312         * Calcula a diferença em dias entre duas datas
313         * @param string $dateM Data 1
314         * @param string $dateS Data 2
315         * @param boolean $unsigned Usar sinal no retorno
316         * @access public
317         */
318        function getDiff($dateM, $dateS, $unsigned=TRUE) {
319                // Calcula o número de dias da diferença
320                $daysS = $this->dateToDays($dateS);
321                $daysM = $this->dateToDays($dateM);
322                return ($unsigned? abs($daysS - $daysM) : ($daysS - $daysM));
323        }
324       
325        /**
326         * Retorna o dia da semana para uma data
327         * @param string $date Data a ser processada
328         * @param boolean $text Retornar o nome do dia da semana
329         * @param boolean $abbr Retornar o nome do dia da semana abreviadamente
330         * @return mixed Nome ou número do dia da semana (baseado em zero)
331         * @access public
332         */
333        function dayOfWeek($date, $text=TRUE, $abbr=FALSE) {
334                // Captura os elementos da data base de acordo com o formato
335                $regs = array();
336                if ($this->isEuroDate($date, $regs)) {
337                        list(, $day, $month, $year) = $regs;
338                } else if ($this->isUsDate($date, $regs) || $this->isSqlDate($date, $regs)) {
339                        list(, $year, $month, $day) = $regs;
340                } else {
341                        return NULL;
342                }
343                // Cálculo do dia da semana
344                if ($month > 2) {
345                        $month -= 2;
346                } else {
347                        $month += 10;
348                        $year--;
349                }
350                $dow = (floor((13 * $month - 1) / 5) + $day + ($year % 100) + floor(($year % 100) / 4) + floor(($year / 100) / 4) - 2 * floor($year / 100) + 77);
351                $dow = (($dow - 7 * floor($dow / 7)));
352                // Exibição do resultado, de acordo com os parâmetros fornecidos
353                if ($text) {
354                        $daysOfWeek = array('segunda', 'terça', 'quarta', 'quinta', 'sexta');
355                        if ($abbr) {
356                                return $daysOfWeek[$dow];       
357                        } else {
358                                return $daysOfWeek[$dow] . '-feira';
359                        }                                       
360                } else {
361                        return $dow;
362                }
363        }
364       
365        /**
366         * Retorna o número de dias de um mês de acordo com o mês e o ano
367         * @param int $month Mês
368         * @param int $year Ano
369         * @return int Número de dias do mês solicitado
370         * @access public
371         */
372        function daysInMonth($month=NULL, $year=NULL) {
373                if ($this->isNull($year))
374                        $year = date("Y");
375                if ($this->isNull($month))
376                        $month = date("m");
377                if ($month == 2) {
378                        return ($this->isLeapYear($year) ? 29 : 28);
379                } elseif (in_array($month, array(4, 6, 9, 11))) {
380                        return 30;
381                } else {
382                        return 31;
383                }
384        }
385       
386        /**
387         * Verifica se um determinado ano é bissexto
388         * @param int $year Ano para ser verificado
389         * @access public
390         * @return boolean
391         */
392        function isLeapYear($year=NULL) {
393                if ($this->isNull($year))
394                        $year = date("Y");
395                if (strlen($year) != 4 || preg_match("/\D/", $year))
396                        return NULL;
397                return ((($year % 4) == 0 && ($year % 100) != 0) || ($year % 400) == 0);
398        }       
399       
400        /**
401         * Converte uma data no padrão europeu (dd/mm/YYYY) para o padrão SQL (YYYY-mm-dd)
402         * @param string $date Data a ser convertida
403         * @param boolean @preserveTime Preservar porção de hora, se ela existir na data fornecida
404         * @return string Data convertida ou a original se o padrão de entrada estiver incorreto
405         * @access public
406         */
407        function fromEuroToSqlDate($date, $preserveTime=FALSE) {
408                $regs = array();
409                if ($this->isEuroDate($date, $regs)) {
410                        $res = "$regs[3]-$regs[2]-$regs[1]";
411                        if ($preserveTime && $regs[4] !== FALSE && $regs[5] !== FALSE) {
412                                $res .= " $regs[4]:$regs[5]";
413                                if ($regs[6] !== FALSE)
414                                        $res .= ":$regs[6]";
415                        }
416                        return $res;
417                } else {
418                        return $date;
419                }
420        }
421       
422        /**
423         * Converte uma data no padrão europeu (dd/mm/YYYY)
424         * @param string $date Data a ser convertida
425         * @param boolean $preserveTime Preservar porção de hora, se ela existir na data fornecida
426         * @return string Data convertida ou a original se o padrão de entrada estiver incorreto
427         * @access public
428         */
429        function fromEuroToUsDate($date, $preserveTime=FALSE) {
430                $regs = array();
431                if ($this->isEuroDate($date, $regs)) {                 
432                        $res = "$regs[3]/$regs[2]/$regs[1]";
433                        if ($preserveTime && $regs[4] !== FALSE && $regs[5] !== FALSE) {
434                                $res .= " $regs[4]:$regs[5]";
435                                if ($regs[6] !== FALSE)
436                                        $res .= ":$regs[6]";
437                        }
438                        return $res;                   
439                } else {
440                        return $date;
441                }
442        }
443       
444        /**
445         * Converte uma data no padrã americano (YYYY/mm/dd) para o padrão SQL (YYYY-mm-dd)
446         * @param string $date Data a ser convertida
447         * @return string Data convertida ou a original se o padrão de entrada estiver incorreto
448         * @access public
449         */
450        function fromUsToSqlDate($date) {
451                $regs = array();
452                if ($this->isUsDate($date, $regs)) {
453                        return str_replace("/", "-", $date);
454                } else {
455                        return $date;
456                }
457        }
458       
459        /**
460         * Converte uma data no padrão americano (YYYY/mm/dd) para o padrão europeu (dd/mm/YYYY)
461         * @param string $date Data a ser convertida
462         * @param boolean $preserveTime Preservar porção de hora, se ela existir na data fornecida
463         * @return string Data convertida ou a original se o padrão de entrada estiver incorreto
464         * @access public
465         */
466        function fromUsToEuroDate($date, $preserveTime=FALSE) {
467                $regs = array();
468                if ($this->isUsDate($date, $regs)) {
469                        $res = "$regs[3]/$regs[2]/$regs[1]";
470                        if ($preserveTime && $regs[4] !== FALSE && $regs[5] !== FALSE) {
471                                $res .= " $regs[4]:$regs[5]";
472                                if ($regs[6] !== FALSE)
473                                        $res .= ":$regs[6]";
474                        }
475                        return $res;                   
476                } else {
477                        return $date;
478                }
479        }
480       
481        /**
482         * Converte uma data no padrão SQL (YYYY-mm-dd) para o padrão europeu (dd/mm/YYYY)
483         * @param string $date  Data a ser convertida
484         * @param boolean preserveTime Preservar porção de hora, se ela existir na data fornecida
485         * @return string Data convertida ou a original se o padrão de entrada estiver incorreto
486         * @access public
487         */
488        function fromSqlToEuroDate($date, $preserveTime=FALSE) {
489                $regs = array();
490                if ($this->isSqlDate($date, $regs)) {
491                        $res = "$regs[3]/$regs[2]/$regs[1]";
492                        if ($preserveTime && $regs[4] !== FALSE && $regs[5] !== FALSE) {
493                                $res .= " $regs[4]:$regs[5]";
494                                if ($regs[6] !== FALSE)
495                                        $res .= ":$regs[6]";
496                        }
497                        return $res;                   
498                } else {
499                        return $date;
500                }
501        }
502       
503        /**
504         * Converte uma data no padrão SQL (YYYY-mm-dd) para o padrão americano (YYYY/mm/dd)
505         * @param string $date Data a ser convertida
506         * @return string Data convertida ou a original se o padrão de entrada estiver incorreto
507         * @access public
508         */
509        function fromSqlToUsDate($date) {
510                $regs = array();
511                if ($this->isSqlDate($date, $regs)) {
512                        return str_replace("-", "/", $date);
513                } else {
514                        return $date;
515                }
516        }
517       
518        /**
519         * Converte um timestamp Unix em uma data/hora no formato DOS com 4 bytes
520         * @param int $unixTimestamp Timestamp UNIX para a conversão
521         * @return string Data e hora no formato DOS
522         * @access public
523         */
524        function fromUnixToDosDate($unixTimestamp=0) {
525                $timeData = ($unixTimestamp) ? getdate($unixTimestamp) : getdate();
526                if ($timeData['year'] < 1980) {
527                        $timeData['year'] = 1980;
528                        $timeData['mon'] = 1;
529                        $timeData['mday'] = 1;
530                        $timeData['hours'] = 0;
531                        $timeData['minutes'] = 0;
532                        $timeData['seconds'] = 0;
533                }
534                return ((($timeData['year'] - 1980) << 25) |
535                        ($timeData['mon'] << 21) |
536                        ($timeData['mday'] << 16) |
537                        ($timeData['hours'] << 11) |
538                        ($timeData['minutes'] << 5) |
539                        ($timeData['seconds'] << 1));
540        }
541       
542        /**
543         * Converte uma data nos formatos EURO, US ou SQL em um timestamp UNIX
544         * @param string $date Data
545         * @return int
546         * @access public
547         */
548        function dateToTime($date) {
549                $date = $this->fromEuroToUsDate($date, TRUE);
550                return strtotime($date);
551        }
552       
553        /**
554         * Converte uma data para o correspondente em número de dias
555         * @param string $date Data base para o cálculo
556         * @return int Data convertida em número de dias
557         * @access public
558         */
559        function dateToDays($date=NULL) {               
560                if ($this->isNull($date))
561                        $date = $this->localDate();
562                $regs = array();
563                if ($this->isEuroDate($date, $regs)) {
564                        list(, $day, $month, $year) = $regs;
565                } else if ($this->isUsDate($date, $regs) || $this->isSqlDate($date, $regs)) {
566                        list(, $year, $month, $day) = $regs;
567                } else {
568                        return -1;
569                }               
570        $century = (int) substr($year,0,2);
571        $year = (int) substr($year,2,2);
572        if ($month > 2) {
573            $month -= 3;
574        } else {
575            $month += 9;
576            if ($year) {
577                $year--;
578            } else {
579                $year = 99;
580                $century --;
581            }
582        }
583        return (floor((146097 * $century) / 4 ) + floor(( 1461 * $year) / 4 ) + floor(( 153 * $month + 2) / 5 ) + $day + 1721119);
584        }
585       
586        /**
587         * Converte um número de dias em uma data
588         * @param int $days Número de dias
589         * @param string $dateType Tipo da data a ser retornada (EURO, US ou SQL)
590         * @return string Data correspondente
591         * @access public
592         */
593        function daysToDate($days, $dateType) {
594                if (!is_float($days) || !in_array(strtolower($dateType), array('euro', 'us', 'sql'))) {
595                        return NULL;
596                }
597        $days -= 1721119;
598        $century = floor(( 4 * $days - 1) / 146097);
599        $days = floor(4 * $days - 1 - 146097 * $century);
600        $day = floor($days / 4);
601        $year = floor(( 4 * $day +  3) / 1461);
602        $day = floor(4 * $day +  3 - 1461 * $year);
603        $day = floor(($day +  4) / 4);
604        $month = floor(( 5 * $day - 3) / 153);
605        $day = floor(5 * $day - 3 - 153 * $month);
606        $day = floor(($day +  5) /  5);
607        if ($month < 10) {
608            $month +=3;
609        } else {
610            $month -=9;
611            if ($year++ == 99) {
612                $year = 0;
613                $century++;
614            }
615        }
616        $century = sprintf('%02d', $century);
617        $year = sprintf('%02d', $year);
618        $month = sprintf('%02d', $month);
619        $day = sprintf('%02d', $day);
620        if (strtolower($dateType) == 'euro') {
621                return ("$day/$month/$century$year");
622        } else if (strtolower($dateType) == 'us') {
623                return ("$century$year/$month/$day");
624        } else {
625                return ("$century$year-$month-$day");
626        }               
627        }
628       
629        /**
630         * Retorna a data local de acordo com o formato
631         * @access public
632         * @param int $ts Timestamp opcional para geração da data local
633         * @return string Data local, a partir do timestamp atual ou um determinado
634         */
635        function localDate($ts=0) {
636                $dateFormat = DATE_FORMAT_LOCAL;
637                if ($ts > 0) {
638                        if ($dateFormat) {
639                                return date($dateFormat . ' H:i:s', $ts);
640                        } else {
641                                return date("d/m/Y H:i:s", $ts);
642                        }
643                } else {
644                        if ($dateFormat) {
645                                return date($dateFormat);
646                        } else {
647                                return date("d/m/Y");
648                        }
649                }
650        }
651       
652        /**
653         * Formata um valor de data a partir dos valores de dia, mês e ano
654         * @param int $day Valor do dia na data
655         * @param int $month Valor do mês na data
656         * @param int $year Valor do ano na data, com 4 dígitos
657         * @param int $fmtType Tipo de formato de data (vide constantes da classe)
658         * @return string Data formatada
659         * @access public
660         */
661        function formatDate($day, $month, $year, $fmtType=DATE_FORMAT_LOCAL, $fmtStr='') {
662                $day = strval(str_repeat('0', (2 - strlen($day))) . $day);
663                $month = strval(str_repeat('0', (2 - strlen($month))) . $month);
664                $year = strval(str_repeat('0', (4 - strlen($year))) . $year);
665                $tsDate = mktime(0, 0, 0, $month, $day, $year);
666                return $this->formatTime($tsDate, $fmtType, $fmtStr);
667        }
668       
669        /**
670         * Formata um valor de unix timestamp
671         * @access public
672         * @param int $time Unix timestamp
673         * @param int $fmtType Tipo de formato de data (vide constantes da classse)
674         * @param string $fmtString Descrição do formato (quando $fmtType==DATE_FORMAT_CUSTOM)
675         * @return string Timestamp formatado
676         */
677        function formatTime($time=NULL, $fmtType=DATE_FORMAT_LOCAL, $fmtStr='') {
678                if (empty($time)) {
679                        $time = time();
680                }                       
681                if (!is_int($time) || $time < 0 || $time > LONG_MAX) {
682                        return $time;
683                }                       
684                if ($fmtType == DATE_FORMAT_LOCAL) {                   
685                        return $this->localDate($time);                 
686                } elseif ($fmtType == DATE_FORMAT_CUSTOM && !empty($fmtStr)) {
687                        return date($fmtStr, $time);
688                } else {
689                        return $time;
690                }
691        }
692}
693?>
Note: See TracBrowser for help on using the repository browser.