Time-driven applications

Time-driven
applications
Piotr Horzycki
Team leader @ gwo.pl
phpCE 2017, Rawa Mazowiecka, Poland

What's time got to do with
web applications?
●
News, movies & other content
●
Voting systems
●
Subscriptions with time constraints
(like "Call For Papers":
https://github.com/opencfp/opencfp)
●
Discount systems
●
Reports, statistics

A very bad example...
class SuperMegaFancyPromotionController
{
public function showAction()
{
if (time() > 1496268000) {
$this->showForm();
} elseif (time() < 1490997600 && time() > 1488322800) {
$this->showWarning();
} else {
/* ... */
}
}
}
This code:
- is hard to read
- cannot be easily tested (see uopz extension)
- is not reusable
- must be modified even if somebody wants to change the dates (hardcoding)

Date & time operations in PHP
●
date(), time(), strtotime(), strftime()...
●
DateTime
●
DateInterval
●
DatePeriod
●
DateTimeZone

UNIX timestamps
●
A signed integer; a number of seconds since the "epoch"
– 1970-01-01 Coordinated Universal Time (UTC)
●
On 32-bit systems, the maximum supported year was 2038
●
On 64-bit systems, PHP 7 works beyond the year 2038:
$ php -r "echo strtotime('1939-09-01');"
-957315600
$ php -r "echo strtotime('2049-09-01');"
2514063600

Why use functions if we have
classes?
function getNextMonthAsRSSDate(DateTimeImmutable $date): string
{
$nextMonth = $date->add(new DateInterval('P1M'));
return $nextMonth->format(DateTime::RSS);
}
function getNextMonthAsRSSDate(int $date): string
{
$nextMonth = mktime(
date('H', $date), date('i', $date),
date('s', $date), date('n', $date) + 1
);
return date('D, d M Y H:i:s O', $nextMonth);
}

DateTimeImmutable vs DateTime
PHP Manual on DateTimeImmutable:
„This class behaves the same as DateTime except it never modifies itself but
returns a new object instead.”
Thus, DateTimeImmutable is a value object, known from DDD.
$now = new DateTime();
$nextMonth = $now->add(new DateInterval('P1M'));
/* $now and $nextMonth are pointers to the same object;
* we need two separate value objects! */
debug_zval_dump($now);
debug_zval_dump($nextMonth);

Timezones are tricky
●
Your server has its local time, your users have their
own local time
●
Daylight Saving Time works differently in different
countries
●
Timezones are not always shifted by whole hours
(like +8:45 in Australia)
●
Solution: store all dates in Coordinated Universal
Time – and convert back to local time in the
presentation layer

Intervals
$june = new DateTimeImmutable('2017-06-01Z');
$november = new DateTimeImmutable('2017-11-01Z');
echo $november
->diff($june) // returns DateInterval
->format('%r%m') . ' months' . PHP_EOL;
// Output: -5 months

Creating intervals in ISO 8601 syntax
$interval = new DateInterval('P1Y2M3DT4H5M6S');
$interval = new DateInterval('P0001-02-03T04:05:06');
=
1 year, 2 months, 3 days,
4 hours, 5 minutes and 6 seconds

Periods
function printSchoolYearMondays()
{
$start = new DateTimeImmutable('2017-09-01Z');
$end = new DateTimeImmutable('2018-06-30T23:59:59Z');
$interval = DateInterval::createFromDateString('next monday');
$period = new DatePeriod(
$start,
$interval,
$end,
DatePeriod::EXCLUDE_START_DATE
);
foreach ($period as $date) {
// $date is immutable if $start is too
echo $date->format('l, Y-m-d') . PHP_EOL;
}
}

Date ranges in MySQL
SELECT *
FROM news
WHERE
YEAR(published_at) = 2017 AND MONTH(published_at) = 11;
SELECT *
FROM news
WHERE
published_at BETWEEN '2017-11-01' AND '2017-11-30 23:59:59';
SELECT *
FROM news
WHERE
published_at LIKE '2017-11-%';

class MonthPeriod
{
public function getStart()
{
return new
DateTimeImmutable('first day of this month midnight');
}
public function getEnd()
{
return new
DateTimeImmutable('first day of next month midnight -1 second');
}
}
define('SQL_DATETIME', 'Y-m-d H:i:s');
$period = new MonthPeriod();
echo $period->getStart()->format(SQL_DATETIME) . PHP_EOL;
echo $period->getEnd()->format(SQL_DATETIME) . PHP_EOL;
// Output:
// 2017-11-01 00:00:00
// 2017-11-30 23:59:59
These two values are ready to be bound into a BETWEEN … AND … statement.

Remember about tests!
class MonthPeriod
{
private $now;
public function __construct(DateTimeImmutable $now)
{
$this->now = $now;
}
public function getStart()
{
return $this->now->modify('first day of this month midnight');
}
public function getEnd()
{
return $this->now->modify('first day of next month midnight -1 second');
}
}

class MonthPeriodTest extends PHPUnitFrameworkTestCase
{
/** @dataProvider getDateRanges */
public function testMonth(
string $today,
string $expectedStartDay,
string $expectedEndDay
) {
$now = new DateTimeImmutable($today);
$period = new MonthPeriod($now);
$expectedStart = new DateTimeImmutable($expectedStartDay);
$expectedEnd = new DateTimeImmutable($expectedEndDay);
$this->assertEquals($expectedStart, $period->getStart());
$this->assertEquals($expectedEnd, $period->getEnd());
}
public function getDateRanges()
{
return [
'November' => [
'2017-11-11Z', '2017-11-01 00:00:00Z', '2017-11-30 23:59:59Z'
],
'Leap year' => [
'2016-02-11Z', '2016-02-01 00:00:00Z', '2016-02-29 23:59:59Z'
],
];
}
}

Date and time arithmetic pitfalls
$lastDayOfJanuary = new DateTimeImmutable('2016-01-31Z');
echo $lastDayOfJanuary
->modify('+1 month')
->format('Y-m-d') . PHP_EOL;
echo $lastDayOfJanuary
->modify('last day of next month')
->format('Y-m-d') . PHP_EOL;
// Output:
// 2016-03-02
// 2016-02-29
More: http://php.net/manual/en/datetime.examples-arithmetic.php
More: Michał Pipa, Data i czas dla programistów (https://youtu.be/ZRoEVJlxPlo)

A bad example, once again...
class SuperMegaFancyPromotionController()
{
public function showAction()
{
if (time() > 1496268000) {
$this->showForm();
} elseif (time() < 1490997600 && time() > 1488322800) {
$this->showWarning();
} else {
/* ... */
}
}
}

Let's rewrite that legacy code...
class PromotionTimelineTest extends PHPUnitFrameworkTestCase
{
public function testIsActive()
{
$now = new DateTimeImmutable('2017-05-01T00:00:00Z');
$opening = $now;
$closing = $opening->add(new DateInterval('P2M'));
$timeline = new PromotionTimeline($now, $opening, $closing);
$this->assertTrue($timeline->isActive());
}
}
...starting from a test

Testing the exceptions
class PromotionTimelineTest extends PHPUnitFrameworkTestCase
{
/* ... */
/**
* @expectedException InvalidArgumentException
*/
public function testInvalidArguments()
{
$now = new DateTimeImmutable('2017-05-01T00:00:00Z');
$opening = $now;
$closing = $opening->sub(new DateInterval('PT1S'));
new PromotionTimeline($now, $opening, $closing);
}
}

class PromotionTimeline
{
private $now;
private $openingDate;
private $closingDate;
public function __construct(
DateTimeImmutable $now,
DateTimeImmutable $openingDate,
DateTimeImmutable $closingDate
) {
if ($openingDate >= $closingDate) {
throw new InvalidArgumentException('The opening date must be
earlier than the closing date');
}
$this->now = $now;
$this->openingDate = $openingDate;
$this->closingDate = $closingDate;
}
public function isActive()
{
return
($this->now >= $this->openingDate) &&
($this->now < $this->closingDate);
}
}

What might come next?
●
Early-bird tickets
●
Reminders
●
Last-minute tickets
●
Individual coupons valid until ...
●
Black Friday
●
...
Expect the unexpected!

Remember the Strategy pattern!
●
Let's say we develop a hotel booking platform
●
Ordinary users have to check out at a fixed
hour specified by the hotel
●
But the premium users have extra time!

Old-fashioned way...
$hotel = Hotel::find(['name' => 'Ossa']);
$user = User::find(['login' => 'test']);
if ($user->isPremium()) {
$checkout = $hotel->getCheckoutTime()->add(new DateInterval('P2H'));
} else {
$checkout = $hotel->getCheckoutTime();
}
echo 'Checkout at ' . $checkout->format('H:i');

interface CheckoutStrategyInterface
{
public function getCheckoutTime();
}
class User
{
private $checkoutStrategy;
public function __construct(CheckoutStrategyInterface $checkoutStrategy)
{
$this->checkoutStrategy = $checkoutStrategy;
}
public function getCheckoutTime()
{
return $this->checkoutStrategy->getCheckoutTime();
}
}
Doing it the flexible way

class StandardCheckoutStrategy implements CheckoutStrategyInterface
{
private $checkout;
public function __construct(DateTimeImmutable $checkout)
{
$this->checkout = $checkout;
}
{
return $this->checkout;
}
}

class ExtendedCheckoutStrategy extends StandardCheckoutStrategy
{
private $extension;
public function __construct(
DateTimeImmutable $checkout,
DateInterval $extension
) {
parent::__construct($checkout);
$this->extension = $extension;
}
{
return $this->checkout->add($this->extension);
}
}

Why do we create so many
classes?
●
A class should be modified only for a single
reason
●
Single-responsibility principle
●
Flexibility: loose coupling, high cohesion
●
You never know what business
brings next
●
But don't over-engineer!

Distributed systems
●
Servers in multiple timezones? Oops...
●
Date synchronization via Network Time Protocol
●
Time events
●
A lot of fun :)

Thank you!
piotr.horzycki@gmail.com
twitter.com/phorzycki
github.com/phorzycki/datetime_examples

Time-driven applications

More Related Content

What's hot (20)

Similar to Time-driven applications (20)

More from Piotr Horzycki (9)

Recently uploaded (20)

Time-driven applications