PHP DateTimeImmutable::setTimezone方法代码示例

 /**
  * Snapshot constructor.
  * @param AggregateIdInterface $aggregateId
  * @param AggregateRootInterface $aggregate
  * @param string $version
  * @param \DateTimeImmutable $createdAt
  */
 public function __construct(AggregateIdInterface $aggregateId, AggregateRootInterface $aggregate, $version, \DateTimeImmutable $createdAt)
 {
     $this->aggregateId = $aggregateId;
     $this->aggregate = $aggregate;
     $this->version = $version;
     $this->createdAt = $createdAt->setTimezone(new \DateTimeZone('UTC'));
 }

 /**
  * @param AggregateIdInterface|string $id
  * @param $version
  * @param mixed $payload
  * @param \DateTimeImmutable $recordedOn
  */
 public function __construct($id, $version, $payload, \DateTimeImmutable $recordedOn)
 {
     $this->id = (string) $id;
     $this->payload = $payload;
     $this->recordedOn = $recordedOn->setTimezone(new \DateTimeZone('UTC'));
     $this->version = $version;
 }

 /**
  * Set the date-time of the Date in this Header.
  *
  * If a DateTime instance is provided, it is converted to DateTimeImmutable.
  *
  * @param DateTimeInterface $dateTime
  */
 public function setDateTime(DateTimeInterface $dateTime)
 {
     $this->clearCachedValueIf($this->getCachedValue() != $dateTime->format(DateTime::RFC2822));
     if ($dateTime instanceof DateTime) {
         $immutable = new DateTimeImmutable('@' . $dateTime->getTimestamp());
         $dateTime = $immutable->setTimezone($dateTime->getTimezone());
     }
     $this->dateTime = $dateTime;
 }

 public static function craftDateTime($seconds, $microseconds = 0)
 {
     // Override \Doctrine\ODM\MongoDB\Types\DateType::craftDateTime to return a DateTimeImmutable object
     // in the 'UTC' timezone instead the current PHP one (date_default_timezone_get())
     $datetime = new \DateTimeImmutable();
     $datetime->setTimezone(new \DateTimeZone('UTC'));
     $datetime->setTimestamp($seconds);
     if ($microseconds > 0) {
         $datetime = \DateTimeImmutable::createFromFormat('Y-m-d H:i:s.u', $datetime->format('Y-m-d H:i:s') . '.' . $microseconds, new \DateTimeZone('UTC'));
     }
     return $datetime;
 }

 /**
  * Returns a DateTime of the numbered day of range of DateRange.
  * If $day is a negative number, it will count backwards from the end of the DateRange.
  * Example (2015-01-01 to 2015-01-31):
  * * 1 = first day of range: 2015-01-01
  * * 10 = tenth day of range: 2015-01-10
  * * -1 = last day of range: 2015-01-31
  * * -5 = fifth to last day: 2015-01-27
  *
  * @param int $day
  * @return \DateTime
  * @throws \Exception if $day falls outside of range
  */
 public function getDayOfRange($day)
 {
     $return = $this->start->setTimezone($this->returnTimezone);
     if ($day > 1) {
         // subtract 1 from the day because 1 should be the first day of the range, not 1 day after start of range
         $daysToAdd = new \DateInterval('P' . ($day - 1) . 'D');
         $return = $return->add($daysToAdd);
     }
     if ($day < 0) {
         $return = $this->end->setTimezone($this->returnTimezone);
         // subtract 1 from the day because 1 should be the last day of the range, not 1 day before end of range
         $return = $return->sub(new \DateInterval('P' . (abs($day) - 1) . 'D'));
     }
     if ($return < $this->start->setTimezone($this->returnTimezone) || $return > $this->end->setTimezone($this->returnTimezone)) {
         throw new \Exception('Requested day falls outside of DateRange');
     }
     return new \DateTime($return->format('Y-m-d'));
 }

 public function isValid(&$value)
 {
     if ($value === NULL && $this->isNullable) {
         return TRUE;
     }
     if ($this->enum) {
         return in_array($value, $this->enum, TRUE);
     }
     foreach ($this->types as $type => $foo) {
         if ($type === 'datetime') {
             if ($value instanceof \DateTime) {
                 return TRUE;
             } elseif ($value instanceof \DateTimeImmutable) {
                 $value = new \DateTime($value->format('c'));
                 return TRUE;
             } elseif (is_string($value) && $value !== '') {
                 $value = new \DateTime($value);
                 $value->setTimezone(new DateTimeZone(date_default_timezone_get()));
                 return TRUE;
             } elseif (ctype_digit($value)) {
                 $value = new \DateTime("@{$value}");
                 return TRUE;
             }
         } elseif ($type === 'datetimeimmutable') {
             if ($value instanceof \DateTimeImmutable) {
                 return TRUE;
             } elseif ($value instanceof \DateTime) {
                 $value = new \DateTimeImmutable($value->format('c'));
                 return TRUE;
             } elseif (is_string($value) && $value !== '') {
                 $tmp = new \DateTimeImmutable($value);
                 $value = $tmp->setTimezone(new DateTimeZone(date_default_timezone_get()));
                 return TRUE;
             } elseif (ctype_digit($value)) {
                 $value = new \DateTimeImmutable("@{$value}");
                 return TRUE;
             }
         } elseif ($type === 'string') {
             if (is_string($value)) {
                 return TRUE;
             }
             if (is_int($value) || is_object($value) && method_exists($value, '__toString')) {
                 $value = (string) $value;
                 return TRUE;
             }
         } elseif ($type === 'float') {
             if (is_float($value)) {
                 return TRUE;
             }
             if (is_numeric($value)) {
                 settype($value, 'float');
                 return TRUE;
             } elseif (is_string($value)) {
                 $value = (double) str_replace(array(' ', ','), array('', '.'), $value);
                 return TRUE;
             }
         } elseif ($type === 'int') {
             if (is_int($value)) {
                 return TRUE;
             }
             if (is_numeric($value)) {
                 settype($value, 'int');
                 return TRUE;
             } elseif (is_string($value)) {
                 $value = (int) str_replace(array(' ', ','), array('', '.'), $value);
                 return TRUE;
             }
         } elseif ($type === 'bool') {
             if (is_bool($value)) {
                 return TRUE;
             }
             if (in_array($value, array(0, 0.0, '0', 1, 1.0, '1'), TRUE)) {
                 $value = (bool) $value;
                 return TRUE;
             }
         } elseif ($type === 'array') {
             if (is_array($value)) {
                 return TRUE;
             }
         } elseif ($type === 'object') {
             if (is_object($value)) {
                 return TRUE;
             }
         } elseif ($type === 'scalar') {
             if (is_scalar($value)) {
                 return TRUE;
             }
         } elseif ($type === 'mixed') {
             return TRUE;
         } else {
             if ($value instanceof $type) {
                 return TRUE;
             }
         }
     }
     return FALSE;
 }

 public function testSetTimezone()
 {
     $time = '2000-01-02T03:14:25';
     $immutable = new DateTimeImmutable($time);
     $control = new DateTimeImmutable($time);
     $mutable = new DateTime($time);
     $timezone = new DateTimeZone('Pacific/Nauru');
     $new = $immutable->setTimezone($timezone);
     $mutable->setTimezone($timezone);
     $this->assertNotSame($immutable, $new);
     $this->assertSame($control->format(DateTime::RFC3339), $immutable->format(DateTime::RFC3339));
     $this->assertSame($mutable->format(DateTime::RFC3339), $new->format(DateTime::RFC3339));
 }

 /**
  * Format the date based on the ISO 8601 date formats
  * @see https://docs.threads.io/docs/threads-timestamp-format
  *
  * @param \DateTimeImmutable $datetime
  *
  * @return string
  */
 private function formatDate(\DateTimeImmutable $datetime)
 {
     return str_replace('+00:00', '.000Z', $datetime->setTimezone(new \DateTimeZone('UTC'))->format('c'));
 }

 /**
  * DateTimeHelper::getDatetime() from SonataIntlBundle
  *
  * @param \Datetime|\DateTimeImmutable|string|integer $data
  * @param \DateTimeZone timezone
  * @return \Datetime
  */
 protected function getDatetime($data, \DateTimeZone $timezone)
 {
     if ($data instanceof \DateTime || $data instanceof \DateTimeImmutable) {
         return $data->setTimezone($timezone);
     }
     // the format method accept array or integer
     if (is_numeric($data)) {
         $data = (int) $data;
     }
     if (is_string($data)) {
         $data = strtotime($data);
     }
     // MongoDB Date and Timestamp
     if ($data instanceof \MongoDate || $data instanceof \MongoTimestamp) {
         $data = $data->sec;
     }
     // Mongodb bug ? timestamp value is on the key 'i' instead of the key 't'
     if (is_array($data) && array_keys($data) == array('t', 'i')) {
         $data = $data['i'];
     }
     $date = new \DateTime();
     $date->setTimestamp($data);
     $date->setTimezone($timezone);
     return $date;
 }

 function get_extend_until_info($user, $group, $periods = 1)
 {
     //use these functions to get current expiry dates for existing members - they are calculated in some cases
     //so just grabbing the "expire" field from the users_usergroups table doesn't always work
     $userInfo = $this->get_user_info($user);
     $usergroupdates = $this->get_user_groups_date($userInfo['userId']);
     $info = $this->get_group_info($group);
     //set the start date as now for new memberships and as expiry of current membership for existing members
     if (array_key_exists($group, $usergroupdates)) {
         if (!empty($usergroupdates[$group]['expire'])) {
             $date = $usergroupdates[$group]['expire'];
         } elseif ($info['expireAfter'] > 0) {
             $date = $usergroupdates[$group]['created'];
         }
     }
     if (!isset($date) || !$date) {
         $date = $this->now;
         //this is a new membership
         $new = true;
     }
     //convert start date to object
     $rawstartutc = new DateTimeImmutable('@' . $date);
     global $prefs;
     $tz = TikiDate::TimezoneIsValidId($prefs['server_timezone']) ? $prefs['server_timezone'] : 'UTC';
     $timezone = new DateTimeZone($tz);
     $startlocal = $rawstartutc->setTimezone($timezone);
     //anniversary memberships
     if (!empty($info['anniversary'])) {
         //set time to 1 second after midnight so that all times are set to same times for interval calculations
         $startlocal = $startlocal->setTime(0, 0, 1);
         // annual anniversaries
         if (strlen($info['anniversary']) == 4) {
             $ann_month = substr($info['anniversary'], 0, 2);
             $ann_day = substr($info['anniversary'], 2, 2);
             $startyear = $startlocal->format('Y');
             //increment the year if past the annual anniversary
             if ($startlocal->format('m') > $ann_month || $startlocal->format('m') == $ann_month && $startlocal->format('d') >= $ann_day) {
                 $startyear++;
             }
             //first extension is always to next anniversary
             $next_ann = $startlocal->setDate($startyear, $ann_month, $ann_day);
             //extend past next anniversary if more than one period
             $extendto = $next_ann->modify('+' . $periods - 1 . ' years');
             //previous anniversary for proration
             $prev_ann = $next_ann->modify('-1 years');
             // monthly anniversaries
             //using modify('+1 month') can result in "skipping" months so fix the day of the previous/next month
         } elseif (strlen($info['anniversary']) == 2) {
             $ann_day = $info['anniversary'];
             $lastday = date('d', strtotime('last day of ' . $startlocal->format('Y') . '-' . $startlocal->format('m')));
             $mod_ann_day = $ann_day > $lastday ? $lastday : $ann_day;
             if ($startlocal->format('d') < $mod_ann_day) {
                 $mod = $mod_ann_day - $startlocal->format('d');
                 $next_ann = $startlocal->modify('+' . $mod . ' days');
                 $prev_mo_lastday = $startlocal->modify('last day of last month');
                 if ($ann_day >= $prev_mo_lastday->format('d')) {
                     $prev_ann = $prev_mo_lastday;
                 } else {
                     $prev_ann = $startlocal->setDate($prev_mo_lastday->format('Y'), $prev_mo_lastday->format('m'), $mod_ann_day);
                 }
             } else {
                 //check if last day of month
                 $next_mo_lastday = $startlocal->modify('last day of next month');
                 if ($mod_ann_day >= $next_mo_lastday->format('d')) {
                     $next_ann = $next_mo_lastday;
                 } else {
                     $next_ann = $startlocal->setDate($next_mo_lastday->format('Y'), $next_mo_lastday->format('m'), $mod_ann_day);
                 }
                 $mod = $startlocal->format('d') - $mod_ann_day;
                 $prev_ann = $startlocal->modify('-' . $mod . ' days');
             }
             if ($periods - 1 > 0) {
                 $yrsplus = floor(($periods - 1) / 12);
                 $yr = $next_ann->format('Y') + $yrsplus;
                 $moplus = $periods - 1 - $yrsplus * 12;
                 if ($moplus + $next_ann->format('m') < 12) {
                     $mo = $moplus + $next_ann->format('m');
                 } else {
                     $yr++;
                     $mo = $moplus + $next_ann->format('m') - 12;
                 }
                 if ($ann_day >= date('d', strtotime('last day of ' . $yr . '-' . $mo))) {
                     $d = date('d', strtotime('last day of ' . $yr . '-' . $mo));
                 } else {
                     $d = $ann_day;
                 }
                 $extendto = $next_ann->setDate($yr, $mo, $d);
             } else {
                 $extendto = $next_ann;
             }
         }
         //calculate interval of membership term
         $interval = $startlocal->diff($extendto);
         //set prorate interval
         $prorateInterval = in_array($info['prorateInterval'], ['year', 'month', 'day']) ? $info['prorateInterval'] : 'day';
         //prorate
         if ($prorateInterval == 'year' && strlen($info['anniversary']) == 4) {
             $ratio = $interval->y;
             $ratio += $interval->m > 0 || $interval->d > 0 ? 1 : 0;
         } elseif ($prorateInterval == 'month' || $prorateInterval == 'year' && strlen($info['anniversary']) == 2) {
//.........这里部分代码省略.........

 /**
  * Adds a log record.
  *
  * @param  int     $level   The logging level
  * @param  string  $message The log message
  * @param  array   $context The log context
  * @return Boolean Whether the record has been processed
  */
 public function addRecord(int $level, string $message, array $context = []) : bool
 {
     $levelName = static::getLevelName($level);
     // check if any handler will handle this message so we can return early and save cycles
     $handlerKey = null;
     reset($this->handlers);
     while ($handler = current($this->handlers)) {
         if ($handler->isHandling(['level' => $level])) {
             $handlerKey = key($this->handlers);
             break;
         }
         next($this->handlers);
     }
     if (null === $handlerKey) {
         return false;
     }
     $dateTime = new DateTimeImmutable($this->microsecondTimestamps, $this->timezone);
     $dateTime->setTimezone($this->timezone);
     $record = ['message' => $message, 'context' => $context, 'level' => $level, 'level_name' => $levelName, 'channel' => $this->name, 'datetime' => $dateTime, 'extra' => []];
     foreach ($this->processors as $processor) {
         $record = call_user_func($processor, $record);
     }
     while ($handler = current($this->handlers)) {
         if (true === $handler->handle($record)) {
             break;
         }
         next($this->handlers);
     }
     return true;
 }

 public function convertFromDatabase($value)
 {
     $datetime = new \DateTimeImmutable($value, new \DateTimeZone('UTC'));
     return $datetime->setTimezone(new \DateTimeZone(date_default_timezone_get()));
 }