Check if business is open using current time and an array with days as keys and hyphen-separated time ranges as values

Question

I'm trying to calculate if the current time is within the opening hours of a restaurant.

This question has been asked a lot on Stackoverflow, but I haven't found one that can account for the problems I am having. Also, would be nice to see idea on a better way to do this.

Currently it breaks if the day is closed (Sunday in this example) or if it's 1am on "Saturday" (so technically 1am Sunday morning). I have a feeling I'll have to change the way the data is stored to account for after midnight, but I'm trying to work with what I have for now. It's a problem, because most restaurants list their opening times for a given day as 5pm - 2am, not 5pm - 12am, 12am - 2am.

Anyway, here is what I have. Please tell me a better way to do it.

I have times stored like this:

$times = array(
    'opening_hours_mon' => '9am - 8pm',
    'opening_hours_tue' => '9am - 2am',
    'opening_hours_wed' => '8:30am - 2am',
    'opening_hours_thu' => '5:30pm - 2am',
    'opening_hours_fri' => '8:30am - 11am',
    'opening_hours_sat' => '9am - 3pm, 5pm - 2am',
    'opening_hours_sun' => 'closed'
);

This is the code I'm using now:

// Get the right key for today
$status = 'open';
$now = (int) current_time( 'timestamp' );
$day = strtolower( date('D', $now) );
$string = 'opening_hours_'.$day;

$times = $meta[$string][0]; // This should be a stirng like '6:00am - 2:00am' or even '6:00am - 11:00am, 1:00pm to 11:00pm'.

// Does it contain a '-', if not assume it's closed.
$pos = strpos($times, '-');
if ($pos === false) {       
    $status = 'closed';
} else {

    // Maybe a day has multiple opening times?
    $seating_times = explode(',', $times);
    foreach( $seating_times as $time ) {

        $chunks = explode('-', $time);
        $open_time = strtotime($chunks[0]);
        $close_time = strtotime($chunks[1]);

        // Calculate if now is between range of open and closed
        if(($open_time <= $now) && ($now <= $close_time)) {
            $status = 'open';
            break;
        } else {
            $status = 'closed';             
        }

    }

}

NOTE: current_time('timestamp',0) is a WordPress function.

Answer 1

Here is my object-oriented solution, based on the usage of the PHP DateTime class (available since the 5.2 version):

<?php 

class Restaurant {
    private $cw;
    private $times = array();
    private $openings = array();

    public function __construct(array $times) {
        $this->times = $times;
        $this->setTimes(date("w") ? "this" : "last");
        //print_r($this->openings);       // Debug
    }

    public function setTimes($cw) {
        $this->cw = $cw;
        foreach ($this->times as $key => $val) {
            $t = array();
            $buf = strtok($val, ' -,');
            for ($n = 0; $buf !== FALSE; $n++) {
                try {
                    $d = new DateTime($buf);
                    $d->setTimestamp(strtotime(substr($key, -3)." {$this->cw} week {$buf}"));
                    if ($n && ($d < $t[$n-1])) {
                        $d->add(new DateInterval('P1D'));
                    }
                    $t[] = $d;
                } catch (Exception $e) {
                    break;
                }
                $buf = strtok(' -,');
            }
            if ($n % 2) {
                throw new Exception("Invalid opening time: {$val}");
            } else {
                $this->openings[substr($key, -3)] = $t;
            }
        }
    }

    public function isOpen() {
        $cw = date("w") ? "this" : "last";
        if ($cw != $this->cw) {
            $this->setTimes($cw);
        }
        $d = new DateTime('now');
        foreach ($this->openings as $wd => $t) {
            $n = count($t);
            for ($i = 0; $i < $n; $i += 2) {
                if (($d >= $t[$i]) && ($d <= $t[$i+1])) {
                    return(TRUE);
                }
            }
        }
        return(FALSE);
    }
}

$times = array(
    'opening_hours_mon' => '9am - 8pm',
    'opening_hours_tue' => '9am - 2am',
    'opening_hours_wed' => '8:30am - 2am',
    'opening_hours_thu' => '9am - 3pm',
    'opening_hours_fri' => '8:30am - 11am',
    'opening_hours_sat' => '9am - 3pm, 5pm - 2am',
    'opening_hours_sun' => 'closed'
);

try {
    $r = new Restaurant($times);
    $status = $r->isOpen() ? 'open' : 'closed';
    echo "status=".$status.PHP_EOL;
} catch (Exception $e) {
    echo $e->getMessage().PHP_EOL;
}

?>

As you can see, the constructor builds an internal form (the openings array of DateTime objects), which is then used with a simple comparison in the isOpen method to check if at the time of the call the restaurant is opened or closed.

You'll also notice that I've used the DateTime:add method to calculate tomorrow's date, instead of adding 86400 (24*60*60) to the current date timestamp, to avoid problems with DST time shifts.
Proof of concept:

<?php

ini_set("date.timezone", "Europe/Rome");
echo "date.timezone = ".ini_get("date.timezone").PHP_EOL;

$d1 = strtotime("2013-10-27 00:00:00");
$d2 = strtotime("2013-10-28 00:00:00");
// Expected: 86400, Result: 90000
echo "Test #1: ".($d2 - $d1).PHP_EOL;
// Expected: 2013-10-28 00:00:00, Result: 2013-10-27 23:00:00
echo "Test #2: ".date("Y-m-d H:i:s", $d1 + 86400).PHP_EOL;

$d1 = strtotime("2014-03-30 00:00:00");
$d2 = strtotime("2014-03-31 00:00:00");
// Expected: 86400, Result: 82800
echo "Test #3: ".($d2 - $d1).PHP_EOL;
// Expected: 2014-03-30 00:00:00, Result: 2014-03-29 23:00:00
echo "Test #4: ".date("Y-m-d H:i:s", $d2 - 86400).PHP_EOL;

?>

Which gives the following results:

date.timezone = Europe/Rome
Test #1: 90000
Test #2: 2013-10-27 23:00:00
Test #3: 82800
Test #4: 2014-03-29 23:00:00

Therefore, it seems that one day not always has 86400 seconds; at least not twice a year...

Answer 2

Suppose that, instead of such an array, we had another with the following kind of entries:

Array ( [from] => 1382335200 [to] => 1382374800 )

The from and to values are timestamps, calculated by projecting your array's information to the current (running) week.

Then, in order to check if the restaurant was open right now, we would have to do something as simple as:

$slots=..... /* calculate time slots array */
$status='closed';
$rightnow=time();
foreach($slots as $slot)
  if($rightnow<=$slot['to'])
    {
    if($rightnow>=$slot['from']) $status='open';
    break;
    }
echo "The restaurant is <strong>$status</strong> right now<br>";

Given a weekday, in the form of mon, tue, wed etc and two strings that define a time range, for example 8:30am and 3:15pm, the following function will return the corresponding time slot, as described above:

function get_time_slot($weekday,$fromtime,$totime)
  {
  $from_ts=strtotime("this week $weekday $fromtime");
  $to_ts=strtotime("this week $weekday $totime");
  if($to_ts<$from_ts)
    {
    $to_ts=strtotime("this week $weekday +1 day $totime");
    if($to_ts>strtotime("next week midnight")) 
      $to_ts=strtotime("this week mon $totime");
    }
  return array('from'=>$from_ts,'to'=>$to_ts);
  }

strtotime() can work miracles, huh? Notice that, if the end of the timeslot turns out to be earlier than the start, we assume that it refers to the next day, and we re-calculate it as such.

EDIT: At first, I naively thought I'd correct it by adding a day's worth of seconds. That wasn't exactly accurate, since manipulating a timestamp doesn't preserve DST information. So if a timeslot included a day shift (midnight) and also a DST shift, it would give inaccurate results by an hour. Using strtotime() all over again, with the same argument plus a day, would set it straight.

yaEDIT: Another bug (hopefully the last one) fixed: When a restaurant is open on Sundays until after midnight, $to_time should wrap to this week's monday, same time. Phew!

Now, in order to transform your array, you would need to do:

$slots=array();
foreach($times as $key=>$entry)
  {
  list(,,$dow)=explode('_',$key);
  foreach(explode(',',$entry) as $d)
    {
    $arr=explode('-',$d);
    if(count($arr)==2) $slots[]=get_time_slot($dow,$arr[0],$arr[1]);
    }
  }

Here's a little phpfiddle to demonstrate this.

---

EDIT: Motivated by the "conciseness" discussion in another answer, I thought I'd give my "compact" version. Using the exact same logic, it boils down to the following:

$status='closed';
$rightnow=time();
foreach($times as $key=>$entry)
  {
  list(,,$dow)=explode('_',$key);
  foreach(explode(',',$entry) as $d)
    if(count($arr=explode('-',$d))==2)
      {
      $from_ts=strtotime("this week $dow {$arr[0]}");
      $to_ts=strtotime("this week $dow {$arr[1]}");
      if($to_ts<$from_ts) $to_ts=strtotime("this week $dow +1 day {$arr[1]}");
        {
        $to_ts=strtotime("this week $dow +1 day {$arr[1]}");
        if($to_ts>strtotime("next week midnight")) 
          $to_ts=strtotime("this week mon {$arr[1]}");
        }
      if($rightnow<=$to_ts)
        {
        if($rightnow>=$from_ts) $status='open';
        break 2; // break both loops
        }
      }
  }
echo "<hr>The restaurant is <strong>$status</strong> right now<br>";

However, I myself still prefer the original version. Besides the obvious benefits of having a function, the $slots array could very well be cached and re-used, making relevant calculations much easier than parsing the original data all over again.

Answer 3

Weeks timings array

$times = array(
    'opening_hours_mon' => '9am - 8pm',
    'opening_hours_tue' => '9am - 2am',
    'opening_hours_wed' => '8:30am - 2am',
    'opening_hours_thu' => '9am - 3pm',
    'opening_hours_fri' => '8:30am - 11am',
    'opening_hours_sat' => '9am - 3pm, 5pm - 2am',
    'opening_hours_sun' => 'closed'
);

Usage Example :

ini_set( "date.timezone", "Pacific/Auckland" ); // Make sure correct timezone is set

echo ( isOpen( $times ) ? 'Open' : 'Closed' );    

echo ( isOpen( $times ,"10am" ) ? 'Open' : 'Closed' );

Function definition :

/*
 *  First parameter : Weeks timings as array
 *  Second parameter : Time to check as string
 *  Return value : boolean
 */
function isOpen( $times ,$timeToCheck = 'now' )
{
    $timeToCheckAsUnixTimestamp = strtotime( $timeToCheck );

    $yesterdayTimes = $todayTimes = '';
    //  Find yesterday's times and today's times
    foreach( $times as $day => $timeRange )
    {
        $yesterdayTimes = ( stripos( $day ,date( "D" ,time() - 60 * 60 * 24 ) ) !== false ? $timeRange : $yesterdayTimes );
        $todayTimes = ( stripos( $day ,date( "D" ) ) !== false ? $timeRange : $todayTimes );
    }
    //  Handle closed
    if( strcasecmp( $todayTimes ,'closed' ) == 0 ) return false;
    if( strcasecmp( $yesterdayTimes ,'closed' ) == 0 ) $yesterdayTimes = '12am - 12am';
    //  Process and check with yesterday's timings
    foreach( explode( ',' ,$yesterdayTimes ) as $timeRanges )
    {
        list( $from ,$to ) = explode( '-' ,$timeRanges );
        list( $fromAsUnixTimestamp ,$toAsUnixTimestamp ) = array( strtotime( $from .' previous day' ) ,strtotime( $to .' previous day'  ) );
        $toAsUnixTimestamp = ( $toAsUnixTimestamp < $fromAsUnixTimestamp ? strtotime( $to ) : $toAsUnixTimestamp );
        if( $fromAsUnixTimestamp <= $timeToCheckAsUnixTimestamp and $timeToCheckAsUnixTimestamp <= $toAsUnixTimestamp ) return true;
    }
    //  Process and check with today's timings
    foreach( explode( ',' ,$todayTimes ) as $timeRanges )
    {
        list( $from ,$to ) = explode( '-' ,$timeRanges );
        list( $fromAsUnixTimestamp ,$toAsUnixTimestamp ) = array( strtotime( $from ) ,strtotime( $to ) );
        $toAsUnixTimestamp = ( $toAsUnixTimestamp < $fromAsUnixTimestamp ? strtotime( $to .' next day' ) : $toAsUnixTimestamp );
        if( $fromAsUnixTimestamp <= $timeToCheckAsUnixTimestamp and $timeToCheckAsUnixTimestamp <= $toAsUnixTimestamp ) return true;
    }
    return false;
}

Answer 4

This is probably not the most efficient, but it should work well for your the problem at hand:

$times = array(
    'opening_hours_mon' => '9am - 8pm',
    'opening_hours_tue' => '9am - 2am',
    'opening_hours_wed' => '8:30am - 2am',
    'opening_hours_thu' => '9am - 3pm',
    'opening_hours_fri' => '8:30am - 11am',
    'opening_hours_sat' => '9am - 3pm, 5pm - 2am',
    'opening_hours_sun' => 'closed'
);

var_dump(is_open($times, strtotime('sun 1am'))); // true

Here's the first function, simple in design; it uses a grid of opening and closing times and determines whether the given time matches any of the ranges:

function is_open($times, $now)
{
    $today = strtotime('today', $now);

    $grid = get_time_grid($times);
    $today_name = strtolower(date('D', $today));
    $today_seconds = $now - $today;

    foreach ($grid[$today_name] as $range) {
        if ($today_seconds >= $range[0] && $today_seconds < $range[1]) {
            return true;
        }
    }

    return false;
}

This function builds the actual grid; if a range ending comes before its corresponding start it will create two ranges, one for each day that's being spanned.

function get_time_grid($times)
{
    static $next_day = array(
        'mon' => 'tue', 'tue' => 'wed', 'wed' => 'thu',
        'thu' => 'fri', 'fri' => 'sat', 'sat' => 'sun',
        'sun' => 'mon'
    );
    static $time_r = '(\d{1,2}(?::\d{2})?(?:am|pm))';

    $today = strtotime('today');
    $grid = [];

    foreach ($times as $key => $schedule) {
        $day_name = substr($key, -3);
        // match all time ranges, skips "closed"
        preg_match_all("/$time_r - $time_r/", $schedule, $slots, PREG_SET_ORDER);
        foreach ($slots as $slot) {
            $from = strtotime($slot[1], $today) - $today;
            $to = strtotime($slot[2], $today) - $today;

            if ($to < $from) { // spans two days
                $grid[$day_name][] = [$from, 86400];
                $grid[$next_day[$day_name]][] = [0, $to];
            } else { // normal range
                $grid[$day_name][] = [$from, $to];
            }
        }
    }

    return $grid;
}

There are only a few comments in the code, but I hope you can follow what's being done. Let me know if you need any clarification.

Answer 5

I have done something similar in the past but took a totally different approach. I stored my opening hours in a separate table.

CREATE TABLE `Openinghours`
(
    `OpeninghoursID` int, // serial
    `RestaurantID` int, // foreign key
    `Dayofweek` int, // day of week : 0 (for Sunday) through 6 (for Saturday)
    `Opentime` int, // time of day when restaurant opens (in seconds)
    `Closetime` int // time of day when restaurant closes (in seconds)
);

If a restaurant has more than one opening period per day you can just add 2 records (or more id needed). The nice thing of using such a table is that you can simply query to see which restaurants are open.

$day = date('w');
$now = time()-strtotime("00:00");
$query = "Select `RestaurantID` from `Openinghours` where `Dayofweek` = ".$day." and `Opentime` <= ".$now." and `Closetime` > ".$now;

Another beauty of using such a system is that you can adapt you query to get different results like for example : what restaurants are open now and stay open for at least another hour (no point going to a restaurant a few minutes before closing)

$day = date('w');
$now = time()-strtotime("00:00");
$query = "Select `RestaurantID` from `Openinghours` where `Dayofweek` = ".$day." and `Opentime` <= ".$now." and `Closetime` > ".($now+3600);

Of course it needs reformatting your current data but it brings nice features.

Answer 6

Here is another solution without needing to reformat your data.

$times = array(
    'opening_hours_mon' => '9am - 8pm',
    'opening_hours_tue' => '9am - 2am',
    'opening_hours_wed' => '8:30am - 2am',
    'opening_hours_thu' => '5:30pm - 2am',
    'opening_hours_fri' => '8:30am - 11am',
    'opening_hours_sat' => '9am - 3pm, 5pm - 2am',
    'opening_hours_sun' => 'closed'
);

function compileHours($times, $timestamp) {
    $times = $times['opening_hours_'.strtolower(date('D',$timestamp))];
    if(!strpos($times, '-')) return array();
    $hours = explode(",", $times);
    $hours = array_map('explode', array_pad(array(),count($hours),'-'), $hours);
    $hours = array_map('array_map', array_pad(array(),count($hours),'strtotime'), $hours, array_pad(array(),count($hours),array_pad(array(),2,$timestamp)));
    end($hours);
    if ($hours[key($hours)][0] > $hours[key($hours)][1]) $hours[key($hours)][1] = strtotime('+1 day', $hours[key($hours)][1]);
    return $hours;
}

function isOpen($now, $times) {
    $open = 0; // time until closing in seconds or 0 if closed
    // merge opening hours of today and the day before
    $hours = array_merge(compileHours($times, strtotime('yesterday',$now)),compileHours($times, $now)); 

    foreach ($hours as $h) {
        if ($now >= $h[0] and $now < $h[1]) {
            $open = $h[1] - $now;
            return $open;
        } 
    }
    return $open;
}

$now = strtotime('7:59pm');
$open = isOpen($now, $times);

if ($open == 0) {
    echo "Is closed";
} else {
    echo "Is open. Will close in ".ceil($open/60)." minutes";
}

?>

I ran several test and it seems to work as expected taking all aspects that I could think off. let me know if you find a problem with this one. I know the approach looks a little nasty but I wanted to use simple functions only (well except for the tricky part with array_map) and keep it as short as possible.

Answer 7

If you use a database for this why you didn't use datetime for this.

Sample:

sunday 14:28, saturday 1:28

You can split this two part and compare them, in string time (part 2). You can use strtotime to convert string time to timestamp and compare it.

Sample:

$date = "sunday 14:28"; 
echo $stamp = strtotime($date);

Output:

1360492200

Like this code:

$Time="sunday  14:28 , saturday 1:28";
$tA=explode(",",$Time);
$start=strtotime($tA[0]);
$end=strtotime($tA[1]);
$now=time();
if($now>$start and $now<$end){
   echo "is open";
}else{
   echo "is close";
}

But you have a problem with update them you can do this.

Answer 8

Here is my solution:

INPUT DATA:

$meta = array(
   'opening_hours_mon' => '9am - 8pm',
   'opening_hours_tue' => '9am - 2am',
   'opening_hours_wed' => '8:30am - 2am',
   'opening_hours_thu' => '9am - 3pm',
   'opening_hours_fri' => '8:30am - 11am',
   'opening_hours_sat' => '9am - 3pm, 5pm - 2am',
   'opening_hours_sun' => 'closed'

);

current_time( 'timestamp' ) (as said author) analog of time() in WordPress
And solution:

    $now = (int) current_time( 'timestamp' );
    $day = strtolower(date('D', $now));
    $yesterday = strtolower(date('D', strtotime('-1 day')));
    $days = array(
        'yesterday' => $meta['opening_hours_'.$yesterday],
        'today' => $meta['opening_hours_'.$day],
    );
    $status = false;
    foreach($days as $when=>$times)
    {
        $parts = explode(',',$times);
        foreach($parts as $p)
        {
            if($p == 'closed')
                break;
            else{
                list($b,$e) = explode('-',$p);
                $b = strtotime("$when $b");
                $e = strtotime("$when $e");
                if($b > $e)
                    $e += strtotime("$when $e +1 day");;
                if($b <= $now && $now <= $e)
                {
                    $status =true;
                    break;
                }
            }
        }
    }

FOR TESTING:
you may change first 3 lines to followings:

$now = (int) strtotime('today 3:00am');
$day = strtolower(date('D', $now));
$yesterday = strtolower(date('D', strtotime('yesterday 3:00am')));

Answer 9

Solution without change of time stored format

<?php
    $times = array(
        'opening_hours_mon' => '9am - 8pm',
        'opening_hours_tue' => '5pm - 2am',
        'opening_hours_wed' => '8:30am - 2am',
        'opening_hours_thu' => '9am - 3pm',
        'opening_hours_fri' => '8:30am - 11am',
        'opening_hours_sat' => '9am - 3pm, 5pm - 2am',
        'opening_hours_sun' => 'closed'
    );

    //$time_go = '13:00';
    $time_go = date('H:i');

    //$day_go = 1; //monday
    $day_go = (date('N') - 1);

    if(Are_they_open($time_go, $day_go, $times)){
        echo 'jep';
    }
    else{
        echo 'nope';
    }

    function Are_they_open($time_go, $day_go, $times){
        // the magic
        $times = array_values($times);
        $day_go = explode(',', $times[$day_go]);
        $time_go = hh_mm_toSeconds($time_go);

        foreach($day_go as $time){

            if((!$time) || ($time == 'closed')){
                return false;
            }

            $time = explode(' - ', $time);
            $time_open = hh_mm_toSeconds(date('H:i', strtotime($time[0])));
            $time_close = hh_mm_toSeconds(date('H:i', strtotime($time[1])));

            if(($time_go > $time_open) && ($time_go < $time_close)){
                return true;
            }
            elseif (($time_open > $time_close) || ($time_go > $time_open)){
                return true;
            }

        }

        return false;
    }

    function hh_mm_toSeconds($str_time){
        sscanf($str_time, "%d:%d", $hours, $minutes);
        return ($hours * 3600) + ($minutes * 60);
    }
?>

Solution where you change Time format

$times = array(
    1 => array(
        array('07:00', '17:00')
    ),
    2 => array(
        array('07:00', '14:30'),
        array('15:00', '20:00')
    ),
    3 => array(
        array('07:00', '17:00')
    ),
    4 => false, //closed
    5 => array(
        array('07:00', '17:00'),
        array('20:00', '24:00')
    ),
    6 => array(
        array('00:00', '03:00'),
        array('07:00', '17:00'),
        array('20:00', '24:00')
    ),
    7 => array(
        array('00:00', '03:00')
    ),
);

Answer 10

Pass Your array as argument to this function and You will get true for open and false for closed at current time. It is simple straightforward function. I just check today opening times and if necessary yesterday without unnecessary looping through all week days. Maybe it could be improved a bit, but it works and is not complicated.

function isOpen($times) {
    $times = array_values($times); //we will use numeric indexes
    $now = new DateTime();
    $day = $now->format('N'); 
    $day--; //days are counted 1 to 7 so we decrement it to match indexes
    $period = $times[$day];
    if($period!='closed') {
        $opening = explode('-', $period);
        $open = new DateTime($opening[0]);
        $close = new DateTime($opening[1]);
        if($close<$open) {
            //it means today we close after midnight, it is tomorrow
            $close->add(new DateInterval('P1D'));
        }
        if($open<$now && $now<$close) {
            //we are open
            return true;
        }
    }
    if($period=='closed' || $now<$open) {
        //now we check if we still open since yesterday
        $day = $day==0 ? 6 : $day-1;
        $period = $times[$day];
        if($period=='closed') return false;
        $opening = explode(' - ', $period);
        $open = new DateTime($opening[0]);
        $close = new DateTime($opening[1]);
        if($close<$open) {
        //it means yesterday we closed after midnight
            if($now<$close) {
                //we are before closing time
                return true;
            }
        }
    }
    return false;
}

Answer 11

Maybe I'm not understanding this completely, but going through a basic loop, maybe this could work:

if( ($date('D') == "3" ) )
{
    $open = "8";
    $close = "17";
    $now = time();

    if( ($now > $open) and ($now < $close) )
    {
        echo "open";
    }
    else
    {
        echo "closed";
    }
}

Perhaps not the best way to go around it since this would not include holidays and such, and requires a few conditional statements, but I think this could work. Well, not optimal, but always worked for me.