534 lines
24 KiB
PHP
534 lines
24 KiB
PHP
<?php
|
|
/**
|
|
* iCalcreator, a PHP rfc2445/rfc5545 solution.
|
|
*
|
|
* This file is a part of iCalcreator.
|
|
*
|
|
* Copyright (c) 2007-2017 Kjell-Inge Gustafsson, kigkonsult, All rights reserved
|
|
* Link http://kigkonsult.se/iCalcreator/index.php
|
|
* Package iCalcreator
|
|
* Version 2.24
|
|
* License Subject matter of licence is the software iCalcreator.
|
|
* The above copyright, link, package and version notices,
|
|
* this licence notice and the [rfc5545] PRODID as implemented and
|
|
* invoked in iCalcreator shall be included in all copies or
|
|
* substantial portions of the iCalcreator.
|
|
* iCalcreator can be used either under the terms of
|
|
* a proprietary license, available at <https://kigkonsult.se/>
|
|
* or the GNU Affero General Public License, version 3:
|
|
* iCalcreator is free software: you can redistribute it and/or
|
|
* modify it under the terms of the GNU Affero General Public License
|
|
* as published by the Free Software Foundation, either version 3 of
|
|
* the License, or (at your option) any later version.
|
|
* iCalcreator is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU Affero General Public License for more details.
|
|
* You should have received a copy of the GNU Affero General Public
|
|
* License along with this program.
|
|
* If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
namespace kigkonsult\iCalcreator\util;
|
|
/**
|
|
* iCalcreator EXDATE/RDATE support class
|
|
*
|
|
* @author Kjell-Inge Gustafsson, kigkonsult <ical@kigkonsult.se>
|
|
* @since 2.22.23 - 2017-04-04
|
|
*/
|
|
class utilRexdate {
|
|
/**
|
|
* Check (EXDATE/RDATE) date(-time) and params arrays for an opt. timezone
|
|
*
|
|
* If it is a DATE-TIME or DATE, updates $parno and (opt) $params)
|
|
* @param array $theDate date to check
|
|
* @param int $parno no of date parts (i.e. year, month.. .)
|
|
* @param array $params property parameters
|
|
* @access private
|
|
* @static
|
|
*/
|
|
private static function chkDateCfg( $theDate, & $parno, & $params ) {
|
|
$paramsValueIsDATE = util::isParamsValueSet( [util::$LCparams => $params],
|
|
util::$DATE );
|
|
switch( true ) {
|
|
case ( isset( $params[util::$TZID] )) :
|
|
$parno = 6;
|
|
break;
|
|
case ( $paramsValueIsDATE ) :
|
|
$params[util::$VALUE] = util::$DATE;
|
|
$parno = 3;
|
|
break;
|
|
default:
|
|
if( util::isParamsValueSet( [util::$LCparams => $params],
|
|
util::$PERIOD )) {
|
|
$params[util::$VALUE] = util::$PERIOD;
|
|
$parno = 7;
|
|
}
|
|
switch( true ) {
|
|
case ( is_array( $theDate )) :
|
|
if( isset( $theDate[util::$LCTIMESTAMP] ))
|
|
$tzid = ( isset( $theDate[util::$LCtz] ))
|
|
? $theDate[util::$LCtz] : null;
|
|
else
|
|
$tzid = ( isset( $theDate[util::$LCtz] ))
|
|
? $theDate[util::$LCtz] : ( 7 == count( $theDate )) ? end( $theDate ) : null;
|
|
if( ! empty( $tzid )) {
|
|
$parno = 7;
|
|
if( ! util::isOffset( $tzid ))
|
|
$params[util::$TZID] = $tzid; // save only timezone
|
|
}
|
|
elseif( ! $parno &&
|
|
( 3 == count( $theDate )) &&
|
|
$paramsValueIsDATE )
|
|
$parno = 3;
|
|
else
|
|
$parno = 6;
|
|
break;
|
|
default : // i.e. string
|
|
$date = trim((string) $theDate );
|
|
if( util::$Z == substr( $date, -1 ))
|
|
$parno = 7; // UTC DATE-TIME
|
|
elseif((( 8 == strlen( $date ) && ctype_digit( $date )) ||
|
|
( 11 >= strlen( $date )))
|
|
&& $paramsValueIsDATE )
|
|
$parno = 3;
|
|
$date = util::strDate2ArrayDate( $date, $parno );
|
|
unset( $date[util::$UNPARSEDTEXT] );
|
|
if( ! empty( $date[util::$LCtz] )) {
|
|
$parno = 7;
|
|
if( ! util::isOffset( $date[util::$LCtz] ))
|
|
$params[util::$TZID] = $date[util::$LCtz]; // save only timezone
|
|
}
|
|
elseif( empty( $parno ))
|
|
$parno = 6;
|
|
} // end switch( true )
|
|
if( isset( $params[util::$TZID] ))
|
|
$parno = 6;
|
|
break;
|
|
} // end switch( true )
|
|
return true;
|
|
}
|
|
/**
|
|
* Return formatted output for calendar component property data value type recur
|
|
*
|
|
* @param array $exdateData
|
|
* @param bool $allowEmpty
|
|
* @return string
|
|
* @static
|
|
*/
|
|
public static function formatExdate( $exdateData, $allowEmpty ) {
|
|
static $SORTER1 = ['kigkonsult\iCalcreator\vcalendarSortHandler',
|
|
'sortExdate1'];
|
|
static $SORTER2 = ['kigkonsult\iCalcreator\vcalendarSortHandler',
|
|
'sortExdate2'];
|
|
$output = null;
|
|
$exdates = [];
|
|
foreach(( array_keys( $exdateData )) as $ex ) {
|
|
$theExdate = $exdateData[$ex];
|
|
if( empty( $theExdate[util::$LCvalue] )) {
|
|
if( $allowEmpty )
|
|
$output .= util::createElement( util::$EXDATE );
|
|
continue;
|
|
}
|
|
if( 1 < count( $theExdate[util::$LCvalue] ))
|
|
usort( $theExdate[util::$LCvalue], $SORTER1 );
|
|
$exdates[] = $theExdate;
|
|
}
|
|
if( 1 < count( $exdates ))
|
|
usort( $exdates, $SORTER2 );
|
|
foreach(( array_keys( $exdates )) as $ex ) {
|
|
$theExdate = $exdates[$ex];
|
|
$content = $attributes = null;
|
|
foreach(( array_keys( $theExdate[util::$LCvalue] )) as $eix ) {
|
|
$exdatePart = $theExdate[util::$LCvalue][$eix];
|
|
$parno = count( $exdatePart );
|
|
$formatted = util::date2strdate( $exdatePart, $parno );
|
|
if( isset( $theExdate[util::$LCparams][util::$TZID] ))
|
|
$formatted = str_replace( util::$Z, null, $formatted);
|
|
if( 0 < $eix ) {
|
|
if( isset( $theExdate[util::$LCvalue][0][util::$LCtz] )) {
|
|
if( ctype_digit( substr( $theExdate[util::$LCvalue][0][util::$LCtz], -4 )) ||
|
|
( util::$Z == $theExdate[util::$LCvalue][0][util::$LCtz] )) {
|
|
if( util::$Z != substr( $formatted, -1 ))
|
|
$formatted .= util::$Z;
|
|
}
|
|
else
|
|
$formatted = str_replace( util::$Z, null, $formatted );
|
|
}
|
|
else
|
|
$formatted = str_replace( util::$Z, null, $formatted );
|
|
} // end if( 0 < $eix )
|
|
$content .= ( 0 < $eix ) ? util::$COMMA . $formatted : $formatted;
|
|
} // end foreach(( array_keys( $theExdate[util::$LCvalue]...
|
|
$output .= util::createElement( util::$EXDATE,
|
|
util::createParams( $theExdate[util::$LCparams] ),
|
|
$content );
|
|
} // end foreach(( array_keys( $exdates...
|
|
return $output;
|
|
}
|
|
/**
|
|
* Return prepared calendar component property exdate input
|
|
*
|
|
* @param array $exdates
|
|
* @param array $params
|
|
* @return array
|
|
* @static
|
|
*/
|
|
public static function prepInputExdate( $exdates, $params=null ) {
|
|
static $GMTUTCZARR = ['GMT', 'UTC', 'Z'];
|
|
$input = [util::$LCparams => util::setParams( $params,
|
|
util::$DEFAULTVALUEDATETIME )];
|
|
$toZ = ( isset( $input[util::$LCparams][util::$TZID] ) &&
|
|
in_array( strtoupper( $input[util::$LCparams][util::$TZID] ),
|
|
$GMTUTCZARR ))
|
|
? true : false;
|
|
/* ev. check 1:st date and save ev. timezone **/
|
|
self::chkDateCfg( reset( $exdates ), $parno, $input[util::$LCparams] );
|
|
util::existRem( $input[util::$LCparams],
|
|
util::$VALUE,
|
|
util::$DATE_TIME ); // remove default parameter
|
|
foreach(( array_keys( $exdates )) as $eix ) {
|
|
$theExdate = $exdates[$eix];
|
|
util::strDate2arr( $theExdate );
|
|
if( util::isArrayTimestampDate( $theExdate )) {
|
|
if( isset( $theExdate[util::$LCtz] ) &&
|
|
! util::isOffset( $theExdate[util::$LCtz] )) {
|
|
if( isset( $input[util::$LCparams][util::$TZID] ))
|
|
$theExdate[util::$LCtz] = $input[util::$LCparams][util::$TZID];
|
|
else
|
|
$input[util::$LCparams][util::$TZID] = $theExdate[util::$LCtz];
|
|
}
|
|
$exdatea = util::timestamp2date( $theExdate, $parno );
|
|
}
|
|
elseif( is_array( $theExdate )) {
|
|
$d = util::chkDateArr( $theExdate, $parno );
|
|
if( isset( $d[util::$LCtz] ) &&
|
|
( util::$Z != $d[util::$LCtz] ) &&
|
|
util::isOffset( $d[util::$LCtz] )) {
|
|
$strdate = sprintf( util::$YMDHISE, (int) $d[util::$LCYEAR],
|
|
(int) $d[util::$LCMONTH],
|
|
(int) $d[util::$LCDAY],
|
|
(int) $d[util::$LCHOUR],
|
|
(int) $d[util::$LCMIN],
|
|
(int) $d[util::$LCSEC],
|
|
$d[util::$LCtz] );
|
|
$exdatea = util::strDate2ArrayDate( $strdate, 7 );
|
|
unset( $exdatea[util::$UNPARSEDTEXT] );
|
|
}
|
|
else
|
|
$exdatea = $d;
|
|
}
|
|
elseif( 8 <= strlen( trim( $theExdate ))) { // ex. 2006-08-03 10:12:18
|
|
$exdatea = util::strDate2ArrayDate( $theExdate, $parno );
|
|
unset( $exdatea[util::$UNPARSEDTEXT] );
|
|
}
|
|
if( 3 == $parno )
|
|
unset( $exdatea[util::$LCHOUR],
|
|
$exdatea[util::$LCMIN],
|
|
$exdatea[util::$LCSEC],
|
|
$exdatea[util::$LCtz] );
|
|
elseif( isset( $exdatea[util::$LCtz] ))
|
|
$exdatea[util::$LCtz] = (string) $exdatea[util::$LCtz];
|
|
if( isset( $input[util::$LCparams][util::$TZID] ) ||
|
|
( isset( $exdatea[util::$LCtz] ) &&
|
|
! util::isOffset( $exdatea[util::$LCtz] )) ||
|
|
( isset( $input[util::$LCvalue][0] ) &&
|
|
( ! isset( $input[util::$LCvalue][0][util::$LCtz] ))) ||
|
|
( isset( $input[util::$LCvalue][0][util::$LCtz] ) &&
|
|
! util::isOffset( $input[util::$LCvalue][0][util::$LCtz] )))
|
|
unset( $exdatea[util::$LCtz] );
|
|
if( $toZ ) // time zone Z
|
|
$exdatea[util::$LCtz] = util::$Z;
|
|
$input[util::$LCvalue][] = $exdatea;
|
|
} // end foreach(( array_keys( $exdates...
|
|
if( 0 >= count( $input[util::$LCvalue] ))
|
|
return false;
|
|
if( 3 == $parno ) {
|
|
$input[util::$LCparams][util::$VALUE] = util::$DATE;
|
|
unset( $input[util::$LCparams][util::$TZID] );
|
|
}
|
|
if( $toZ ) // time zone Z
|
|
unset( $input[util::$LCparams][util::$TZID] );
|
|
return $input;
|
|
}
|
|
/**
|
|
* Return formatted output for calendar component property rdate
|
|
*
|
|
* @param array $rdateData
|
|
* @param bool $allowEmpty
|
|
* @param string $objName
|
|
* @return string
|
|
* @static
|
|
*/
|
|
public static function formatRdate( $rdateData, $allowEmpty, $objName ) {
|
|
static $SORTER1 = ['kigkonsult\iCalcreator\vcalendarSortHandler',
|
|
'sortRdate1'];
|
|
static $SORTER2 = ['kigkonsult\iCalcreator\vcalendarSortHandler',
|
|
'sortRdate2'];
|
|
$utcTime = ( in_array( $objName, util::$TZCOMPS )) ? true : false;
|
|
$output = null;
|
|
$rdates = [];
|
|
foreach(( array_keys( $rdateData )) as $rpix ) {
|
|
$theRdate = $rdateData[$rpix];
|
|
if( empty( $theRdate[util::$LCvalue] )) {
|
|
if( $allowEmpty )
|
|
$output .= util::createElement( util::$RDATE );
|
|
continue;
|
|
}
|
|
if( $utcTime )
|
|
unset( $theRdate[util::$LCparams][util::$TZID] );
|
|
if( 1 < count( $theRdate[util::$LCvalue] ))
|
|
usort( $theRdate[util::$LCvalue], $SORTER1 );
|
|
$rdates[] = $theRdate;
|
|
}
|
|
if( 1 < count( $rdates ))
|
|
usort( $rdates, $SORTER2 );
|
|
foreach(( array_keys( $rdates )) as $rpix ) {
|
|
$theRdate = $rdates[$rpix];
|
|
$attributes = util::createParams( $theRdate[util::$LCparams] );
|
|
$cnt = count( $theRdate[util::$LCvalue] );
|
|
$content = null;
|
|
$rno = 1;
|
|
foreach(( array_keys( $theRdate[util::$LCvalue] )) as $rix ) {
|
|
$rdatePart = $theRdate[util::$LCvalue][$rix];
|
|
$contentPart = null;
|
|
if( is_array( $rdatePart ) &&
|
|
util::isParamsValueSet( $theRdate, util::$PERIOD )) { // PERIOD
|
|
if( $utcTime )
|
|
unset( $rdatePart[0][util::$LCtz] );
|
|
$formatted = util::date2strdate( $rdatePart[0] ); // PERIOD part 1
|
|
if( $utcTime || !empty( $theRdate[util::$LCparams][util::$TZID] ))
|
|
$formatted = str_replace( util::$Z, null, $formatted);
|
|
$contentPart .= $formatted;
|
|
$contentPart .= '/';
|
|
$cnt2 = count( $rdatePart[1]);
|
|
if( array_key_exists( util::$LCYEAR, $rdatePart[1] )) {
|
|
if( array_key_exists( util::$LCHOUR, $rdatePart[1] ))
|
|
$cnt2 = 7; // date-time
|
|
else
|
|
$cnt2 = 3; // date
|
|
}
|
|
elseif( array_key_exists( util::$LCWEEK, $rdatePart[1] )) // duration
|
|
$cnt2 = 5;
|
|
if(( 7 == $cnt2 ) && // period= -> date-time
|
|
isset( $rdatePart[1][util::$LCYEAR] ) &&
|
|
isset( $rdatePart[1][util::$LCMONTH] ) &&
|
|
isset( $rdatePart[1][util::$LCDAY] )) {
|
|
if( $utcTime )
|
|
unset( $rdatePart[1][util::$LCtz] );
|
|
$formatted = util::date2strdate( $rdatePart[1] ); // PERIOD part 2
|
|
if( $utcTime || !empty( $theRdate[util::$LCparams][util::$TZID] ))
|
|
$formatted = str_replace( util::$Z, null, $formatted );
|
|
$contentPart .= $formatted;
|
|
}
|
|
else { // period= -> dur-time
|
|
$contentPart .= util::duration2str( $rdatePart[1] );
|
|
}
|
|
} // PERIOD end
|
|
else { // SINGLE date start
|
|
if( $utcTime )
|
|
unset( $rdatePart[util::$LCtz] );
|
|
$parno = ( util::isParamsValueSet( $theRdate, util::$DATE )) ? 3 : null;
|
|
$formatted = util::date2strdate( $rdatePart, $parno );
|
|
if( $utcTime || !empty( $theRdate[util::$LCparams][util::$TZID] ))
|
|
$formatted = str_replace( util::$Z, null, $formatted);
|
|
$contentPart .= $formatted;
|
|
}
|
|
$content .= $contentPart;
|
|
if( $rno < $cnt )
|
|
$content .= util::$COMMA;
|
|
$rno++;
|
|
} // end foreach(( array_keys( $theRdate[util::$LCvalue]...
|
|
$output .= util::createElement( util::$RDATE,
|
|
$attributes,
|
|
$content );
|
|
} // foreach(( array_keys( $rdates...
|
|
return $output;
|
|
}
|
|
/**
|
|
* Return prepared calendar component property rdate input
|
|
*
|
|
* @param array $rdates
|
|
* @param array $params
|
|
* @param string $objName
|
|
* @return array
|
|
* @static
|
|
*/
|
|
public static function prepInputRdate( $rdates, $params, $objName ) {
|
|
static $PREFIXARR = ['P', '+', '-'];
|
|
static $GMTUTCZARR = ['GMT', 'UTC', 'Z'];
|
|
$input = [util::$LCparams => util::setParams( $params,
|
|
util::$DEFAULTVALUEDATETIME )];
|
|
if( in_array( $objName, util::$TZCOMPS )) {
|
|
unset( $input[util::$LCparams][util::$TZID] );
|
|
$input[util::$LCparams][util::$VALUE] = util::$DATE_TIME;
|
|
}
|
|
$toZ = ( isset( $params[util::$TZID] ) &&
|
|
in_array( strtoupper( $params[util::$TZID] ),
|
|
$GMTUTCZARR ))
|
|
? true : false;
|
|
/* check if PERIOD, if not set */
|
|
if(( ! isset( $input[util::$LCparams][util::$VALUE] ) ||
|
|
( ! util::isParamsValueSet( $input, util::$DATE ) &&
|
|
! util::isParamsValueSet( $input, util::$PERIOD ))) &&
|
|
isset( $rdates[0] ) && is_array( $rdates[0] ) && ( 2 == count( $rdates[0] )) &&
|
|
isset( $rdates[0][0] ) && isset( $rdates[0][1] ) && ! isset( $rdates[0][util::$LCTIMESTAMP] ) &&
|
|
(( is_array( $rdates[0][0] ) && ( isset( $rdates[0][0][util::$LCTIMESTAMP] ) ||
|
|
util::isArrayDate( $rdates[0][0] ))) ||
|
|
( is_string( $rdates[0][0] ) && ( 8 <= strlen( trim( $rdates[0][0] ))))) &&
|
|
( is_array( $rdates[0][1] ) || ( is_string( $rdates[0][1] ) && ( 3 <= strlen( trim( $rdates[0][1] ))))))
|
|
$input[util::$LCparams][util::$VALUE] = util::$PERIOD;
|
|
/* check 1:st date, upd. $parno (opt) and save opt. timezone **/
|
|
$date = reset( $rdates );
|
|
if( isset( $input[util::$LCparams][util::$VALUE] ) &&
|
|
( util::$PERIOD == $input[util::$LCparams][util::$VALUE] )) // PERIOD
|
|
$date = reset( $date );
|
|
self::chkDateCfg( $date, $parno, $input[util::$LCparams] );
|
|
util::existRem( $input[util::$LCparams],
|
|
util::$VALUE,
|
|
util::$DATE_TIME ); // remove default
|
|
foreach( $rdates as $rpix => $theRdate ) {
|
|
$inputa = null;
|
|
util::strDate2arr( $theRdate );
|
|
if( is_array( $theRdate )) {
|
|
if( isset( $input[util::$LCparams][util::$VALUE] ) &&
|
|
( util::$PERIOD == $input[util::$LCparams][util::$VALUE] )) { // PERIOD
|
|
foreach( $theRdate as $rix => $rPeriod ) {
|
|
util::strDate2arr( $theRdate );
|
|
if( is_array( $rPeriod )) {
|
|
if( util::isArrayTimestampDate( $rPeriod )) { // timestamp
|
|
if( isset( $rPeriod[util::$LCtz] ) &&
|
|
! util::isOffset( $rPeriod[util::$LCtz] )) {
|
|
if( isset( $input[util::$LCparams][util::$TZID] ))
|
|
$rPeriod[util::$LCtz] = $input[util::$LCparams][util::$TZID];
|
|
else
|
|
$input[util::$LCparams][util::$TZID] = $rPeriod[util::$LCtz];
|
|
}
|
|
$inputab = util::timestamp2date( $rPeriod, $parno );
|
|
} // end if( util::isArrayTimestampDate( $rPeriod ))
|
|
elseif( util::isArrayDate( $rPeriod )) {
|
|
$d = ( 3 < count ( $rPeriod ))
|
|
? util::chkDateArr( $rPeriod, $parno )
|
|
: util::chkDateArr( $rPeriod, 6 );
|
|
if( isset( $d[util::$LCtz] ) &&
|
|
( util::$Z != $d[util::$LCtz] ) &&
|
|
util::isOffset( $d[util::$LCtz] )) {
|
|
$inputab = util::strDate2ArrayDate( sprintf( util::$YMDHISE,
|
|
(int) $d[util::$LCYEAR],
|
|
(int) $d[util::$LCMONTH],
|
|
(int) $d[util::$LCDAY],
|
|
(int) $d[util::$LCHOUR],
|
|
(int) $d[util::$LCMIN],
|
|
(int) $d[util::$LCSEC],
|
|
$d[util::$LCtz] ),
|
|
7 );
|
|
unset( $inputab[util::$UNPARSEDTEXT] );
|
|
}
|
|
else
|
|
$inputab = $d;
|
|
} // end elseif( util::isArrayDate( $rPeriod ))
|
|
elseif(( 1 == count( $rPeriod )) &&
|
|
( 8 <= strlen( reset( $rPeriod )))) { // text-date
|
|
$inputab = util::strDate2ArrayDate( reset( $rPeriod ), $parno );
|
|
unset( $inputab[util::$UNPARSEDTEXT] );
|
|
}
|
|
else // array format duration
|
|
$inputab = util::duration2arr( $rPeriod );
|
|
} // end if( is_array( $rPeriod ))
|
|
elseif(( 3 <= strlen( trim( $rPeriod ))) && // string format duration
|
|
( in_array( $rPeriod[0], $PREFIXARR ))) {
|
|
if( 'P' != $rPeriod[0] )
|
|
$rPeriod = substr( $rPeriod, 1 );
|
|
$inputab = util::durationStr2arr( $rPeriod );
|
|
}
|
|
elseif( 8 <= strlen( trim( $rPeriod ))) { // text date ex. 2006-08-03 10:12:18
|
|
$inputab = util::strDate2ArrayDate( $rPeriod, $parno );
|
|
unset( $inputab[util::$UNPARSEDTEXT] );
|
|
}
|
|
if(( 0 == $rpix ) && ( 0 == $rix )) {
|
|
if( isset( $inputab[util::$LCtz] ) &&
|
|
in_array( strtoupper( $inputab[util::$LCtz] ),
|
|
$GMTUTCZARR )) {
|
|
$inputab[util::$LCtz] = util::$Z;
|
|
$toZ = true;
|
|
}
|
|
}
|
|
else {
|
|
if( isset( $inputa[0][util::$LCtz] ) &&
|
|
( util::$Z == $inputa[0][util::$LCtz] ) &&
|
|
isset( $inputab[util::$LCYEAR] ))
|
|
$inputab[util::$LCtz] = util::$Z;
|
|
else
|
|
unset( $inputab[util::$LCtz] );
|
|
}
|
|
if( $toZ && isset( $inputab[util::$LCYEAR] ) )
|
|
$inputab[util::$LCtz] = util::$Z;
|
|
$inputa[] = $inputab;
|
|
} // end foreach( $theRdate as $rix => $rPeriod )
|
|
} // PERIOD end
|
|
elseif ( util::isArrayTimestampDate( $theRdate )) { // timestamp
|
|
if( isset( $theRdate[util::$LCtz] ) &&
|
|
! util::isOffset( $theRdate[util::$LCtz] )) {
|
|
if( isset( $input[util::$LCparams][util::$TZID] ))
|
|
$theRdate[util::$LCtz] = $input[util::$LCparams][util::$TZID];
|
|
else
|
|
$input[util::$LCparams][util::$TZID] = $theRdate[util::$LCtz];
|
|
}
|
|
$inputa = util::timestamp2date( $theRdate, $parno );
|
|
}
|
|
else { // date[-time]
|
|
$inputa = util::chkDateArr( $theRdate, $parno );
|
|
if( isset( $inputa[util::$LCtz] ) &&
|
|
( util::$Z != $inputa[util::$LCtz] ) &&
|
|
util::isOffset( $inputa[util::$LCtz] )) {
|
|
$inputa = util::strDate2ArrayDate( sprintf( util::$YMDHISE,
|
|
(int) $inputa[util::$LCYEAR],
|
|
(int) $inputa[util::$LCMONTH],
|
|
(int) $inputa[util::$LCDAY],
|
|
(int) $inputa[util::$LCHOUR],
|
|
(int) $inputa[util::$LCMIN],
|
|
(int) $inputa[util::$LCSEC],
|
|
$inputa[util::$LCtz] ),
|
|
7 );
|
|
unset( $inputa[util::$UNPARSEDTEXT] );
|
|
}
|
|
}
|
|
} // end if( is_array( $theRdate ))
|
|
elseif( 8 <= strlen( trim( $theRdate ))) { // text date ex. 2006-08-03 10:12:18
|
|
$inputa = util::strDate2ArrayDate( $theRdate, $parno );
|
|
unset( $inputa[util::$UNPARSEDTEXT] );
|
|
if( $toZ )
|
|
$inputa[util::$LCtz] = util::$Z;
|
|
}
|
|
if( ! isset( $input[util::$LCparams][util::$VALUE] ) ||
|
|
( util::$PERIOD != $input[util::$LCparams][util::$VALUE] )) { // no PERIOD
|
|
if(( 0 == $rpix ) && !$toZ )
|
|
$toZ = ( isset( $inputa[util::$LCtz] ) &&
|
|
in_array( strtoupper( $inputa[util::$LCtz] ), $GMTUTCZARR ))
|
|
? true : false;
|
|
if( $toZ )
|
|
$inputa[util::$LCtz] = util::$Z;
|
|
if( 3 == $parno )
|
|
unset( $inputa[util::$LCHOUR],
|
|
$inputa[util::$LCMIN],
|
|
$inputa[util::$LCSEC],
|
|
$inputa[util::$LCtz] );
|
|
elseif( isset( $inputa[util::$LCtz] ))
|
|
$inputa[util::$LCtz] = (string) $inputa[util::$LCtz];
|
|
if( isset( $input[util::$LCparams][util::$TZID] ) ||
|
|
( isset( $input[util::$LCvalue][0] ) &&
|
|
( ! isset( $input[util::$LCvalue][0][util::$LCtz] ))))
|
|
if( !$toZ )
|
|
unset( $inputa[util::$LCtz] );
|
|
}
|
|
$input[util::$LCvalue][] = $inputa;
|
|
}
|
|
if( 3 == $parno ) {
|
|
$input[util::$LCparams][util::$VALUE] = util::$DATE;
|
|
unset( $input[util::$LCparams][util::$TZID] );
|
|
}
|
|
if( $toZ )
|
|
unset( $input[util::$LCparams][util::$TZID] );
|
|
return $input;
|
|
}
|
|
}
|