}
 
    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;
    }
 
    /**

                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;
    }
 
    public static function Exists(...$key):?bool {
        if ($i = static::getInstance()) {
            return $i->exists($key);

        if ($aObj || is_null($aObj)) {
            return $aObj;
        }
 
        $db_conn = DB::conn();
        $rbs = array();
        if ($cid && $isHiddenToCustomers) {
            $sql .= ' AND show_category_when_closed = 0';
        }
        $sql = "SELECT * FROM ".ClosedHours::getTableName()." WHERE (restaurant_id = ? OR category_id = ?) ".$sql." ORDER BY id DESC";
        $db_conn->bindParameter($sql, 1, $rid, "integer");
        $db_conn->bindParameter($sql, 1, $cid, "integer");
        $result = $db_conn->query($sql);
        if ($result && $result->rowCount() > 0) {
            while ($row = $result->fetch()) {
                $ch = new ClosedHours();
                $ch->loadFromArray($row, true);
                $rbs[] = $ch;
            }
            Cache::SetArray($cacheKey, $rbs);
            return $rbs;
        }
        Cache::SetObject($cacheKey, null);
        return null;
    }
    
    public static function clearCache($rid, $cid = null) {
        global $days;
        $types = ['PICKUP', 'DINEIN', 'DELIVERY'];
        $isHiddenToCustomersArray = [0, 1];
        foreach ($days as $d) {
            foreach ($types as $t) {
                foreach ($isHiddenToCustomersArray as $isHiddenToCustomers) {
                    Cache::Delete('ch_'.($cid > 0? ('c'.$cid) : ('r'.$rid)).'_'.mb_strtolower($d).'_'.$t.'_'.$isHiddenToCustomers);
                }
            }
        }
    }
 
    public function toString() {

        }
        if (!$time) {
            $time = $restaurant->getLocalTime();
        }
        $closedHours = ClosedHours::getByDateAndCategoryAndType($time, $category->getId(), $orderType, $isHiddenToCustomers);
        if (is_array($closedHours) && count($closedHours) > 0) {
            return $closedHours;
        }
        //check parent category too
        if ($category->getParentId()) {
            $closedHours = ClosedHours::getByDateAndCategoryAndType($time, $category->getParentId(), $orderType, $isHiddenToCustomers);
            if (is_array($closedHours) && count($closedHours) > 0) {
                return $closedHours;
            }
        }
        return false;
    }
 
    public static function getByDateAndRestaurantAndType($time = null, $rid = -1, $type = 'PICKUP') {
        return ClosedHours::getByDateAndTypeAndRestaurantOrCategory($time, $rid, null, $type);
    }
 
    public static function getByDateAndCategoryAndType($time = null, $cid = null, $type = 'PICKUP', $isHiddenToCustomers = false) {
        return ClosedHours::getByDateAndTypeAndRestaurantOrCategory($time, -1, $cid, $type, $isHiddenToCustomers);
    }
 
    public static function getByDateAndTypeAndRestaurantOrCategory($time = null, $rid = -1, $cid = -1, $type = 'PICKUP', $isHiddenToCustomers = false) {
        $day = mb_strtolower(date('l', $time));
        $sql = " AND ".$day." = 1";
 
        if (!$type) {
            $type = 'PICKUP';
        }
        switch ($type) {
            case 'PICKUP':
                $sql .= " AND pickup=1 ";
                break;
            case 'DELIVERY':
                $sql .= " AND delivery=1 ";
                break;

                if (empty($startEndArray[$i-1]['00:00']) && $prevclose < $prevopen) {
                    $startEndArray[$i-1]['00:00'] = $prevclose;
                    $prevDayClose = $prevclose;
                }
            }
        }
 
        //if there are holiday hours for this day - only return these hours
        $startEndInvalidArray = [];
        if (!$excludingClosedHours) {
            $holidayHours = HolidayHours::getByDateAndRestaurantAndType(date('Y-m-d 00:00:00', $dateTimestamp), $this->getId(), $cart->getBaseOrderType());
            if (is_object($holidayHours)) {
                $startTime     = date('H:i', strtotime($holidayHours->getStartHour()));
                $endTime       = date('H:i', strtotime($holidayHours->getEndHour()));
                $startEndArray = [[$startTime => $endTime]];
                $openTimes = [$startTime];
            }
 
            //remove times from closed hours
            $closedHours = ClosedHours::getByDateAndRestaurantAndType($dateTimestamp, $this->getId(), $cart->getBaseOrderType());
            if (!is_object($holidayHours) && is_array($closedHours) && count($closedHours) > 0) {
                foreach ($closedHours as $h) {
                    $startTime              = date('H:i', strtotime($h->getStartTime()));
                    $endTime                = date('H:i', strtotime($h->getEndTime()));
                    $startEndInvalidArray[] = [$startTime => $endTime];
                }
            }
        }
 
        //menu available times
        $prevDayMenusClose = null;
        $allPrevDayMenuClosed = true;
        $onePrevDayMenuClosed = false;
        $getTimesForAnyMenus = false;
        if ($menus === null) {
            $menus = $cart->getMenus();
        }
        if (!count($menus)) {
            $menus = $this->getActiveMenus(true);
            $getTimesForAnyMenus = true;

 
            //disable days for when the cart items' category is closed
            $categories = $cart->getCartItemsCategories();
            foreach ($categories as $category) {
                $isCategoryHidden = ClosedHours::isCategoryDisabled($this, $category, $currentLocalTime, false, $orderType) || HolidayHours::isCategoryDisabled($this, $category, $currentLocalTime, false, $orderType);
                if ($isCategoryHidden) {
                    $closed = true;
                }
            }
 
            //ordering closed
            $closedUntil = $this->getLocalPublicOrderingClosedUntilText(true, $orderType);
            if ($closedUntil && strtotime(date('Y-m-d', $closedUntil)) > strtotime(date('Y-m-d', $currentLocalTime))) {
                $closed = true;
            }
 
            $dateCurrent = date('Y-m-d', $currentLocalTime);
            if (!$closed) {
                //if no times are available on that day - show whole day as unavailable
                $times = $this->getAvailableTimes(new DateTime($dateCurrent), $excludeClosedHours, $menus, $ignoreOrderingDaysLimit, $excludeHoursPastClosing);
                if (count($times)) {
                    $ymd = date('Y-m-d', $currentLocalTime);
                    $availableDates[$ymd] = $ymd;
                }
            }
        }
 
        $cart->setBaseOrderType($savedOrderType);
        $cart->updateToSession();
 
        $cache[$cacheKey] = $availableDates;
 
        if ($returnAsKeys) {
            return $availableDates;
        } else {
            return array_values($availableDates);
        }
    }
 
    public function hasAvailableDays($selectedTime, $orderType) {

     * @param bool $ignoreDaysLimit
     * @param Menu[] $menus
     * @return array
     * @throws Exception
     */
    public function getOrderingDaysForAnyType($ignoreDaysLimit = false, $menus = []) {
        // Use a static variable to store cache within the request scope, so we don't recalculate this on every call within the request
        static $cache = [];
        $cacheKey = ($ignoreDaysLimit ? '1' : '0') .
            ($menus === null ? 'null' : md5(json_encode($menus)));
 
        if (isset($cache[$cacheKey])) {
            return $cache[$cacheKey];
        }
 
        $orderTypes = $this->getEnabledBaseOrderTypes();
        $availableDates = [];
        $dateTime = new DateTime(date('Y-m-d', $this->getLocalTime()));
        if (isset($orderTypes["PICKUP"]) || isset($orderTypes["DINEIN"])) {
            $availableDates = $this->getAvailableDates($dateTime, 'PICKUP', false, $ignoreDaysLimit, false, $menus);
        }
        if (isset($orderTypes["DELIVERY"])) {
            $availableDates = array_merge($availableDates, $this->getAvailableDates($dateTime, 'DELIVERY', false, $ignoreDaysLimit, false, $menus));
        }
        sort($availableDates);
        $cache[$cacheKey] = $availableDates;
        return $availableDates;
    }
 
    /**
     * @param DateTime $date
     * @return array
     */
    public function getAvailableTimeSlots($date) {
        //time slots
        if ($this->time_slots_enabled) {
            $validTimes = $this->getAvailableTimes($date);
            $timeSlots = RestaurantTimeSlot::getForRestaurant($this);
            $validTimeSlots = [];
 

        $cart->setBaseOrderType($savedOrderType);
        $cart->updateToSession();
 
        $cache[$cacheKey] = $availableDates;
 
        if ($returnAsKeys) {
            return $availableDates;
        } else {
            return array_values($availableDates);
        }
    }
 
    public function hasAvailableDays($selectedTime, $orderType) {
        $dateTime = new DateTime(date('Y-m-d', $selectedTime));
        $availableDates = $this->getAvailableDates($dateTime, $orderType, true, true, false, []);
        return count($availableDates) > 0;
    }
 
    public function hasOrderingDaysForAnyType() {
        return count($this->getOrderingDaysForAnyType()) > 0;
    }
 
    /**
     * @param bool $ignoreDaysLimit
     * @param Menu[] $menus
     * @return array
     * @throws Exception
     */
    public function getOrderingDaysForAnyType($ignoreDaysLimit = false, $menus = []) {
        // Use a static variable to store cache within the request scope, so we don't recalculate this on every call within the request
        static $cache = [];
        $cacheKey = ($ignoreDaysLimit ? '1' : '0') .
            ($menus === null ? 'null' : md5(json_encode($menus)));
 
        if (isset($cache[$cacheKey])) {
            return $cache[$cacheKey];
        }
 
        $orderTypes = $this->getEnabledBaseOrderTypes();
        $availableDates = [];

            if ($restaurant->getPublicOrderingIsClosedForever()) {
                return $returnClosedUntilTime ? 'Indefinitely' : 'Online ordering is not currently offered at this location.';
            }
 
            if ($restaurant->public_ordering_closed_until) {
                return $restaurant->getLocalPublicOrderingClosedUntilText($returnClosedUntilTime);
            }
        }
        if (is_string($defaultMsg)) {
            return $returnClosedUntilTime ? 'Indefinitely' : $defaultMsg;
        }
 
        return $returnClosedUntilTime ? 'Indefinitely' : ($result?: true); //in case result is an empty string
    }
 
    if ($skipLoginCheck && is_object($restaurant) && $restaurant->isOrderingClosed()) {
        return true;
    }
 
    if (is_object($restaurant) && !$restaurant->hasOrderingDaysForAnyType()) {
        if ($restaurant->same_day_orders_only || $restaurant->asap_orders_only) {
            $firstAvailableTime = $restaurant->getFirstAvailableTime();
            return $returnClosedUntilTime ? $firstAvailableTime
                : ('Online ordering is closed' . ($firstAvailableTime ? (' until ' . date('F jS \a\t g:iA', $firstAvailableTime)) : ''));
        }
        return $returnClosedUntilTime ? strtotime('+200 years') : 'Online ordering is closed';
    }
 
    return false;
}
 
function addErrorDialogueToLoadEvent() {
    if (!isset($_REQUEST['hide_error_dialog'])) {
        $errStr = str_replace("'", "‘", $_REQUEST['errors']);
        $errStr = preg_replace('/\r\n/', ' ', $errStr);
        if ($errStr) {
            return '<script type="text/javascript" defer="defer">
            var tmpOnload = window.onload;
            window.onload = function() {
                if(tmpOnload) tmpOnload();

if ($account->getSkipTimeWarning()) {
    $_SESSION['time_ok'] = true;
}
 
if (shouldShowAdminBypassMessageForCheckout()) {
    setStatus(ONLINE_ORDERING_BYPASS_MESSAGE);
}
 
if (is_object($restaurant) && is_object($menu) && is_object($category) && isset($_REQUEST['item_id'])) {
    $item = new MenuItem($_REQUEST['item_id']);
    $item->setQuantity(1);
    if (!$item->isInMenu($menu->getId())) {
        redirectToOrderingWithError('The selected menu item is not available in the selected menu.', [$restaurant, $menu, $category]);
    }
 
    if (!MenuItemAvailability::isAvailableForMenuItemAndTime($item->getId(), $restaurant->getLocalTime())) {
        redirectToOrderingWithError('The selected menu item has limited availability. It is not currently offered at this time.', [$restaurant, $menu, $category]);
    }
 
    $closedMsg = isOrderingClosed(CLOSED_MSG_RESTAURANT);
 
    if ($closedMsg && is_string($closedMsg)) {
        setStatus($closedMsg);
    }
 
    if (isset($_REQUEST['price_id'])) {
        $p = new MenuItemPrice($_REQUEST['price_id']);
        if ($p->getMenuItemId() == $item->getId()) {
            $selected_price = $p;
            $selectPriceId = $p->getId();
        }
    }
}
 
$_REQUEST['_PAGETITLE'] = '';
$_REQUEST['_PAGEDESCRIPTION'] = '';
$_REQUEST['_PAGEH2'] = '';
$menuText = '';
$orderTypeText = '';
//check that our order level contains the necessary bits of valid data, otherwise redirect back up

 
        $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");