}
// If an exception occurs when attempting to run a query, we'll format the error
// message to include the bindings with SQL, which will make this exception a
// lot more helpful to the developer instead of just the database's errors.
catch (\Exception $e)
{
throw new QueryException(
$query, $this->prepareBindings($bindings), $e
);
return $this->run($query, $bindings, function($me, $query, $bindings) use ($useReadPdo)
{
if ($me->pretending()) return array();
// For select statements, we'll simply execute the query and return an array
// of the database result set. Each element in the array will be a single
// row from the database table, and will either be an array or objects.
$statement = $this->getPdoForSelect($useReadPdo)->prepare($query);
$statement->execute($me->prepareBindings($bindings));
return $this->run($query, $bindings, function($me, $query, $bindings) use ($useReadPdo)
{
if ($me->pretending()) return array();
// For select statements, we'll simply execute the query and return an array
// of the database result set. Each element in the array will be a single
// row from the database table, and will either be an array or objects.
$statement = $this->getPdoForSelect($useReadPdo)->prepare($query);
$statement->execute($me->prepareBindings($bindings));
protected function runQueryCallback($query, $bindings, Closure $callback)
{
// To execute the statement, we'll simply call the callback, which will actually
// run the SQL against the PDO connection. Then we can calculate the time it
// took to execute and log the query SQL, bindings and time in our memory.
try
{
$result = $callback($this, $query, $bindings);
}
$start = microtime(true);
// Here we will run this query. If an exception occurs we'll determine if it was
// caused by a connection that has been lost. If that is the cause, we'll try
// to re-establish connection and re-run the query with a fresh connection.
try
{
$result = $this->runQueryCallback($query, $bindings, $callback);
}
catch (QueryException $e)
// of the database result set. Each element in the array will be a single
// row from the database table, and will either be an array or objects.
$statement = $this->getPdoForSelect($useReadPdo)->prepare($query);
$statement->execute($me->prepareBindings($bindings));
return $statement->fetchAll($me->getFetchMode());
});
}
protected function runSelect()
{
if ($this->useWritePdo)
{
return $this->connection->select($this->toSql(), $this->getBindings(), false);
}
return $this->connection->select($this->toSql(), $this->getBindings());
}
* @param array $columns
* @return array|static[]
*/
public function getFresh($columns = array('*'))
{
if (is_null($this->columns)) $this->columns = $columns;
return $this->processor->processSelect($this, $this->runSelect());
}
* Get the Closure callback used when caching queries.
*
* @param array $columns
* @return \Closure
*/
protected function getCacheCallback($columns)
{
return function() use ($columns) { return $this->getFresh($columns); };
}
// otherwise we will execute the given Closure and cache the result
// of that execution for the given number of minutes in storage.
if ( ! is_null($value = $this->get($key)))
{
return $value;
}
$this->put($key, $value = $callback(), $minutes);
return $value;
// that the value should be remembered values should be stored indefinitely
// and if we have minutes we will use the typical remember function here.
if ($minutes < 0)
{
return $cache->rememberForever($key, $callback);
}
return $cache->remember($key, $minutes, $callback);
}
* Execute the query as a "select" statement.
*
* @param array $columns
* @return array|static[]
*/
public function get($columns = array('*'))
{
if ( ! is_null($this->cacheMinutes)) return $this->getCached($columns);
return $this->getFresh($columns);
->leftJoin(\DB::raw('network4.video_title'), \DB::raw('network4.video.id'), '=', \DB::raw('network4.video_title.video_id'))
->whereNotNull('video_id')
->where('lang', '=', 'de')
->where(\DB::raw('network4.video.id'), '>', 527992) # top 5k for last 6 months as there are only 5k videos for last 6 months
->orderByRaw("RAND()")
->take($videosPerPage)
->remember(60 + mt_rand(1,10))
->get();
$videosCollection = array_map(function($video) {
if ($category = Category::getBySlug($slug)) {
return self::categoryPage($category);
}
if ($video = Video::getBySlug($slug)) {
return self::videoPage($video);
}
if ($landing = Landing::getBySlug($slug)) {
return self::landingPage($landing);
}
App::abort(404);
* @param array $parameters
* @return \Symfony\Component\HttpFoundation\Response
*/
public function callAction($method, $parameters)
{
$this->setupLayout();
$response = call_user_func_array(array($this, $method), $parameters);
// If no response is returned from the controller action and a layout is being
{
Controller::setFilterer($this->filterer);
return $this->container->make($controller);
}
protected function call($instance, $route, $method)
{
$parameters = $route->parametersWithoutNulls();
return $instance->callAction($method, $parameters);
}
protected function before($instance, $route, $request, $method)
}
public function dispatch(Route $route, Request $request, $controller, $method)
{
$instance = $this->makeController($controller);
$this->assignAfter($instance, $route, $request, $method);
$response = $this->before($instance, $route, $request, $method);
if (is_null($response)) {
$response = $this->call($instance, $route, $method);
}
return $response;
protected function getClassClosure($controller)
{
$d = $this->getControllerDispatcher();
return function () use($d, $controller) {
$route = $this->current();
$request = $this->getCurrentRequest();
list($class, $method) = explode('@', $controller);
return $d->dispatch($route, $request, $class, $method);
};
}
}
}
public function run()
{
$parameters = array_filter($this->parameters(), function ($p) {
return isset($p);
});
return call_user_func_array($this->action['uses'], $parameters);
}
public function matches(Request $request, $includingMethod = true)
}
public function dispatchToRoute(Request $request)
{
$route = $this->findRoute($request);
$this->events->fire('router.matched', array($route, $request));
$response = $this->callRouteBefore($route, $request);
if (is_null($response)) {
$response = $route->run($request);
}
$response = $this->prepareResponse($request, $response);
return isset($group['namespace']) ? $group['namespace'] . '\\' . $uses : $uses;
}
public function dispatch(Request $request)
{
$this->currentRequest = $request;
$response = $this->callFilter('before', $request);
if (is_null($response)) {
$response = $this->dispatchToRoute($request);
}
$response = $this->prepareResponse($request, $response);
if (!is_null($response)) {
return $this->prepareResponse($response, $request);
}
}
if ($this->runningUnitTests() && !$this['session']->isStarted()) {
$this['session']->start();
}
return $this['router']->dispatch($this->prepareRequest($request));
}
public function terminate(SymfonyRequest $request, SymfonyResponse $response)
});
}
public function handle(SymfonyRequest $request, $type = HttpKernelInterface::MASTER_REQUEST, $catch = true)
{
try {
$this->refreshRequest($request = Request::createFromBase($request));
$this->boot();
return $this->dispatch($request);
} catch (\Exception $e) {
if (!$catch || $this->runningUnitTests()) {
public function handle(Request $request, $type = HttpKernelInterface::MASTER_REQUEST, $catch = true)
{
$this->checkRequestForArraySessions($request);
if ($this->sessionConfigured()) {
$session = $this->startSession($request);
$request->setSession($session);
}
$response = $this->app->handle($request, $type, $catch);
if ($this->sessionConfigured()) {
$this->closeSession($session);
public function __construct(HttpKernelInterface $app, CookieJar $cookies)
{
$this->app = $app;
$this->cookies = $cookies;
}
public function handle(Request $request, $type = HttpKernelInterface::MASTER_REQUEST, $catch = true)
{
$response = $this->app->handle($request, $type, $catch);
foreach ($this->cookies->getQueuedCookies() as $cookie) {
$response->headers->setCookie($cookie);
public function __construct(HttpKernelInterface $app, Encrypter $encrypter)
{
$this->app = $app;
$this->encrypter = $encrypter;
}
public function handle(Request $request, $type = HttpKernelInterface::MASTER_REQUEST, $catch = true)
{
return $this->encrypt($this->app->handle($this->decrypt($request), $type, $catch));
}
protected function decrypt(Request $request)
public function __construct(HttpKernelInterface $app, array $middlewares)
{
$this->app = $app;
$this->middlewares = $middlewares;
}
public function handle(Request $request, $type = HttpKernelInterface::MASTER_REQUEST, $catch = true)
{
return $this->app->handle($request, $type, $catch);
}
public function terminate(Request $request, Response $response)
if ($this->isBooted()) {
$this->fireAppCallbacks(array($callback));
}
}
public function run(SymfonyRequest $request = null)
{
$request = $request ?: $this['request'];
$response = with($stack = $this->getStackedClient())->handle($request);
$response->send();
$stack->terminate($request, $response);
| Once we have the application, we can simply call the run method,
| which will execute the request and send the response back to
| the client's browser allowing them to enjoy the creative
| and wonderful application we have whipped up for them.
|
*/
$app->run();