35 restaurants in the area

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

    }
 
    /**
     * Returns the cached object, if it {@link BaseClass::SHOULD_BE_CACHED} and valid, given the $id.
     * @param $id
     * @return false|static
     */
    protected function cacheGet($id) {
        if (static::SHOULD_BE_CACHED && $id > 0 && $cache = Cache::GetObject($this->getCacheKey($id))) {
            return $cache;
        }
        return false;
    }
 
    /**
     * Caches the current object, if {@link BaseClass::SHOULD_BE_CACHED}.
     */
    protected function cacheSet() {
        if (static::SHOULD_BE_CACHED && $this->id > 0) {
            Cache::SetObject($this->getCacheKey(), $this, static::CACHE_EXPIRATION);
        }
    }
 
    /**
     * Removes the current object from cache, if {@link BaseClass::SHOULD_BE_CACHED}.
     */
    public function cacheDelete() {
        if (static::SHOULD_BE_CACHED && $this->id > 0) {
            Cache::Delete($this->getCacheKey());
        }
    }
 
    /**
     * Removes all objects from cache, if {@link BaseClass::SHOULD_BE_CACHED}.
     */
    public static function cacheDeleteAll($chunkSize = self::CACHE_DELETE_CHUNK_SIZE) {
        if (static::SHOULD_BE_CACHED) {
            static::chunk($chunkSize, function ($chunk) {
                foreach ($chunk as $row) {
                    $row->cacheDelete();

     * @param int|int[] $id
     * @param array $columns
     * @return static|Collection|static[]|null
     * @todo why isn't this protected?
     * @fixme side-effect of this workaround: the cache is silently skipped when running query-modifiers like ResellerUser::withoutGlobalScope('main_resellers')->find(123)
     */
    public function findNew($id, $columns = ['*']) {
        if (is_array($id)) {
            return $this->directFind($id, $columns);
        }
 
        if ($cached = $this->cacheGet($id)) {
            return $cached;
        }
 
        /** @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 */

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

const ONLINE_ORDERING_BYPASS_MESSAGE = 'Online ordering currently is disabled for customers. Only logged-in employees can currently complete checkouts.';
 
/** Makes {@link isOrderingClosed} return a message saying ordering is not currently available. */
const CLOSED_MSG_RESTAURANT = 'RESTAURANT';
 
/**
 * Verifies through Restaurant, Reseller and Global Status setting if it should be able to order in the current session.
 * @param string $defaultMsg Will return this if no "close message" is found and ordering is closed.
 *                           You can also use the {@link CLOSED_MSG_RESTAURANT} flag, which will return a message
 *                           telling the customer ordering is not currently available.
 * @param bool $skipLoginCheck skips login check to determine whether or not ordering is disabled regardless of session.
 * @return string|bool If a "close message" is set, will return it. Otherwise, returns the given parameter or true if
 * none is found. Finally, false in case ordering is available.
 */
function isOrderingClosed($defaultMsg = null, $returnClosedUntilTime = false, $skipLoginCheck = false) {
    global $restaurant, $global_reseller;
    $notif_options = is_object($restaurant)? (int)$restaurant->order_sending_methods : 0; //forcing to int is enough to type-cast the second parameter
 
    //main system status
    $system = AccessStatus::getStatus();
    if ($system->is_ordering_closed || $notif_options & $system->is_notif_closed) {
        $result = $system->close_message;
    } elseif (is_object($global_reseller) && (
            $global_reseller->is_ordering_closed || $notif_options & $global_reseller->is_notif_closed
        )) {
        //reseller-forced closure
        $result = $global_reseller->close_message;
    } elseif (is_object($restaurant) && !isLoggedAsCustomerAdmin() && $restaurant->getPublicOrderingIsClosed()) {
        //allows entry of account managers only, if the restaurant is closed
        $result = true;
    }
 
    if (isset($result)) {
        if (is_string($result) && strlen(trim($result))) {
            return $returnClosedUntilTime ? 'Indefinitely' : $result;
        }
        if ($defaultMsg == CLOSED_MSG_RESTAURANT && is_object($restaurant)) {
            if ($restaurant->getPublicOrderingIsClosedForever()) {
                return $returnClosedUntilTime ? 'Indefinitely' : 'Online ordering is not currently offered at this location.';
            }

    public static function openStatus($attrs, \Cart $cart, \Restaurant $restaurant, $showHoursIfOpen = false, $showHoursIfClosed = false, $fillStatusIfOpen = false) {
        $hoursInfos = $restaurant->getTodaysHoursInfo();
        $earliestOpen = $hoursInfos['earliestOpen'];
 
        $isOpen = false;
        $opensSoon = false;
        $opensSoonKey = 'restaurant_status_opens_soon_' . $restaurant->id;
        $openUntilKey = 'restaurant_status_open_until_' . $restaurant->id;
        $closedUntilKey = 'restaurant_status_closed_until_' . $restaurant->id;
        $orderingClosedUntilKey = 'restaurant_status_ordering_closed_until_' . $restaurant->id;
        if (\Cache::Get($opensSoonKey) && \Cache::Get($opensSoonKey) >= $restaurant->getLocalTime()) {
            $opensSoon = true;
            $nextOpenTime = \Cache::Get($opensSoonKey);
        } elseif (\Cache::Get($openUntilKey) && \Cache::Get($openUntilKey) >= $restaurant->getLocalTime()) {
            $isOpen = true;
        } elseif (\Cache::Get($closedUntilKey) && \Cache::Get($closedUntilKey) >= $restaurant->getLocalTime()) {
            //closed
            $nextOpenTime = \Cache::Get($closedUntilKey);
        } else {
            $isOrderingClosed = isOrderingClosed(CLOSED_MSG_RESTAURANT);
            $orderingClosedUntil = isOrderingClosed(CLOSED_MSG_RESTAURANT, true);
            $orderingClosedUntilTimestamp = is_numeric($orderingClosedUntil)? $orderingClosedUntil : false;
            $isOpen = !$isOrderingClosed && ($restaurant->pickupAvailableNow() || $restaurant->deliveryAvailableNow());
            if ($restaurant->getPublicOrderingClosedUntil()) {
                $orderingClosedUntil = $restaurant->getLocalPublicOrderingClosedUntilText(true);
                $closedUntilTimestamp = is_numeric($orderingClosedUntil)? $orderingClosedUntil : false;
                $hasAvailableDays =
                    $restaurant->hasAvailableDays($restaurant->getLocalTime(), $cart->getBaseOrderType());
                if ($hasAvailableDays) {
                    $nextOpenTime = $cart->getNextOpenTimeForAnyType($restaurant, $closedUntilTimestamp);
                    if (date('giA', $nextOpenTime) > date('giA', $earliestOpen)) {
                        $earliestOpen = $nextOpenTime;
                    }
                } else {
                    $orderingClosedUntil = 'Indefinitely';
                    $nextOpenTime = strtotime('+100 years');
                }
            } else {
                $nextOpenTime = $cart->getNextOpenTimeForAnyType($restaurant, $orderingClosedUntilTimestamp);
            }

        ob_start();
        ?>
 
        <div class="restaurant_card d-flex flex-column flex-md-row <?=$props['class']?>" <?=\EDS\stringify_attrs(\EDS\omit($attrs, array_keys($props)))?>>
            <?=\EDS\Restaurant::image(
                ['class' => 'restaurant_card-image'],
                $badge ? ('<div class="restaurant_card-badge align-self-start rounded-start mt-3 bg-success ps-2 pe-2p5 py-1 text-white eds-interface-text-s-bold">' . $badge . '</div>') : null,
                $account
            )?>
 
            <div class="p-3 eds-interface-text-m-regular">
                <div class="d-flex gap-2 align-items-baseline">
                    <? // Display name ?>
                    <div>
                        <div class="restaurant_card-title eds-display-text-title-xs flex-fill"><?=$restaurant->display_name?></div>
                        <div class="eds-copy-text-s-regular mt-1"><?=$restaurant->getFullAddress(false)?></div>
                    </div>
                </div>
 
                <?=\EDS\Restaurant::openStatus(['class' => 'mt-1'], $cart, $restaurant, false, true, true)?>
 
                <div class="d-flex flex-wrap align-items-baseline mt-2" style="--eds-bullet-spacing-before: 0.5rem">
                    <span class="bullet-separated"><?=$distance?></span>
                    <?=\EDS\Restaurant::rating(['class' => 'bullet-separated'], $restaurant)?>
                    <?=\EDS\Restaurant::priceRange(['class' => 'bullet-separated'], $restaurant)?>
                    <? if (\RAHCampaign::isActiveForRestaurant($restaurant)) { ?>
                        <div class="bullet-separated"><?=\RAHCampaign::badge()?></div>
                    <? } ?>
                </div>
 
                <? if ($is_open) { // Order types ?>
                    <div class="d-flex align-items-baseline eds-copy-text-s-bold mt-2">
                        <?=\EDS\Icon(['icon' => 'utensils-alt', 'variant' => 'solid', 'class' => 'me-1 text-light'])?>
 
                        <? if ($restaurant->getHasPickupBase()) { ?>
                            <span class="comma-separated"><?=PICKUP_LABEL?></span>
                        <? } ?>
 
                        <? if ($restaurant->getHasDeliveryBase()) { ?>
                            <span class="comma-separated"><?=DELIVERY_LABEL?></span>

                                        max-height: none !important;
                                    }
                                }
 
                            </style>
 
                            <div id="filtered-restaurants" class="d-flex flex-column gap-3 mt-3">
                                <? if (!$filtered_restaurants) { ?>
                                    No restaurants match your search.
                                <? } ?>
 
                                <? foreach ($filtered_restaurants as $restaurant) {
                                    $GLOBALS['account'] = new \Account($restaurant->account_id); // Unfortunately needed for `formatCustomerOrderLink`
                                    ?>
                                    <?=\EDS\html('a', [
                                        'id' => 'restaurant_' . $restaurant->id,
                                        'class' => 'overflow-hidden rounded-2 border bg-white text-dark text-decoration-none',
                                        'href' => formatCustomerOrderLink([$restaurant]),
                                        'onclick' => static::confirmNewCart($cart, $restaurant),
                                    ], static::card($cart, $restaurant))?>
                                <? } ?>
                            </div>
                        </div>
                    </div>
                <? } else { ?>
                    <?=static::states()?>
                <? } ?>
            </div>
            <?=\EDS\Dialog(['id' => 'modal-map-restaurant', 'size' => 'medium', 'fullscreen' => false])?>
        </section>
        <?
 
        if ($nearMeCuisine && !$map_is_shown) {
            echo static::nearMeJs();
        }
 
        if (count($url_params) > 0) { // sc-60709: use canonical url and noindex for restaurant searches
            \EDS\Portal::input('canonical_url', $canonicalUrl);
            \EDS\Portal::input('meta-robots', 'noindex');
        }

        }
 
        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)
        );
        $city_name = $state_name && in_array($city, $states[$state_name]) ? $city : null;
 
        return ['state' => $state_name, 'city' => $city_name];
    }
 
    // Components

     * ```
     *
     * @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");