* @param string $path
* @param string $contents
* @param bool $lock
* @return int
*/
public function put($path, $contents, $lock = false)
{
return file_put_contents($path, $contents, $lock ? LOCK_EX : 0);
}
* @param string $path
* @param string $contents
* @param bool $lock
* @return int
*/
public function put($path, $contents, $lock = false)
{
return file_put_contents($path, $contents, $lock ? LOCK_EX : 0);
}
*/
public function put($key, $value, $minutes)
{
$value = $this->expiration($minutes).serialize($value);
$this->createCacheDirectory($path = $this->path($key));
$this->files->put($path, $value);
}
*/
public function put($key, $value, $minutes)
{
$minutes = $this->getMinutes($minutes);
if ( ! is_null($minutes))
{
$this->store->put($key, $value, $minutes);
}
}
*
* @param string $method
* @param array $parameters
* @return mixed
*/
public function __call($method, $parameters)
{
return call_user_func_array(array($this->driver(), $method), $parameters);
}
case 1:
return $instance->$method($args[0]);
case 2:
return $instance->$method($args[0], $args[1]);
case 3:
return $instance->$method($args[0], $args[1], $args[2]);
case 4:
case 1:
return $instance->$method($args[0]);
case 2:
return $instance->$method($args[0], $args[1]);
case 3:
return $instance->$method($args[0], $args[1], $args[2]);
case 4:
}
if (!$access) unset($this->modules[$id]);
}
}
Cache::put('modules', $this->modules, 240);
return $this->modules;
}
if (!$access) unset($this->modules[$id]);
}
}
Cache::put('modules', $this->modules, 240);
return $this->modules;
public static function __callStatic($method, $args)
{
$instance = static::getFacadeRoot();
switch (count($args))
{
case 0:
return $instance->$method();
case 1:
{
$this->settings = App::make("fluid-mod-setting");
$this->settings->populate();
}
$this->widgetManager = App::make("fluid-core::widget-manager");
$modules = ModuleManager::populate();
$extensions = ExtensionManager::populate();
{
$this->settings = App::make("fluid-mod-setting");
$this->settings->populate();
}
$this->widgetManager = App::make("fluid-core::widget-manager");
$modules = ModuleManager::populate();
$extensions = ExtensionManager::populate();
View::share("cleanInput", $cleanInput);
View::share("isBot", $is_bot);
$this->page = App::make("fluid-core::page", $url);
if (empty($this->page->page)) $this->page->page = App::make("fluid-mod-page")->first();
$this->populateGlobals();
Route::filter('page.init', 'PageController@init');
return new \Fortyfour\FluidCore\Cms\Classes\WidgetManager;
});
App::singleton('fluid-core::site', function($init=true) {
$site = new \Fortyfour\FluidCore\Controllers\SiteController;
if ($init) $site->init();
return $site;
public function build($concrete, $parameters = array())
{
// If the concrete type is actually a Closure, we will just execute it and
// hand back the results of the functions, which allows functions to be
// used as resolvers for more fine-tuned resolution of these objects.
if ($concrete instanceof Closure)
{
return $concrete($this, $parameters);
}
$concrete = $this->getConcrete($abstract);
// We're ready to instantiate an instance of the concrete type registered for
// the binding. This will instantiate the types, as well as resolve any of
// its "nested" dependencies recursively until all have gotten resolved.
if ($this->isBuildable($concrete, $abstract))
{
$object = $this->build($concrete, $parameters);
}
else
$abstract = $this->getAlias($abstract);
if (isset($this->deferredServices[$abstract]))
{
$this->loadDeferredProvider($abstract);
}
return parent::make($abstract, $parameters);
}
case 0:
return $instance->$method();
case 1:
return $instance->$method($args[0]);
case 2:
return $instance->$method($args[0], $args[1]);
case 3:
App::singleton('fluid-cart', function() {
return new Cart;
});
App::make("fluid-core::site", false);
App::make("fluid-core::auth");
App::make("fluid-core::admin");
App::singleton('fluid-cart', function() {
return new Cart;
});
App::make("fluid-core::site", false);
App::make("fluid-core::auth");
App::make("fluid-core::admin");
// payload to each of them so that they receive each of these arguments.
if ( ! is_array($payload)) $payload = array($payload);
$this->firing[] = $event;
foreach ($this->getListeners($event) as $listener)
{
$response = call_user_func_array($listener, $payload);
// If a response is returned from the listener and event halting is enabled
*
* @param string $event
* @param array $payload
* @return mixed
*/
public function until($event, $payload = array())
{
return $this->fire($event, $payload, true);
}
* @param \Illuminate\Http\Response $response
* @return mixed
*/
protected function callFilter($filter, $request, $response = null)
{
if ( ! $this->filtering) return null;
return $this->events->until('router.'.$filter, array($request, $response));
}
public function dispatch(Request $request)
{
$this->currentRequest = $request;
// If no response was returned from the before filter, we will call the proper
// route instance to get the response. If no route is found a response will
// still get returned based on why no routes were found for this request.
$response = $this->callFilter('before', $request);
if (is_null($response))
}
if ($this->runningUnitTests() && ! $this['session']->isStarted())
{
$this['session']->start();
}
return $this['router']->dispatch($this->prepareRequest($request));
}
{
try
{
$this->refreshRequest($request = Request::createFromBase($request));
$this->boot();
return $this->dispatch($request);
}
catch (\Exception $e)
if ($this->sessionConfigured())
{
$session = $this->startSession($request);
$request->setSession($session);
}
$response = $this->app->handle($request, $type, $catch);
// Again, if the session has been configured we will need to close out the session
* @param \Symfony\Component\HttpFoundation\Request $request
* @param int $type
* @param bool $catch
* @return \Symfony\Component\HttpFoundation\Response
*/
public function handle(Request $request, $type = HttpKernelInterface::MASTER_REQUEST, $catch = true)
{
$response = $this->app->handle($request, $type, $catch);
foreach ($this->cookies->getQueuedCookies() as $cookie)
* @param \Symfony\Component\HttpFoundation\Request $request
* @param int $type
* @param bool $catch
* @return \Symfony\Component\HttpFoundation\Response
*/
public function handle(Request $request, $type = HttpKernelInterface::MASTER_REQUEST, $catch = true)
{
return $this->encrypt($this->app->handle($this->decrypt($request), $type, $catch));
}
{
$this->app = $app;
$this->middlewares = $middlewares;
}
public function handle(Request $request, $type = HttpKernelInterface::MASTER_REQUEST, $catch = true)
{
return $this->app->handle($request, $type, $catch);
}
* @param \Symfony\Component\HttpFoundation\Request $request
* @return void
*/
public function run(SymfonyRequest $request = null)
{
$request = $request ?: $this['request'];
$response = with($stack = $this->getStackedClient())->handle($request);
$response->send();
|--------------------------------------------------------------------------
|
| Execute the request and send the response back to the client.
|
*/
$app->run();