}
 
    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);

        $this->table = $table;
    }
 
    public function getFields($withTypes = false):array {
        //FIXME: workaround for BaseClass objects that are not present in the database. check BaseClass::NO_TABLE
        if (!$this->table) {
            return [];
        }
        if (!$this->typesCache) { //not in the local cache, let's fetch it
            $cacheKey = "describe_{$this->table}_1"; //this "1" meant "include ID" in the old code
 
            //TODO: replace with Cache::Remember
            $this->typesCache = Cache::GetArray($cacheKey);
            if (!$this->typesCache || self::SKIP_CACHE) { //not in the cache either, let's generate it
                $this->typesCache = collect(DB::select("DESCRIBE $this->table"))
                                        ->pluck('Type', 'Field')
                                        ->transform(['DbFields','simplifyType'])
                                        ->all();
 
                Cache::SetArray($cacheKey, $this->typesCache);
            }
        }
 
        if (!$this->fieldsCache && !$withTypes) {
            $this->fieldsCache = array_keys($this->typesCache);
        }
 
        return $withTypes? $this->typesCache : $this->fieldsCache;
    }
 
    /**
     * Separates all attributes into custom and pure fields (those present on the database table).
     * @param array $values
     * @return array 0 => custom fields, 1 => pure fields
     */
    public function splitCustom(array $values) {
        $tableFields = array_flip($this->getFields());
        $customFields = array_diff_key($values, $tableFields);
        $pureFields = array_intersect_key($values, $tableFields);
 

 
    /**
     * Sets the updated_at field, with a backport of the 5.5+ behavior for disabling that field.
     * @param mixed $value
     * @return EloquentModel
     */
    public function setUpdatedAt($value) {
        if (static::UPDATED_AT) {
            parent::setAttribute(static::UPDATED_AT, $value);
        }
        return $this;
    }
 
    public function getAttribute($key) {
        //first we check for mutated getters
        if ($getter = $this->findAnyGetMutator($key)) {
            return $this->$getter();
        }
 
        if (in_array($key, $this->fields()->getFields()) || array_key_exists($key, $this->attributes)) {
            //this is an existing database field or came from a custom query, so let's get it as an attribute
            return parent::getAttribute($key);
        } elseif (method_exists($this, $key)) {
            //this is a relationship method, skipped at getAttribute() by the last if-clause, so let's call it here
            try {
                return $this->getRelationValue($key);
            } catch (LogicException $e) {
                throw new LogicException('You probably forgot to *return* from your relation method - or accidentally triggered a relation getter where you shouldn\'t', $e->getCode(), $e);
            }
        } elseif (property_exists($this, $key)) {
            //support for legacy getter of custom props
            return $this->$key;
        } else {
            //probably a custom prop (sometimes used in legacy code), so let's get it directly from the object as usual
            //this causes a small side-effect where isset() can't be used with undeclared custom props; property_exists() should be used instead (actually, they should be declared lol)
            if (DevLevel > 0) {
                trigger_error('Custom property got from '.static::class.": $key", E_USER_NOTICE);
            }
            return $this->$key;
        }

     *
     * @param  int  $perPage
     * @return $this
     */
    public function setPerPage($perPage)
    {
        $this->perPage = $perPage;
 
        return $this;
    }
 
    /**
     * Dynamically retrieve attributes on the model.
     *
     * @param  string  $key
     * @return mixed
     */
    public function __get($key)
    {
        return $this->getAttribute($key);
    }
 
    /**
     * Dynamically set attributes on the model.
     *
     * @param  string  $key
     * @param  mixed  $value
     * @return void
     */
    public function __set($key, $value)
    {
        $this->setAttribute($key, $value);
    }
 
    /**
     * Determine if the given attribute exists.
     *
     * @param  mixed  $offset
     * @return bool
     */

     * @param string $func
     * @param array  $args
     * @return mixed|null If setXyz() is called, it will return the final stored format. Otherwise, returns what's
     * recovered from getXyz() or whatever the resulting magic method should return.
     */
    public function __call($func, $args) {
        $action = substr($func, 0, 3);
 
        $prop = snake_case(substr($func, 3));
        //we need to extend snake_case() result to consider numbers as boundaries too..... for most cases :|
        if (!preg_match('/(^street|note|freepos_tax)\d/', $prop)) {
            $prop = preg_replace('/(.)(?=\d)/u', '$1_', $prop);
        }
 
        switch ($action) {
            case 'set':
                $this->__set($prop, $args[0]);
                return $this->__get($prop);
            case 'get':
                return $this->__get($prop);
            case 'iss':
                return isset($this->attributes[$prop]);
        }
 
        try {
            return parent::__call($func, $args);
        } catch (BadMethodCallException $e) {
            trigger_error('Invalid method called: '.get_class($this)."::$func()", E_USER_WARNING);
            return null;
        }
    }
 
    /**
     * Checks for either legacy or Laravel-style mutators (setField() or getFieldAttribute()).
     * @param string $getSet either 'get' or 'set'
     * @param string $key
     * @return string
     */
    private function findAnyMutator($getSet, $key):string {
        $base = $getSet.studly_case($key);

    });
 
if (!$hnHost) {
    $status = new AccessStatus();
    $status->close_message = 'The URL you were trying to access is not valid on this server. If you feel this is in error, please contact your restaurant or online ordering provider. Sorry for any inconvenience!';
 
    //if HN_DevToLive() didn't throw up, but still we end up here, this might be just a 404 error, or an actual missing
    // SSL cert when accessing DevLevel 2 intentionally. Thus, let's include a helper message as well.
    if (DevLevel >= 2) {
        preg_match('/^(.*)\.(\d+)\.(.*)$/', $_SERVER['HTTP_HOST'], $domainPieces);
        if (sizeof($domainPieces) == 4) {
            $status->close_message .= "<br/><br/>Psst... developer! This may also be a missing SSL Cert.<br/>If there's no typo on the URL, <a href='https://order.ehungry.com.$domainPieces[2].$domainPieces[3]/rcs/?form=devtools'>generate a certificate</a> for <tt>$domainPieces[1]</tt>";
        }
    }
 
    include(App_Path.'/Web/closed.php');
    exit(0);
}
 
if ($hnHost->getRedirectEnabled()) {
    header('Location: '.$hnHost->getRedirectHost().($hnHost->getRedirectUri()==""?$_SERVER['REQUEST_URI']:$hnHost->getRedirectUri()));
}
 
if (DevLevel == 0) {
    define('HTTPS_HOST', 'https://'.$hnHost->getHnSecure()."/");
} else {
    define('HTTPS_HOST', 'https://'.HN_LiveToDev($hnHost->getHnSecure())."/");
}
 
define('HN_SECURE', $hnHost->getHnSecure());
define('APP_HOSTNAME', HTTPS_HOST);
 
///////////////////////////////////////////////////////////////////////////////
// baked in settings
 
$_REQUEST['status'] = array();
 
define('Secure', 1); //phpcs:ignore Generic.NamingConventions.UpperCaseConstantName.ConstantNotUpperCase
define('Insecure', 2); //phpcs:ignore Generic.NamingConventions.UpperCaseConstantName.ConstantNotUpperCase
 

<? /** @noinspection PhpIncludeInspection - to avoid marking dynamic includes */
 
//TODO create a «root»/_bootstrap.php which can be used by .psysh.php, tests/bootstrap.php and Web/index.php
require(dirname(__DIR__).'/PHP/base_consts.php');
require(dirname(__DIR__).'/PHP/autoloader.php');
initializeAutoLoader();
 
//disabled for now since we already have our own Alerts infrastructure, and it's not worth it to append another cloud provider to the startup of every freaking request; it's also not possible to catch errors this early if we depend on database checks, but we'll leave it here in case we change our mind?
//ErrorHandlers::sentryInit(); //early catch of errors and failsafe for smaller controllers, not in Sentry
 
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");