}
 
    public static function SetObject($key, $var, $expire = 86400) {
        return static::Set($key, serialize($var), $expire);
    }
 
    public static function SetArray($key, $var, $expire = 86400) {
        return static::Set($key, serialize($var), $expire);
    }
 
    public static function SetBoolean($key, $var, $expire = 86400) {
        return static::Set($key, serialize($var), $expire);
    }
 
    public static function Set($key, $var, $expire = 86400) {
        App::debugbarLog('debug', "Cache set: $key");
        if ($i = static::getInstance()) {
            $var = static::beforeSet($var);
            return $expire > 0?
                $i->setEx($key, $expire, $var) :
                $i->set($key, $var);
        }
        return null;
    }
 
    public static function Exists(...$key):?bool {
        if ($i = static::getInstance()) {
            return $i->exists($key);
        }
        return null;
    }
 
    public static function Expire($key, $ttl) {
        if ($i = static::getInstance()) {
            return $i->expire($key, $ttl);
        }
        return false;
    }
 
    /**

    public static function getInstance() {
        if (static::$redisObj === null) {
            static::$redisObj = new Redis();
            try {
                if (!@static::$redisObj->connect(static::$host, (int)static::$port)) {
                    static::$redisObj = false;
                    Splunk::log(Splunk::LOG_REDIS_CONN, ['error' => 'Error connecting']);
                } else {
                    static::$redisObj->select(static::$db);
                }
            } catch (RedisException $e) {
                static::$redisObj = false;
                Splunk::log(Splunk::LOG_REDIS_CONN, ['error' => 'Error connecting: '.$e->getMessage()]);
            }
        }
        return static::$redisObj;
    }
 
    public static function SetObject($key, $var, $expire = 86400) {
        return static::Set($key, serialize($var), $expire);
    }
 
    public static function SetArray($key, $var, $expire = 86400) {
        return static::Set($key, serialize($var), $expire);
    }
 
    public static function SetBoolean($key, $var, $expire = 86400) {
        return static::Set($key, serialize($var), $expire);
    }
 
    public static function Set($key, $var, $expire = 86400) {
        App::debugbarLog('debug', "Cache set: $key");
        if ($i = static::getInstance()) {
            $var = static::beforeSet($var);
            return $expire > 0?
                $i->setEx($key, $expire, $var) :
                $i->set($key, $var);
        }
        return null;
    }

                }
            }
        } else {
            $sql = "SELECT id FROM ".HolidayHours::getTableName()." WHERE for_date = ? AND " .
                ($cid ? "category_id" : "restaurant_id") . " = ? AND order_type = ? $where ORDER BY id DESC";
            $db_conn->bindParameter($sql, 1, $date, "string");
            $db_conn->bindParameter($sql, 1, $rid, "integer");
            $db_conn->bindParameter($sql, 1, $type, "string");
            $result = $db_conn->query($sql);
            if ($result && $result->rowCount() > 0) {
                if ($row = $result->fetch()) {
                    $hh = new HolidayHours($row['id']);
                    Cache::SetObject($cacheKey, $hh);
                    return $hh;
                }
            }
        }
        
        if ($cacheKey) {
            Cache::SetObject($cacheKey, null);
        }
        return null;
    }
 
    public static function getByDateAndRestaurant($date, $rid) {
        $db_conn = DB::conn();
        $rbs = [];
        $sql = "SELECT id FROM ".HolidayHours::getTableName()." WHERE for_date = ? AND restaurant_id = ? ORDER BY id DESC";
        $db_conn->bindParameter($sql, 1, $date, "string");
        $db_conn->bindParameter($sql, 1, $rid, "integer");
        $result = $db_conn->query($sql);
        if ($result) {
            while ($row = $result->fetch()) {
                $rbs[] = new HolidayHours($row['id']);
            }
        }
        return $rbs;
    }
 
    public static function storeHours($holidayClosed, $forDate, $restaurantID, $holidayNotifications, $holidayOpenHour, $holidayOpenMinute, $holidayOpenMeridien, $holidayClosedHour, $holidayClosedMinute, $holidayClosedMeridien, $timeErrorMessage, $orderType, $namedHolidayID, $holidayDateRangeID, $categoryID = null, $isYearly = false, $showCategoryWhenClosed = false) {

        }
        if (!$time) {
            $time = $restaurant->getLocalTime();
        }
        $holidayHours = HolidayHours::getByDateAndCategoryAndType(date('Y-m-d 00:00:00', $time), $category->getId(), $orderType, $isHiddenToCustomers);
        if (is_object($holidayHours)) {
            return $holidayHours;
        }
        //check parent category too
        if ($category->parent_id) {
            $holidayHours = HolidayHours::getByDateAndCategoryAndType(date('Y-m-d 00:00:00', $time), $category->parent_id, $orderType, $isHiddenToCustomers);
            if (is_object($holidayHours)) {
                return $holidayHours;
            }
        }
        return false;
    }
 
    public static function getByDateAndRestaurantAndType($date, $rid, $type = 'PICKUP') {
        return HolidayHours::getByDateAndTypeAndRestaurantOrCategory($date, $rid, null, $type);
    }
 
    public static function getByDateAndCategoryAndType($date, $cid, $type = null, $isHiddenToCustomers = false) {
        return HolidayHours::getByDateAndTypeAndRestaurantOrCategory($date, null, $cid, $type, $isHiddenToCustomers);
    }
    
    public static function getByDateAndTypeAndRestaurantOrCategory($date, $rid = null, $cid = null, $type = 'PICKUP', $isHiddenToCustomers = false) {
        $db_conn = DB::conn();
        $cacheKey = 'hh_'.$date.'_'.($cid > 0 ? ('c'.$cid):('r'.$rid)).'_'.($type?:'ALL') . "_" . ($isHiddenToCustomers ? '1' : '0');
 
        $aObj = Cache::GetObject($cacheKey, true);
        if ($aObj || is_null($aObj)) {
            return $aObj;
        }
 
        $where = '';
        if ($cid) {
            $rid = $cid;
            if ($isHiddenToCustomers) {
                $where .= ' AND show_category_when_closed = 0';

    }

    /**
     * Get open and closing time including holiday hours and closed hours
     * @param $baseOrderType
     * @param $localTime
     * @param $returnLatestClose
     * @return array
     */
    public function getEffectiveOpenAndCloseTimes($baseOrderType, $localTime = null, $returnLatestClose = false) {
        $dt = $baseOrderType == 'DELIVERY'? 'Delivery' : '';
        $localTime = $localTime ?: $this->getLocalTime();
        $dayOfWeek = date('l', $localTime);
        $opensAt = $this->{'get'.$dt.$dayOfWeek.'Open'}();
        $closesAt = $this->{'get'.$dt.$dayOfWeek.'Closed'}();
        if ($this->two_hour_sets && ($localTime > strtotime(date('Y-m-d', $localTime) . ' ' . $closesAt) || $returnLatestClose)) {
            $opensAt = $this->{'get'.$dt.$dayOfWeek.'Open2'}();
            $closesAt = $this->{'get'.$dt.$dayOfWeek.'Closed2'}();
        }
        $holidayHours = HolidayHours::getByDateAndRestaurantAndType(date('Y-m-d 00:00:00', $dayOfWeek), $this->id, $baseOrderType);
        if (is_object($holidayHours)) {
            $opensAt = $holidayHours->getStartHour();
            $closesAt = $holidayHours->getEndHour();
        }
        $closedHours = ClosedHours::getByDateAndRestaurantAndType(date('Y-m-d 00:00:00', $dayOfWeek), $this->id, $baseOrderType);
        if (!is_object($holidayHours) && is_array($closedHours) && count($closedHours) > 0) {
            foreach ($closedHours as $h) {
                $startTime = date('H:i:s', strtotime($h->getStartTime()));
                $endTime = date('H:i:s', strtotime($h->getEndTime().'-1 minute'));
                if ($startTime <= $opensAt && $endTime >= $opensAt) {
                    $opensAt = $endTime;
                }
                if ($startTime <= $closesAt && $endTime >= $closesAt) {
                    $closesAt = $startTime;
                }
            }
        }
        return ['open' => $opensAt, 'close' => $closesAt];
    }

                if ($startTime <= $closesAt && $endTime >= $closesAt) {
                    $closesAt = $startTime;
                }
            }
        }
        return ['open' => $opensAt, 'close' => $closesAt];
    }

    public function getLatestEffectiveCloseTime($localTime = null, $orderType = null) {
        //pickup closing time
        $localTime = $localTime ?: $this->getLocalTime();
        $openAndClose = $this->getEffectiveOpenAndCloseTimes($orderType?:'PICKUP', $localTime, true);
        $dateAdjustment = $openAndClose['close'] < $openAndClose['open'] && $openAndClose['close'] < date('H:i', $localTime) ? ' +1 day' : '';
        $pickupCloseTimestamp = strtotime(date('Y-m-d', $localTime) . ' ' . $openAndClose['close'] . $dateAdjustment);
        if ($orderType) {
            return $pickupCloseTimestamp;
        }

        //delivery closing time
        $deliveryOpenAndClose = $this->getEffectiveOpenAndCloseTimes('DELIVERY', $localTime, true);
        $dateAdjustment = $deliveryOpenAndClose['close'] < $deliveryOpenAndClose['open'] && $deliveryOpenAndClose['close'] < date('H:i', $localTime) ? ' +1 day' : '';
        $deliveryCloseTimestamp = strtotime(date('Y-m-d', $localTime) . ' ' . $deliveryOpenAndClose['close'] . $dateAdjustment);

        //return latest closing time between pickup and del
        return max($deliveryCloseTimestamp, $pickupCloseTimestamp);
    }
    
    public function getTodaysHoursInfo() {
        $today = date('l');
        $holidayDate = date('Y-m-d 00:00:00', $this->getLocalTime());

        $hours = [];
        $earliestOpen = null;
        $latestClose = null;
        $earliestOpen2 = null;
        $latestClose2 = null;

        if ($this->getHasDineInBase()
            || $this->getHasPickupBase()
            || ($this->getHasDeliveryBase() && !$this->separate_delivery_hours)

 
    /**
     * @param string $orderType
     * @return bool
     */
    public function getAsapAndLaterDisabled(Restaurant $restaurant, $orderType = null) {
        $thirdPartyDeliveryDisabled = $orderType == 'DELIVERY' && $restaurant->isThirdPartyDeliveryDisablingDelivery();
        return $restaurant->getPublicOrderingIsClosedForever($orderType) || !$restaurant->hasAvailableDays($restaurant->getLocalTime(), $orderType) || $thirdPartyDeliveryDisabled;
    }
 
    /**
     * Returns true if the customer is not ordering for today
     * @param \Restaurant $restaurant
     * @param int $selectedTime timestamp
     * @param int $localTime timestamp
     * @return bool
     */
    public function getIsOrderForAnotherDay(Restaurant $restaurant, $selectedTime, $localTime = null) {
        $localTime = $localTime ?: $restaurant->getLocalTime();
        return $selectedTime > $restaurant->getLatestEffectiveCloseTime($localTime);
    }
}
 

                $this->setClosedAtEot(false);
                $this->setOrderPushedToNextDay(false);
                $this->setCalculatedNextOpenTime(0);
                if ($this->getIsClosedAtTime($restaurant, $eotCheckTime)) {
                    $this->setClosedAtEot(true);
                    $eot = $this->getNextOpenTime($restaurant, $eot, false, true);
                    $this->setCalculatedNextOpenTime($eot);
                    if (date('Y-m-d', $localTime) != date('Y-m-d', $eot)) {
                        if ($restaurant->getRequirePrepTimeOpening()) {
                            $eot = strtotime('+'.$prepTime.' Seconds', $eot);
                        }
                    }
                    $eot = $this->addThrottleTime($restaurant, $eot);
                } else {
                    $openTime = $this->getNextOpenTime($restaurant, $eot);
                    $this->setCalculatedNextOpenTime($openTime);
                }
 
                //If order is pushed to next day - save that info to show warnings to customer
                if ($this->getIsOrderForAnotherDay($restaurant, $eotCheckTime)) {
                    $this->setOrderPushedToNextDay(true);
                }
            } elseif ($this->getCalculatedNextOpenTime() && $this->getIsClosedAtTime($restaurant, $eotCheckTime)) {
                if ($this->getCalculatedNextOpenTime() < $eot) {
                    $eot = $this->getNextOpenTime($restaurant, $eot, false, true);
                } else {
                    $eot = $this->getCalculatedNextOpenTime();
                    $eot = $this->addThrottleTime($restaurant, $eot);
                }
            }
 
            //make sure earliest order time is after prep time
            if ($eot < $restaurant->getLocalTime() + $prepTime) {
                $eot = $restaurant->getLocalTime() + $prepTime;
            }
 
            return $eot;
        }
    }
 

                } else {
                    $times[$i.':'.$aMinute.' '.$meridian] = $i.':'.$aMinute.' '.$meridian;
                }
            }
        }
    }
    return $times;
}

function checkTimeWarning(Cart $cart, Restaurant $restaurant) {
    $originalOrderType = $cart->base_order_type;
    $localTime = $restaurant->local_time;
    $holidayDate = date('Y-m-d 00:00:00', $localTime);

    $closedTypePickup = false;
    if ($restaurant->getHasPickupBase()) {
        $cart->setBaseOrderType('PICKUP');
        $cart->updateToSession();
        $closedTypePickup = $cart->getIsClosedAtTime($restaurant, $localTime);
        $eot['PICKUP'] = $restaurant->hasAvailableDays($localTime, 'PICKUP') ? $cart->getEarliestOrderTime($restaurant, null, true) : null;
    }

    $closedTypeDinein = false;
    if ($restaurant->getHasDineInBase()) {
        $cart->setBaseOrderType('DINEIN');
        $cart->updateToSession();
        $closedTypeDinein = $cart->getIsClosedAtTime($restaurant, $localTime);
        $eot['DINEIN'] = $restaurant->hasAvailableDays($localTime, 'DINEIN') ? $cart->getEarliestOrderTime($restaurant, null, true) : null;
    }

    if ($restaurant->getHasDineInBase() || $restaurant->getHasPickupBase()) {
        $holidayHours = HolidayHours::getByDateAndRestaurantAndType($holidayDate, $restaurant->id, $cart->base_order_type);
        if ($holidayHours) {
            $startTime = strtotime(date('1990-01-01 H:i:00', strtotime($holidayHours->start_hour)));
            $endTime = strtotime(date('1990-01-01 H:i:00', strtotime($holidayHours->end_hour)));
            $readyTime = strtotime(date('1990-01-01 H:i:s', $localTime));
            if ($holidayHours->is_closed || ($startTime > $readyTime || $endTime < $readyTime)) {
                $eot['DINEIN_HOLIDAY'] = $holidayHours->message;
            }
        }

        }
 
        if (ClosedHours::isCategoryHidden($restaurant, $category) || HolidayHours::isCategoryHidden($restaurant, $category)) {
            redirectToOrderingWithError('Sorry, this category is currently unavailable.', [$restaurant, $menu, -1]);
        }
        $page_fragment = $account->getCategoryPageFragment($menu, $category->getId(), $restaurant->getHideAllPrices(), $restaurant, true);
 
        if (isset($_REQUEST['sort'])) {
            if ($_REQUEST['sort'] == "name") {
                usort($items, array("MenuItem", "nameAlphaSort"));
            } elseif ($_REQUEST['sort'] == "price") {
                usort($items, array("MenuItem", "priceSort"));
            }
        }
        break;
    case 4: //Item
    case 5: //Price
        //check if we're closed right now. If so, display warning
        if (!isset($_SESSION['time_ok']) && is_object($restaurant)) {
            $eot = checkTimeWarning($cart, $restaurant);
        }
        break;
}
 
if ($_REQUEST['ordering_level'] < 3 && is_object($menu)) {
    if ($account->getDefaultOrderingPage() == 1) {
        if ($_GET['embed']) {
            $qs = '?embed='.$_GET['embed'];
        } else {
            $qs = '';
        }
        redirectToOrdering([$restaurant, $menu, -1], $qs);
    } elseif ($account->getDefaultOrderingPage() == 2) {
        if ($_GET['embed']) {
            $qs = '?sort=alpha&embed='.$_GET['embed'];
        } else {
            $qs = '?sort=alpha';
        }
        redirectToOrdering([$restaurant, $menu, -1], $qs);
    }

 
        $cart->setDefaultOrderType($account, $restaurant);
 
        $cart->setDefaultFees($account, $restaurant);
    }
 
    $restaurantRequiredPages = [
        'login',
        'customerorders'
    ];
    if (is_null($restaurant) && in_array($_REQUEST['form'], $restaurantRequiredPages)) {
        redirectTo('home');
    }
 
    $modelPath = CORE_PATH . 'model4.0/customer/'.$_REQUEST['form'].'.php';
} else {
    $_REQUEST['mobiledetect'] = new Mobile_Detect;
}
if (is_readable($modelPath)) {
    include_once($modelPath);
}
App::debugbarTime("model '{$_REQUEST['form']}'");
 
$custom_nav = CustomNavigationTab::getAllForAccount($account->getId());
 
$view2HideRightColumns = ['checkout', 'dashboard', 'customerdetails', 'customerorders',
                                'mydeliveryaddresses', 'emailpreferences', 'mycoupons', 'mycreditcards', 'mypassword',
                                'customerorderdetails', 'editcustomer', 'adddeliveryaddress',
                                'editlocation', 'orderconfirmation','viewcart', 'map', 'validatecallback'];
if (in_array($_REQUEST['form'], $view2HideRightColumns)) {
    $hideRightColumn = true;
}
 
$myAccountPages = ['accountsettings', 'dashboard', 'customerdetails', 'customerorders', 'editaddress', 'editcustomer', 'mydeliveryaddresses', 'editlocation', 'emailpreferences', 'mycoupons', 'mycreditcards', 'mypassword', 'adddeliveryaddress', 'map', 'myloyalty'];
if (in_array($_REQUEST['form'], $myAccountPages)) {
    $isMyAccountPage = true;
}
 
if (!isset($cart) || !is_object($cart)) {
    $GLOBALS['cart'] = \Cart::getCurrent();

App::startTime();
 
ErrorHandlers::register();
 
// Global.php is the core setup file for the application
App::debugbarTime('Global.php');
require(dirname(__DIR__) . '/PHP/Global.php');
App::debugbarTime('Global.php');
/** @var string $controller The main controller - defined at /PHP/Global.php */
 
App::debugbarTime('Sentry - controller');
ErrorHandlers::sentryInit($controller); //doesn't always do much - not every controller has a Sentry project
App::debugbarTime('Sentry - controller');
 
App::debugbarTime("controller: $controller");
apache_note('AppController', $controller);
if (file_exists(CORE_PATH."lib/helpers/$controller.php")) {
    require CORE_PATH."lib/helpers/$controller.php";
}
require CORE_PATH."controllers/$controller.php";
App::debugbarTime("controller: $controller");