Fixed export-import for quota percent.
[timetracker.git] / WEB-INF / lib / tdcron / class.tdcron.php
1 <?php
2
3         define('IDX_MINUTE',                    0);
4         define('IDX_HOUR',                      1);
5         define('IDX_DAY',                       2);
6         define('IDX_MONTH',                     3);
7         define('IDX_WEEKDAY',                   4);
8         define('IDX_YEAR',                      5);
9
10         /*
11          * tdCron v0.0.1 beta - CRON-Parser for PHP
12          *
13          * Copyright (c) 2010 Christian Land / tagdocs.de
14          *
15          * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
16          * associated documentation files (the "Software"), to deal in the Software without restriction,
17          * including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
18          * and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so,
19          * subject to the following conditions:
20          *
21          * The above copyright notice and this permission notice shall be included in all copies or substantial
22          * portions of the Software.
23          *
24          * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
25          * LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
26          * NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
27          * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
28          * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
29          *
30          * @author      Christian Land <devel@tagdocs.de>
31          * @package     tdCron
32          * @copyright   Copyright (c) 2010, Christian Land / tagdocs.de
33          * @version     v0.0.1 beta
34          */
35         class tdCron {
36
37                 /**
38                  * Parsed cron-expressions cache.
39                  * @var mixed
40                  */
41                 static private $pcron = array();
42
43                 /**
44                  * getNextOccurrence() uses a cron-expression to calculate the time and date at which a cronjob
45                  * should be executed the next time. If a reference-time is passed, the next time and date
46                  * after that time is calculated.
47                  *
48                  * @access      public
49                  * @param       string          $expression     cron-expression to use
50                  * @param       int             $timestamp      optional reference-time
51                  * @return      int
52                  */
53                 static public function getNextOccurrence($expression, $timestamp = null) {
54
55                         try {
56
57                                 // Convert timestamp to array
58
59                                 $next           = self::getTimestamp($timestamp);
60
61                                 // Calculate date/time
62
63                                 $next_time      = self::calculateDateTime($expression, $next);
64
65                         } catch (Exception $e) {
66
67                                 throw $e;
68
69                         }
70
71                         // return calculated time
72
73                         return $next_time;
74
75                 }
76
77                 /**
78                  * getLastOccurrence() does pretty much the same as getNextOccurrence(). The only difference
79                  * is, that it doesn't calculate the next but the last time a cronjob should have been executed.
80                  *
81                  * @access      public
82                  * @param       string          $expression     cron-expression to use
83                  * @param       int             $timestamp      optional reference-time
84                  * @return      int
85                  */
86
87                 static public function getLastOccurrence($expression, $timestamp = null) {
88
89                         try {
90
91                                 // Convert timestamp to array
92
93                                 $last           = self::getTimestamp($timestamp);
94
95                                 // Calculate date/time
96
97                                 $last_time      = self::calculateDateTime($expression, $last, false);
98
99                         } catch (Exception $e) {
100
101                                 throw $e;
102
103                         }
104
105                         // return calculated time
106
107                         return $last_time;
108
109                 }
110
111                 /**
112                  * calculateDateTime() is the function where all the magic happens :-)
113                  *
114                  * It calculates the time and date at which the next/last call of a cronjob is/was due.
115                  *
116                  * @access      private
117                  * @param       mixed           $value          cron-expression
118                  * @param       mixed           $rtime          reference-time
119                  * @param       bool            $next           true = nextOccurence, false = lastOccurence
120                  * @return      int
121                  */
122
123                 static private function calculateDateTime($expression, $rtime, $next = true) {
124
125                         // Initialize vars
126  
127                         $calc_date      = true;
128
129                         // Parse cron-expression (if neccessary)
130
131                         $cron           = self::getExpression($expression, !$next);
132
133                         // OK, lets see if the day/month/weekday of the reference-date exist in our
134                         // $cron-array.
135
136                         if (!in_array($rtime[IDX_DAY], $cron[IDX_DAY]) ||
137                             !in_array($rtime[IDX_MONTH], $cron[IDX_MONTH]) ||
138                             !in_array($rtime[IDX_WEEKDAY], $cron[IDX_WEEKDAY])) {
139
140                                 // OK, things are easy. The day/month/weekday of the reference time
141                                 // can't be found in the $cron-array. This means that no matter what
142                                 // happens, we WILL end up at at a different date than that of our
143                                 // reference-time. And in this case, the lastOccurrence will ALWAYS
144                                 // happen at the latest possible time of the day and the nextOccurrence
145                                 // at the earliest possible time.
146                                 //
147                                 // In both cases, the time can be found in the first elements of the
148                                 // hour/minute cron-arrays.
149
150                                 $rtime[IDX_HOUR]        = reset($cron[IDX_HOUR]);
151                                 $rtime[IDX_MINUTE]      = reset($cron[IDX_MINUTE]);
152
153                         } else {
154
155                                 // OK, things are getting a little bit more complicated...
156  
157                                 $nhour          = self::findValue($rtime[IDX_HOUR], $cron[IDX_HOUR], $next);
158
159                                 // Meh. Such a cruel world. Something has gone awry. Lets see HOW awry it went.
160
161                                 if ($nhour === false) { // Fix as per http://www.phpclasses.org/discuss/package/6699/thread/3/
162
163                                         // Ah, the hour-part went wrong. Thats easy. Wrong hour means that no
164                                         // matter what we do we'll end up at a different date. Thus we can use
165                                         // some simple operations to make things look pretty ;-)
166                                         //
167                                         // As alreasy mentioned before -> different date means earliest/latest
168                                         // time:
169
170                                         $rtime[IDX_HOUR]        = reset($cron[IDX_HOUR]);
171                                         $rtime[IDX_MINUTE]      = reset($cron[IDX_MINUTE]);
172
173                                         // Now all we have to do is add/subtract a day to get a new reference time
174                                         // to use later to find the right date. The following line probably looks
175                                         // a little odd but thats the easiest way of adding/substracting a day without
176                                         // screwing up the date. Just trust me on that one ;-)
177
178                                         $rtime                  = explode(',', strftime('%M,%H,%d,%m,%w,%Y', mktime($rtime[IDX_HOUR], $rtime[IDX_MINUTE], 0, $rtime[IDX_MONTH], $rtime[IDX_DAY], $rtime[IDX_YEAR]) + ((($next) ? 1 : -1) * 86400)));
179
180                                 } else {
181
182                                         // OK, there is a higher/lower hour available. Check the minutes-part.
183
184                                         $nminute        = self::findValue($rtime[IDX_MINUTE], $cron[IDX_MINUTE], $next);
185
186                                         if ($nminute === false) {
187
188                                                 // No matching minute-value found... lets see what happens if we substract/add an hour
189
190                                                 $nhour          = self::findValue($rtime[IDX_HOUR] + (($next) ? 1 : -1), $cron[IDX_HOUR], $next);
191
192                                                 if ($nhour === false) {
193
194                                                         // No more hours available... add/substract a day... you know what happens ;-)
195
196                                                         $nminute        = reset($cron[IDX_MINUTE]);
197                                                         $nhour          = reset($cron[IDX_HOUR]);
198
199                                                         $rtime          = explode(',', strftime('%M,%H,%d,%m,%w,%Y', mktime($nhour, $nminute, 0, $rtime[IDX_MONTH], $rtime[IDX_DAY], $rtime[IDX_YEAR]) + ((($next) ? 1 : -1) * 86400)));
200
201                                                 } else {
202
203                                                         // OK, there was another hour. Set the right minutes-value
204
205                                                         $rtime[IDX_HOUR]        = $nhour;
206                                                         $rtime[IDX_MINUTE]      = (($next) ? reset($cron[IDX_MINUTE]) : end($cron[IDX_MINUTE]));
207
208                                                         $calc_date      = false;
209
210                                                 }
211
212                                         } else {
213
214                                                 // OK, there is a matching minute... reset minutes if hour has changed
215
216                                                 if ($nhour <> $rtime[IDX_HOUR]) {
217                                                         $nminute                = reset($cron[IDX_MINUTE]);
218                                                 }
219
220                                                 // Set time
221  
222                                                 $rtime[IDX_HOUR]        = $nhour;
223                                                 $rtime[IDX_MINUTE]      = $nminute;
224  
225                                                 $calc_date      = false;
226
227                                         }
228
229                                 }
230
231                         }
232
233                         // If we have to calculate the date... we'll do so
234
235                         if ($calc_date) {
236
237                                 if (in_array($rtime[IDX_DAY], $cron[IDX_DAY]) &&
238                                     in_array($rtime[IDX_MONTH], $cron[IDX_MONTH]) &&
239                                     in_array($rtime[IDX_WEEKDAY], $cron[IDX_WEEKDAY])) {
240
241                                         return mktime($rtime[1], $rtime[0], 0, $rtime[3], $rtime[2], $rtime[5]);
242
243                                 } else {
244
245                                         // OK, some searching necessary...
246
247                                         $cdate  = mktime(0, 0, 0, $rtime[IDX_MONTH], $rtime[IDX_DAY], $rtime[IDX_YEAR]);
248
249                                         // OK, these three nested loops are responsible for finding the date...
250                                         //
251                                         // The class has 2 limitations/bugs right now:
252                                         //
253                                         //      -> it doesn't work for dates in 2036 or later!
254                                         //      -> it will most likely fail if you search for a Feburary, 29th with a given weekday
255                                         //         (this does happen because the class only searches in the next/last 10 years! And
256                                         //         while it usually takes less than 10 years for a "normal" date to iterate through
257                                         //         all weekdays, it can take 20+ years for Feb, 29th to iterate through all weekdays!
258
259                                         for ($nyear = $rtime[IDX_YEAR];(($next) ? ($nyear <= $rtime[IDX_YEAR] + 10) : ($nyear >= $rtime[IDX_YEAR] -10));$nyear = $nyear + (($next) ? 1 : -1)) {
260
261                                                 foreach ($cron[IDX_MONTH] as $nmonth) {
262
263                                                         foreach ($cron[IDX_DAY] as $nday) {
264
265                                                                 if (checkdate($nmonth,$nday,$nyear)) {
266
267                                                                         $ndate  = mktime(0,0,1,$nmonth,$nday,$nyear);
268
269                                                                         if (($next) ? ($ndate >= $cdate) : ($ndate <= $cdate)) {
270
271                                                                                 $dow    = date('w',$ndate);
272
273                                                                                 // The date is "OK" - lets see if the weekday matches, too...
274
275                                                                                 if (in_array($dow,$cron[IDX_WEEKDAY])) {
276
277                                                                                         // WIN! :-) We found a valid date...
278
279                                                                                         $rtime                  = explode(',', strftime('%M,%H,%d,%m,%w,%Y', mktime($rtime[IDX_HOUR], $rtime[IDX_MINUTE], 0, $nmonth, $nday, $nyear)));
280
281                                                                                         return mktime($rtime[1], $rtime[0], 0, $rtime[3], $rtime[2], $rtime[5]);
282
283                                                                                 }
284
285                                                                         }
286
287                                                                 }
288
289                                                         }
290
291                                                 }
292
293                                         }
294
295                                 }
296
297                                 throw new Exception('Failed to find date, No matching date found in a 10 years range!', 10004);
298
299                         }
300
301                         return mktime($rtime[1], $rtime[0], 0, $rtime[3], $rtime[2], $rtime[5]);
302
303                 }
304
305                 /**
306                  * getTimestamp() converts an unix-timestamp to an array. The returned array contains the following values:
307                  *
308                  *      [0]     -> minute
309                  *      [1]     -> hour
310                  *      [2]     -> day
311                  *      [3]     -> month
312                  *      [4]     -> weekday
313                  *      [5]     -> year
314                  *
315                  * The array is used by various functions.
316                  *
317                  * @access      private
318                  * @param       int             $timestamp      If none is given, the current time is used
319                  * @return      mixed
320                  */
321
322                 static private function getTimestamp($timestamp = null) {
323
324                         if (is_null($timestamp)) {
325                                 $arr    = explode(',', strftime('%M,%H,%d,%m,%w,%Y', time()));
326                         } else {
327                                 $arr    = explode(',', strftime('%M,%H,%d,%m,%w,%Y', $timestamp));
328                         }
329
330                         // Remove leading zeros (or we'll get in trouble ;-)
331
332                         foreach ($arr as $key=>$value) {
333                                 $arr[$key]      = (int)ltrim($value,'0');
334                         }
335
336                         return $arr;
337
338                 }
339
340                 /**
341                  * findValue() checks if the given value exists in an array. If it does not exist, the next
342                  * higher/lower value is returned (depending on $next). If no higher/lower value exists,
343                  * false is returned.
344                  *
345                  * @access      public
346                  * @param       int             $value
347                  * @param       mixed           $data
348                  * @param       bool            $next
349                  * @return      mixed
350                  */
351
352                 static private function findValue($value, $data, $next = true) {
353
354                         if (in_array($value, $data)) {
355
356                                 return (int)$value;
357
358                         } else {
359
360                                 if (($next) ? ($value <= end($data)) : ($value >= end($data))) {
361
362                                         foreach ($data as $curval) {
363
364                                                 if (($next) ? ($value <= (int)$curval) : ($curval <= $value)) {
365
366                                                         return (int)$curval;
367
368                                                 }
369
370                                         }
371
372                                 }
373
374                         }
375
376                         return false;
377
378                 }
379
380                 /**
381                  * getExpression() returns a parsed cron-expression. Parsed cron-expressions are cached to reduce
382                  * unneccessary calls of the parser.
383                  *
384                  * @access      public
385                  * @param       string          $value
386                  * @param       bool            $reverse
387                  * @return      mixed
388                  */
389
390                  static private function getExpression($expression, $reverse=false) {
391
392                         // First of all we cleanup the expression and remove all duplicate tabs/spaces/etc.
393                         // For example "*              * *    * *" would be converted to "* * * * *", etc.
394
395                         $expression     = preg_replace('/(\s+)/', ' ', strtolower(trim($expression)));
396
397                         // Lets see if we've already parsed that expression
398
399                         if (!isset(self::$pcron[$expression])) {
400
401                                 // Nope - parse it!
402
403                                 try {
404
405                                         self::$pcron[$expression]               = tdCronEntry::parse($expression);
406                                         self::$pcron['reverse'][$expression]    = self::arrayReverse(self::$pcron[$expression]);
407
408                                 } catch (Exception $e) {
409
410                                         throw $e;
411
412                                 }
413
414                         }
415
416                         return ($reverse ? self::$pcron['reverse'][$expression] : self::$pcron[$expression]);
417
418                 }
419
420                 /**
421                  * arrayReverse() reverses all sub-arrays of our cron array. The reversed values are used for calculations
422                  * that are run when getLastOccurence() is called.
423                  *
424                  * @access      public
425                  * @param       mixed           $cron
426                  * @return      mixed
427                  */
428
429                 static private function arrayReverse($cron) {
430
431                         foreach ($cron as $key=>$value) {
432
433                                 $cron[$key]     = array_reverse($value);
434
435                         }
436
437                         return $cron;
438
439                 }
440
441         }