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

     * Checks for either legacy or Laravel-style getters (getField() or getFieldAttribute()).
     * @param string $key
     * @return string
     */
    private function findAnyGetMutator($key):string {
        return $this->findAnyMutator('get', $key);
    }
 
    public function setAttribute($key, $value) {
        if ($key == 'key_name' && in_array($key, $this->fields()->getFields())) {
            //TODO: another special case, there's a field with the same name as the setter for the Eloquent PK at TemplateAccountSettings
            return parent::setAttribute($key, $value);
        }
 
        //first we check for the mutated setters
        if ($setter = $this->findAnySetMutator($key)) {
            return $this->$setter($value);
        }
 
        if (in_array($key, $this->fields()->getFields()) || array_key_exists($key, $this->attributes)) {
            //this is an existing database field, so let's set it as an attribute
            return parent::setAttribute($key, $value);
        } elseif (property_exists($this, $key)) {
            //support for legacy setter of custom props
            return $this->$key = $value;
        } else {
            //probably a custom prop (sometimes used in legacy code), so let's set it directly on the object as usual
            if (DevLevel > 0) {
                trigger_error('Custom property set at '.static::class.": $key", E_USER_NOTICE);
            }
            return $this->$key = $value;
        }
    }
 
    /**
     * Sets the "created_at" field, similarly to {@link HasTimestamps::setCreatedAt()}.
     *
     * We had to override this method because of the legacy setters, as follows: Eloquent is based on setXyzAttribute()
     * setters, but we also allow setXyz() for legacy reasons, and this happens at {@link setAttribute()}. When
     * {@link updateTimestamps()} is called, it calls setUpdateAt() (which works fine because our configured field is

     */
    protected static $restaurantDates = [];
 
    /**
     * @param int|array|ParameterHandler $idOrAttr An ID, so the entry is loaded from the database, or a list of attributes to be pre-filled into a new entry.
     */
    public function __construct($idOrAttr = null) {
        if (is_numeric($idOrAttr)) {
            //legacy behavior
            if ($entry = static::find($idOrAttr)) {
                //TODO: find a way to have default attributes respected in the same way Eloquent does - probably a mix of array_merge() and array_filter() (so we clear empty values from the found entry), or maybe we'll need a custom merger so the final attribute array doesn't miss any field
                $this->setRawAttributes($entry->attributes, true);
                $this->exists = true;
            }
            $this->setAttribute('id', $idOrAttr);
            parent::__construct();
        } elseif (is_array($idOrAttr) || $idOrAttr instanceof ParameterHandler) {
            parent::__construct($idOrAttr); //default Eloquent behavior + our custom fill()
        } else {
            $this->setAttribute('id', -1); //FIXME: legacy behavior as well... can we ditch this someday please????
            parent::__construct();
        }
    }
 
    /**
     * We've overwritten the original query builder to include extra methods :)
     * @param \Illuminate\Database\Query\Builder $query
     * @return Builder|EloquentModel|eHungry\Illuminate\Database\Eloquent\Builder
     */
    public function newEloquentBuilder($query) {
        return new eHungry\Illuminate\Database\Eloquent\Builder($query);
    }
 
    protected static function boot() {
        parent::boot();
 
        //Registering events in a better way - https://laravel.com/docs/5.7/eloquent#events
        //Based on the Ardent implementation (https://goo.gl/ieFB59), taken from Yii/Rails models
        $eventTypes = ['sav', 'creat', 'updat', 'delet', 'restor', 'retriev'];
        $tenses = ['ing', 'ed']; //There's NO retrieving event! a check was not placed here for performance

        /** @var static $result */
        $result = $this->directFind($id, $columns);
 
        if ($result && $columns == ['*']) {
            $result->cacheSet();
        }
 
        return $result;
    }
 
    /**
     * Finds one or more entries in the database. In case of single-finds, checks the cache layer first.
     * @see BaseClass::SHOULD_BE_CACHED
     * @see Cache
     * @param int|int[] $id
     * @param array $columns
     * @return Collection|static|static[]|null
     */
    public static function find($id, $columns = ['*']) {
        return (new static)->findNew($id, $columns);
    }
 
    //FIXME: we're missing cached versions for findOrFail and findOrNew, at the very least
 
    /** @deprecated use {@link save()} instead */
    public function store() {
        return $this->save();
    }
 
    /**
     * Overrides the original save to return the generated ID.
     * After saving, caching ({@link SHOULD_BE_CACHED}) and logging ({@link willLogChanges()}/{@link loggingChanges()})
     * are done, if enabled.
     * @param array $options The only option available is "touch" (which is true by default); setting it to false will
     *                       disable "touching" parent relationships (aka belongsTo/belongsToMany) listed in
     *                       {@link $touches}, which updates their timestamps upon a successful save.
     *                       See https://laravel.com/docs/5.4/eloquent-relationships#touching-parent-timestamps
     * @return bool|int Returns the ID in case of a successful operation, or false instead.
     */
    public function save(array $options = []) {

     * Stores which classes had their logging behavior overwritten during runtime.
     * @var array
     * @see willLogChanges()
     */
    private static $overwrittenLogChanges = [];
 
    /**
     * @var array Indicates the fields which should be placed in the restaurant's timezone when casting to JSON
     * @see addDateAttributesToArray()
     * @see https://github.com/ehungry/EHungry/wiki/Data-standards#timezone-less-restaurant-times
     */
    protected static $restaurantDates = [];
 
    /**
     * @param int|array|ParameterHandler $idOrAttr An ID, so the entry is loaded from the database, or a list of attributes to be pre-filled into a new entry.
     */
    public function __construct($idOrAttr = null) {
        if (is_numeric($idOrAttr)) {
            //legacy behavior
            if ($entry = static::find($idOrAttr)) {
                //TODO: find a way to have default attributes respected in the same way Eloquent does - probably a mix of array_merge() and array_filter() (so we clear empty values from the found entry), or maybe we'll need a custom merger so the final attribute array doesn't miss any field
                $this->setRawAttributes($entry->attributes, true);
                $this->exists = true;
            }
            $this->setAttribute('id', $idOrAttr);
            parent::__construct();
        } elseif (is_array($idOrAttr) || $idOrAttr instanceof ParameterHandler) {
            parent::__construct($idOrAttr); //default Eloquent behavior + our custom fill()
        } else {
            $this->setAttribute('id', -1); //FIXME: legacy behavior as well... can we ditch this someday please????
            parent::__construct();
        }
    }
 
    /**
     * We've overwritten the original query builder to include extra methods :)
     * @param \Illuminate\Database\Query\Builder $query
     * @return Builder|EloquentModel|eHungry\Illuminate\Database\Eloquent\Builder
     */
    public function newEloquentBuilder($query) {

<?
/**
 * @property bool $is_reseller_closed [default: 0]
 * @property bool $is_manager_closed [default: 0]
 * @property bool $is_customer_closed [default: 0]
 * @property bool $is_ordering_closed [default: 0]
 * @property int $is_notif_closed [default: 0]
 * @property string $close_message
 */
class AccessStatus extends BaseClass {
    public const SHOULD_BE_CACHED = true;
    protected const CACHE_EXPIRATION = 30; //only cache for a short period in case things blow up and we need to adjust settings direct in DB
 
    public static function getStatus() {
        return new AccessStatus(1);
    }
}
 

        $_SESSION['customer_session'] = $customer_session;
        redirectToAdminWithError('ordering');
    }
}
 
//using the "open in new tab" link from the admin side to access the customer side
if (isset($_REQUEST['adminreturn'])) {
    $_SESSION['adminreturn'] = $_REQUEST['adminreturn'];
    $_SESSION['adminreturnlastaccessed'] = time();
}
if (isset($_SESSION['adminreturn']) && $_SESSION['adminreturn']) {
    $_SESSION['adminreturnlastaccessed'] = time();
}
 
if (isset($_REQUEST['reset'])) {
    unset($_SESSION);
    session_destroy();
}
 
$status = \AccessStatus::getStatus();
if ($status->getIsCustomerClosed()) {
    if (isset($_SESSION['admin_id'])) {
        echo '<div style="background-color:#FF0000;font-weight:bold;font-size:2em;padding:4px;border-bottom:solid 2px #000;color:#FFF;">SITE CLOSED TO USERS</div>';
    } else {
        http_response_code(503);
        include(App_Path.'/Web/closed.php');
        exit(0);
    }
}
 
$validPages = array (
    'accessibility' => false,
    'category' => false,
    'contact' => false,
    'customerregister' => false,
    'editcartitem' => false,
    'forgotpass' => false,
    'help' => false,
    'home' => false,
    'link' => false,

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