}
 
    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

     */
    public function __call($method, $parameters)
    {
        if (in_array($method, ['increment', 'decrement'])) {
            return $this->$method(...$parameters);
        }
 
        return $this->newQuery()->$method(...$parameters);
    }
 
    /**
     * Handle dynamic static method calls into the method.
     *
     * @param  string  $method
     * @param  array  $parameters
     * @return mixed
     */
    public static function __callStatic($method, $parameters)
    {
        return (new static)->$method(...$parameters);
    }
 
    /**
     * Convert the model to its string representation.
     *
     * @return string
     */
    public function __toString()
    {
        return $this->toJson();
    }
 
    /**
     * When a model is being unserialized, check if it needs to be booted.
     *
     * @return void
     */
    public function __wakeup()
    {
        $this->bootIfNotBooted();

 
    protected const DISABLE_PRESERVATION = true;
 
    public $timestamps = true;
    protected $dates = ['modified_at', 'created_at'];
    protected static $searchResponseAttributes = [];
 
    public static function clearAddress($address) {
        return trim(preg_replace('/\s+/S', ' ', preg_replace('/[^A-Za-z0-9\s]/', '', $address)));
    }
 
    /**
     * The meat of {@link search()}. Runs a search query and deletes the entry if it's too old, returning null;
     * otherwise, returns the main attributes of what's found (given {@link $searchResponseAttributes}.
     * @param array $args
     * @return mixed|null
     */
    final protected static function searchProcedure(array $args) {
        /** @var self $entry */
        $entry = self::where($args)->first();
        if (!$entry) {
            return null;
        }
 
        //if result older than 6 months, time for an update
        if ($entry->modified_at->lessThanOrEqualTo(new DateTime('6 months ago'))) {
            $entry->delete();
            return null;
        } else {
            //FIXME: replace with "return $entry->only(static::$searchResponseAttributes)" when PHP 7 / Eloquent 5.5 arrive
            $result = collect($entry->attributes)->only(static::$searchResponseAttributes)->all();
            return sizeof($result) == 1? current($result) : array_values($result);
        }
    }
 
    /**
     * Should be implemented on children classes by using {@link searchProcedure()} with the correct arguments.
     * @return array|null
     */
    public static function search() {

 * @property float $longitude [default: 0.00000000]
 * @property string $ip
 */
class GeocodeCache extends GeoCache {
 
    protected $guarded = ['id', 'created_at', 'modified_at'];
 
    protected static $searchResponseAttributes = ['latitude', 'longitude'];
 
    public function setAddressAttribute($address) {
        $this->attributes['address'] = self::clearAddress($address);
    }
 
    /**
     * Searches the geocode cache for a given address.
     * @param string $address
     * @return float[]|null Returns lat/long, or null if not found
     */
    public static function search($address = null) {
        return self::searchProcedure(['address' => self::clearAddress($address)]);
    }
 
    public static function remove($address = null) {
        self::removeProcedure(['address' => self::clearAddress($address)]);
    }
}
 

<?
/**
 * @property string $zip_code
 * @property string $city
 * @property string $county
 * @property string $state
 * @property string $AreaCode
 * @property float $Latitude
 * @property float $Longitude
 */
class ZipCode extends BaseClass {
    
    public static function getGeoLocation($addr = '', $attempt = 1) {
        if (preg_match('/^[\s,]+$/', $addr)) {
            return false;
        }
        if ($addr == '90210') {
            $addr .= ', USA'; // google will not assume that this postal code is in the US like it does for all? others and fails to geocode it
        }
        if ($coords = GeocodeCache::search($addr)) {
            return $coords;
        }
        $ch = curl_init();
        curl_setopt($ch, CURLOPT_URL, GOOGLE_MAPS_GEOCODE_URL . 'json?key='.GOOGLE_SERVER_API_KEY.'&address='.urlencode($addr));
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
        $geocode_data = curl_exec($ch);
 
        $sl = [
            'ip' => $ip,
            'addr' => $addr,
            'cnt' => $attempt
        ];
 
        if ($geocode_data) {
            try {
                $js = json_decode($geocode_data);
            } catch (Exception $e) {
                Alert::sendAlert(
                    ALERT_LEVEL_WARNING,
                    ALERT_EMAIL,

 
        // check for the 'near-me' ajax request hidden form variable (which will be included in the form in all but the initial request)
        if (!empty($request['near-me']) && empty($request['city']) && empty($request['state'])) {
            return static::restaurantsNearMe($params, $request);
        } else {
            unset($request['near-me']);
        }
 
        return static::restaurantList($request);
    }
 
    public static function restaurantsByStateAndCity(array $params, array $request) {
        $state = \EDS\undasherize($params['state']);
        $city = \EDS\undasherize($params['city']);
        $request = array_merge($request, static::getStateAndCityIfRestaurantsAvailable($state, $city));
 
        $address = "$city, $state";
        $request['search'] = $address;
 
        $geocode_data = \ZipCode::getGeoLocation($address);
        if ($geocode_data) {
            $request['lat'] = $geocode_data[0];
            $request['lng'] = $geocode_data[1];
        }
 
        return static::restaurantList($request);
    }
    
    private static function getStateAndCityIfRestaurantsAvailable(?string $state_or_abbr, ?string $city) {
        $state_or_abbr = trim($state_or_abbr ?: '');
        $city = trim($city ?: '');
 
        $states = DataService::getStates();
        $state_name = (
            $state_or_abbr && array_key_exists($state_or_abbr, $states)
                ? $state_or_abbr
                : (getStateFullName($state_or_abbr) && array_key_exists(getStateFullName($state_or_abbr), $states)
                    ? getStateFullName($state_or_abbr)
                    : null)
        );

     * ```
     *
     * @return mixed
     */
    public static function handle(string $method, string $url, array $request, array $route_classes) {
        $_REQUEST['_VERSION'] = 4; // Important for some methods that rely on the version
 
        $account_id_string = Account::getAccountIdString();
        $decoded_url = urldecode($url); // Handle encoded characters like `%20`
        $unprefixed_url = $account_id_string
            ? preg_replace("/^\/$account_id_string/", '', $decoded_url)
            : $decoded_url;
 
        foreach ($route_classes as $route_class) {
            $routes = $route_class::ROUTES;
            foreach ($routes as $path => $handler) {
                $params = [];
 
                if (preg_match("/^$path\/?$/i", "$method $unprefixed_url", $params)) {
                    return $route_class::$handler($params, $request);
                }
            }
        }
 
        http_response_code(404);
        return '<div class="px-4 py-3">' . \EDS\Alert(['variant' => 'danger'], 'Not Found') . '</div>';
    }
}
 

require_once(CORE_PATH . 'auth/forgotpassword.php');
require_once(CORE_PATH . 'auth/login.php');
require_once(CORE_PATH . 'auth/register.php');
 
require_once(CORE_PATH . 'marketplace/assets/assets.php');
 
require_once(__DIR__ . '/routes/landing.php');
require_once(__DIR__ . '/routes/campaigns.php');
require_once(__DIR__ . '/routes/product.php');
require_once(__DIR__ . '/routes/restaurant_list.php');
require_once(__DIR__ . '/routes/restaurant_details.php');
require_once(__DIR__ . '/routes/support.php');
require_once(__DIR__ . '/routes/generatedfilesroute.php');
 
$handler_output = \eHungry\Services\Router::handle(
    $_SERVER['REQUEST_METHOD'],
    parse_url($_SERVER['REQUEST_URI'], PHP_URL_PATH),
    $_REQUEST,
    [
        \AccountSettings\ProfileInfoRoutes::class,
        \AccountSettings\BasicInformationRoutes::class,
        \AccountSettings\ChangePasswordRoutes::class,
        \AccountSettings\AddressRoutes::class,
        \AccountSettings\PaymentMethodRoutes::class,
        \AccountSettings\CommunicationRoutes::class,
        \AccountSettings\CampaignsRoutes::class,
        \AccountSettings\AccountRoutes::class,
        \AccountSettings\OrderRoutes::class,
        \AccountSettings\CouponRoutes::class,
 
        \Auth\ForgotPasswordRoutes::class,
        \Auth\LoginRoutes::class,
        \Auth\RegisterRoutes::class,
 
        LandingRoute::class,
        CampaignsRoute::class,
        ProductRoute::class,
        RestaurantListRoute::class,
        RestaurantPageRoute::class,
        SupportRoutes::class,

<?
include(CORE_PATH . 'marketplace/router.php');
 

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