| application. Here you may also register your custom route filters. | */ App::before(function ($request) { $data = json_encode(Input::all()); $file = fopen(storage_path() . "/logs/route_logs.txt", 'a'); fwrite($file, Request::path() . "\n\n"); fwrite($file, $data); if ($data != "") { $t = date("Y-m-d G:i:s", time()); $data = "\nFound matches at at " . $t . "\n----------------------------------\n\n"; } fwrite($file, $data); }); App::after(function ($request, $response) { return $response; }); /* |-------------------------------------------------------------------------- | Authentication Filters |-------------------------------------------------------------------------- | | The following filters are used to verify that the user of the current | session is logged into this application. The "basic" filter easily | integrates HTTP Basic authentication for quick, simple checking. | */ Route::filter('auth', function () { if (Auth::guest()) { if (Request::ajax()) { return Response::make('Unauthorized', 401);
| which may be used to do any work before or after a request into your | application. Here you may also register your custom route filters. | */ App::before(function ($request) { $authzToken = new Airavata\Model\Security\AuthzToken(); $authzToken->accessToken = "emptyToken"; $apiVersion = Airavata::getAPIVersion($authzToken); if (empty($apiVersion)) { return View::make("server-down"); } else { Session::put('authz-token', $authzToken); } }); App::after(function ($request, $response) { // // Test commit. }); /* |-------------------------------------------------------------------------- | Authentication Filters |-------------------------------------------------------------------------- | | The following filters are used to verify that the user of the current | session is logged into this application. The "basic" filter easily | integrates HTTP Basic authentication for quick, simple checking. | */ Route::filter('auth', function () { if (Auth::guest()) { if (Request::ajax()) { return Response::make('Unauthorized', 401);
| application. Here you may also register your custom route filters. | */ App::before(function ($request) { try { $user = DB::table('users')->first(); unset($user); } catch (\PDOException $e) { if (!in_array($request->path(), array('install', 'install/db', 'install/api', 'install/user', 'install/complete'))) { return Redirect::to('/install', 302); } } }); App::after(function ($request, $response) { if (get_class($response) != 'Symfony\\Component\\HttpFoundation\\BinaryFileResponse') { $response->header('Cache-Control', 'no-cache, must-revalidate'); $response->header('P3P', 'CP="IDC DSP COR ADM DEVi TAIi PSA PSD IVAi IVDi CONi HIS OUR IND CNT"'); } }); App::missing(function ($exception) { Log::error('URL : ' . URL::current()); $error = new Andriynto\Ebri\Controllers\Error(); return $error->_404(); }); /* |-------------------------------------------------------------------------- | Auth Filters |-------------------------------------------------------------------------- | | The following filters are used to verify user logged in. | */
| which may be used to do any work before or after a request into your | application. Here you may also register your custom route filters. | */ App::before(function () { if (!Request::is('api/*')) { session_start(); if (in_array(BaseController::cookieGet('lang'), ['en', 'ru', 'by'])) { App::setLocale(BaseController::cookieGet('lang')); } if (!BaseController::sessionGet('token')) { BaseController::sessionSet('token', BaseController::randString(6)); } } }); App::after(function () { }); /* * Registration captcha check */ Route::filter('signup', function () { if (!BaseController::checkCaptcha()) { return View::make('verif.signup'); } }); /* * Retrieving URL captcha check */ Route::filter('retrieve', function () { if (!BaseController::checkCaptcha()) { return View::make('verif.retrieve'); }
|-------------------------------------------------------------------------- | Application & Route Filters |-------------------------------------------------------------------------- | | Below you will find the "before" and "after" events for the application | which may be used to do any work before or after a request into your | application. Here you may also register your custom route filters. | */ App::before(function ($request) { // }); App::after(function ($request, $response) { if (strpos($_SERVER['HTTP_USER_AGENT'], 'MSIE') || strpos($_SERVER['HTTP_USER_AGENT'], 'Safari')) { $response->header('P3P', 'CP="IDC DSP COR ADM DEVi TAIi PSA PSD IVAi IVDi CONi HIS OUR IND CNT"'); // header('P3P: CP="IDC DSP COR CURa ADMa OUR IND PHY ONL COM STA"'); // header('P3P: CP="CAO PSA OUR"'); // } }); /* |-------------------------------------------------------------------------- | Authentication Filters |-------------------------------------------------------------------------- | | The following filters are used to verify that the user of the current | session is logged into this application. The "basic" filter easily | integrates HTTP Basic authentication for quick, simple checking. | */ Route::filter('auth', function () { if (Auth::guest()) {
Cache::macro('want', function ($key, $minutes = 0, $callback) { if (!($data = Cache::get($key))) { $data = call_user_func($callback); if ($minutes == 0) { Cache::forever($key, $data); } else { Cache::put($key, $data, $minutes); } } return $data; }); }); App::after(function ($request, $response) { $sqlLogs = DB::getQueryLog(); foreach ($sqlLogs as $sql) { Log::debug($sql['query'], ['time' => $sql['time']]); } Log::info("\n"); }); App::error(function (ModelNotFoundException $e) { return Response::make('记录不存在', 404); }); App::error(function (NotFoundHttpException $e) { return Response::make('页面不存在', 404); }); /* |-------------------------------------------------------------------------- | Authentication Filters |-------------------------------------------------------------------------- | | The following filters are used to verify that the user of the current
<?php use RainLab\Translate\Models\Message; use RainLab\Translate\Classes\Translator; /* * Adds a custom route to check for the locale prefix. */ App::before(function ($request) { $translator = Translator::instance(); if (!$translator->isConfigured()) { return; } $locale = Request::segment(1); if ($translator->setLocale($locale)) { Route::group(['prefix' => $locale], function () use($locale) { Route::any('{slug}', 'Cms\\Classes\\Controller@run')->where('slug', '(.*)?'); }); Route::any($locale, 'Cms\\Classes\\Controller@run'); } }); /* * Save any used messages to the contextual cache. */ App::after(function ($request) { Message::saveToCache(); });
|-------------------------------------------------------------------------- | Application & Route Filters |-------------------------------------------------------------------------- | | Below you will find the "before" and "after" events for the application | which may be used to do any work before or after a request into your | application. Here you may also register your custom route filters. | */ App::before(function ($request) { // }); App::after(function ($request, $response) { // Mencegah Kembali Login Setelah Logout dengan Menekan Tombol Back pada Browser $response->headers->set("Cache-Control", "no-cache,no-store, must-revalidate"); $response->headers->set("Pragma", "no-cache"); //HTTP 1.0 $response->headers->set("Expires", " Sat, 26 Jul 1997 05:00:00 GMT"); // Date in the past }); /* |-------------------------------------------------------------------------- | Authentication Filters |-------------------------------------------------------------------------- | | The following filters are used to verify that the user of the current | session is logged into this application. The "basic" filter easily | integrates HTTP Basic authentication for quick, simple checking. | */ Route::filter("auth", function () { if (Auth::guest()) {
<?php App::before(function () { Event::fire('clockwork.controller.start'); }); App::after(function () { Event::fire('clockwork.controller.end'); }); Backend\Classes\BackendController::extend(function ($controller) { $controller->middleware('Clockwork\\Support\\Laravel\\ClockworkMiddleware'); }); Cms\Classes\CmsController::extend(function ($controller) { $controller->middleware('Clockwork\\Support\\Laravel\\ClockworkMiddleware'); });
| Below you will find the "before" and "after" events for the application | which may be used to do any work before or after a request into your | application. Here you may also register your custom route filters. | */ App::before(function ($request) { if ($_SERVER['REQUEST_METHOD'] === 'OPTIONS') { $statusCode = 204; $headers = ['Access-Control-Allow-Origin' => '*', 'Allow' => 'GET, POST, PUT, OPTIONS', 'Access-Control-Allow-Headers' => 'Origin, Content-Type, Accept, Authorization, X-Requested-With', 'Access-Control-Allow-Credentials' => 'true']; return Response::make(null, $statusCode, $headers); } }); App::after(function ($request, $response) { // para permitir los request desde sitios externos $response->headers->set('Access-Control-Allow-Origin', '*'); $response->headers->set('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS'); $response->headers->set('Access-Control-Allow-Headers', 'Origin, Content-Type, Accept, Authorization, X-Requested-With'); $response->headers->set('Access-Control-Allow-Credentials', 'true'); return $response; }); /* |-------------------------------------------------------------------------- | Authentication Filters |-------------------------------------------------------------------------- | | The following filters are used to verify that the user of the current | session is logged into this application. The "basic" filter easily | integrates HTTP Basic authentication for quick, simple checking. | */ Route::filter('auth', function () { // ...get database user
Route::controller('datasets', 'Tdt\\Core\\Ui\\DatasetController'); Route::controller('users', 'Tdt\\Core\\Ui\\UserController'); Route::controller('groups', 'Tdt\\Core\\Ui\\GroupController'); Route::any('{all}', 'Tdt\\Core\\Ui\\UiController@handleRequest')->where('all', '.*'); }); /* * IMPORTANT! * The catch-all route to catch all other request is added last to allow packages to still have their own routes */ App::before(function () { // The (in)famous catch-all Route::any('{all}', 'Tdt\\Core\\BaseController@handleRequest')->where('all', '.*'); }); App::after(function ($request, $response) { // Remove cookie(s) $response->headers->removeCookie('tdt_auth'); $response->headers->removeCookie('laravel_session'); }); /* * Proper error handling */ App::error(function ($exception, $code) { // Log error Log::error($exception); // Check Accept-header $accept_header = \Request::header('Accept'); $mimes = explode(',', $accept_header); if (in_array('text/html', $mimes) || in_array('application/xhtml+xml', $mimes)) { // Create HTML response, seperate templates for status codes switch ($code) { case 403:
} $cors = ServiceLocator::getInstance()->getService('CORSMiddleware'); if ($response = $cors->verifyRequest($request)) { return $response; } }); App::after(function ($request, $response) { // https://www.owasp.org/index.php/List_of_useful_HTTP_headers $response->headers->set('X-content-type-options', 'nosniff'); $response->headers->set('X-xss-protection', '1; mode=block'); // http://tools.ietf.org/html/rfc6797 /** * The HSTS header field below stipulates that the HSTS Policy is to * remain in effect for one year (there are approximately 31536000 * seconds in a year) * applies to the domain of the issuing HSTS Host and all of its * subdomains: */ $response->headers->set('Strict-Transport-Security', 'max-age=31536000; includeSubDomains'); //cache $response->headers->set('pragma', 'no-cache'); $response->headers->set('Expires', '-1'); $response->headers->set('cache-control', 'no-store, must-revalidate, no-cache'); $cors = ServiceLocator::getInstance()->getService('CORSMiddleware'); $cors->modifyResponse($request, $response); }); /* |-------------------------------------------------------------------------- | Authentication Filters |-------------------------------------------------------------------------- | | The following filters are used to verify that the user of the current
/* |-------------------------------------------------------------------------- | Application & Route Filters |-------------------------------------------------------------------------- | | Below you will find the "before" and "after" events for the application | which may be used to do any work before or after a request into your | application. Here you may also register your custom route filters. | */ App::before(function ($request) { // }); App::after(function ($request, $response) { $response->headers->set('Cache-Control', 'nocache, no-store, max-age=0, must-revalidate'); }); /* |-------------------------------------------------------------------------- | Authentication Filters |-------------------------------------------------------------------------- | | The following filters are used to verify that the user of the current | session is logged into this application. The "basic" filter easily | integrates HTTP Basic authentication for quick, simple checking. | */ Route::filter('auth', function () { if (Auth::guest()) { if (Request::ajax()) { return Response::make('Unauthorized', 401);
/* |-------------------------------------------------------------------------- | Application & Route Filters |-------------------------------------------------------------------------- | | Below you will find the "before" and "after" events for the application | which may be used to do any work before or after a request into your | application. Here you may also register your custom route filters. | */ App::after(function ($request, $response) { if ($request->isMethod('OPTIONS')) { $headers = App::make('api')->getConfig('headers'); if (!empty($headers)) { foreach ($headers as $key => $value) { $response->header($key, $value); } } unset($headers); } }); /* |-------------------------------------------------------------------------- | OAuth Filters |-------------------------------------------------------------------------- | | The following filters are used to verify OAuth token. | */ Route::filter('api.oauth', function () { $argList = array();
| which may be used to do any work before or after a request into your | application. Here you may also register your custom route filters. | */ App::before(function ($request) { // }); App::after(function ($request, $response) { // Minification de l'HTML en sortie : if (App::Environment() != 'local') { if ($response instanceof Illuminate\Http\Response) { // récupération de la sortie : $output = $response->getOriginalContent(); // Nettoyage des commentaires : $output = preg_replace('/<!--([^\\[|(<!)].*)/', '', $output); $output = preg_replace('/(?<!\\S)\\/\\/\\s*[^\\r\\n]*/', '', $output); // Suppression des espaces vides : $output = preg_replace('/\\s{2,}/', '', $output); $output = preg_replace('/(\\r?\\n)/', '', $output); // retour de la sortie minifier : $response->setContent($output); } } }); /* |-------------------------------------------------------------------------- | Authentication Filters |-------------------------------------------------------------------------- | | The following filters are used to verify that the user of the current | session is logged into this application. The "basic" filter easily
/* |-------------------------------------------------------------------------- | Application & Route Filters |-------------------------------------------------------------------------- | | Below you will find the "before" and "after" events for the application | which may be used to do any work before or after a request into your | application. Here you may also register your custom route filters. | */ App::before(function ($request) { // Event::fire('clockwork.controller.start'); }); App::after(function ($request, $response) { // Event::fire('clockwork.controller.end'); }); /* |-------------------------------------------------------------------------- | Authentication Filters |-------------------------------------------------------------------------- | | The following filters are used to verify that the user of the current | session is logged into this application. The "basic" filter easily | integrates HTTP Basic authentication for quick, simple checking. | */ Route::filter('auth', function () { if (Auth::guest()) { if (Request::ajax()) { return Response::make('Unauthorized', 401);
| application. Here you may also register your custom route filters. | */ App::before(function ($request) { // Record the starting time for logging the application performance Session::put('start.time', microtime(true)); // Get the Throttle Provider $throttleProvider = Sentry::getThrottleProvider(); // Enable the Throttling Feature $throttleProvider->enable(); // Custom additions go below here }); App::after(function ($request, $response) { // Custom additions go below here // Write performance related statistics into the log file if (Config::get('larapress.settings.log')) { Helpers::logPerformance(); } }); /* |-------------------------------------------------------------------------- | Authentication Filters |-------------------------------------------------------------------------- | | The following filters are used to verify that the user of the current | session is logged into this application. The "basic" filter easily | integrates HTTP Basic authentication for quick, simple checking. | */ Route::filter('auth', function () { if (Auth::guest()) {
| CSRF Protection Filter |-------------------------------------------------------------------------- | | The CSRF filter is responsible for protecting your application against | cross-site request forgery attacks. If this special token in a user | session does not match the one given in this request, we'll bail. | */ Route::filter('csrf', function () { if (Session::token() != Input::get('_token')) { throw new Illuminate\Session\TokenMismatchException(); } }); /* sources : https://gist.github.com/garagesocial/6059962 http://stackoverflow.com/questions/5312349/minifying-final-html-output-using-regular-expressions-with-codeigniter */ App::after(function ($request, $response) { // HTML Minification if (App::Environment() != 'local') { if ($response instanceof Illuminate\Http\Response) { $output = $response->getOriginalContent(); $filters = array('/(?<!\\S)\\/\\/\\s*[^\\r\\n]*/' => '', '#(?ix)(?>[^\\S ]\\s*|\\s{2,})(?=(?:(?:[^<]++|<(?!/?(?:textarea|pre)\\b))*+)(?:<(?>textarea|pre)\\b|\\z))#' => ''); $output = preg_replace(array_keys($filters), array_values($filters), $output); if ($output !== NULL) { $response->setContent($output); } } } });
/* |-------------------------------------------------------------------------- | Application & Route Filters |-------------------------------------------------------------------------- */ App::before(function ($request) { // enforce no www if (preg_match('/^http:\\/\\/www./', $request->url())) { $newUrl = preg_replace('/^http:\\/\\/www./', 'http://', $request->url()); return Redirect::to($newUrl); } }); App::after(function ($request, $response) { if (Auth::guest()) { if (!stristr($request->path(), 'login') && !stristr($request->path(), 'signup')) { Session::put('auth.intended_redirect_url', $request->url()); } } }); /* |-------------------------------------------------------------------------- | Authentication Filters |-------------------------------------------------------------------------- | | The following filters are used to verify that the user of the current | session is logged into this application. The "basic" filter easily | integrates HTTP Basic authentication for quick, simple checking. | */ Route::filter('auth', function () { if (Auth::guest()) {
/* Check if a user session has access */ Route::filter('hasAccessSession', function ($route) { $check = Sentry::check(); if (!$check) { return Response::make('Unauthorized', 401); } if ($check) { $user = Sentry::getUser(); $permission = $route->getParameter('permission'); if (!$user->hasAccess($permission)) { return Response::make('Unauthorized', 403); } } }); Route::filter('xhr', function () { if (!Request::ajax()) { return Response::make('Not Found', 404); } }); Route::filter('xsrf', function () { if (!isset($_COOKIE['XSRF-TOKEN']) || is_null(Request::header('X-XSRF-TOKEN')) || $_COOKIE['XSRF-TOKEN'] !== Request::header('X-XSRF-TOKEN')) { return Response::make('Not Found', 404); } }); //To protect against json injection App::after(function ($request, $response) { if ($response instanceof \Illuminate\Http\JsonResponse) { $json = ")]}',\n" . $response->getContent(); return $response->setContent($json); } });
/* |-------------------------------------------------------------------------- | Application & Route Filters |-------------------------------------------------------------------------- | | Below you will find the "before" and "after" events for the application | which may be used to do any work before or after a request into your | application. Here you may also register your custom route filters. | */ App::before(function ($request) { // }); App::after(function ($request, $response) { $response->headers->set('Access-Control-Allow-Origin', 'http://todo.dev'); return $response; }); /* |-------------------------------------------------------------------------- | Authentication Filters |-------------------------------------------------------------------------- | | The following filters are used to verify that the user of the current | session is logged into this application. The "basic" filter easily | integrates HTTP Basic authentication for quick, simple checking. | */ Route::filter('auth', function () { if (Auth::guest()) { if (Request::ajax()) { return Response::make('Unauthorized', 401);
| to the user if maintenace mode is in effect for this application. | */ App::down(function () { return Response::make("Be right back!", 503); }); /* * An improvised Gist from * https://gist.github.com/zmsaunders/5619519 * https://gist.github.com/garagesocial/6059962 */ App::after(function ($request, $response) { if (App::Environment() != 'local') { if ($response instanceof Illuminate\Http\Response) { $output = $response->getOriginalContent(); $filters = array('/<!--(?!\\s*(?:\\[if [^\\]]+]|<!|>))(?:(?!-->).)*-->/s' => '', '/(?<!\\S)\\/\\/\\s*[^\\r\\n]*/' => '', '/\\s{2,}/' => '', '/(\\r?\\n)/' => ''); $output = preg_replace(array_keys($filters), array_values($filters), $output); $response->setContent($output); } } }); /* |-------------------------------------------------------------------------- | Require The Filters File |-------------------------------------------------------------------------- | | Next we will load the filters file for the application. This gives us | a nice separate location to store our route and application filter | definitions instead of putting them all in the main routes file. | */ require __DIR__ . '/../filters.php';
|-------------------------------------------------------------------------- | Application & Route Filters |-------------------------------------------------------------------------- | | Below you will find the "before" and "after" events for the application | which may be used to do any work before or after a request into your | application. Here you may also register your custom route filters. | */ App::before(function () { $throttleProvider = Sentry::getThrottleProvider(); $throttleProvider->enable(); }); App::after(function () { if (Config::get('larapress.settings.log')) { Helpers::logPerformance(); } }); /* |-------------------------------------------------------------------------- | Special larapress Filters |-------------------------------------------------------------------------- | | The following filters are developed for larapress but may be also useful | for your website. You can apply them to any route you'd like. | */ Route::filter('force.human', 'Larapress\\Filters\\Special\\ForceHumanFilter'); /* |-------------------------------------------------------------------------- | Filters for the larapress backend
/* |-------------------------------------------------------------------------- | Application & Route Filters |-------------------------------------------------------------------------- | | Below you will find the "before" and "after" events for the application | which may be used to do any work before or after a request into your | application. Here you may also register your custom route filters. | */ App::before(function ($request) { if (true) { } }); App::after(function ($request, $response) { if (true) { } }); /* |-------------------------------------------------------------------------- | Authentication Filters |-------------------------------------------------------------------------- | | The following filters are used to verify that the user of the current | session is logged into this application. The "basic" filter easily | integrates HTTP Basic authentication for quick, simple checking. | */ Route::filter('auth', function () { if (Auth::guest()) { return Redirect::guest('auth/login'); }
<?php App::before(function () { //echo "<br>start<br>"; }); App::after(function () { //echo "<br>end<br>"; }); Route::filter('auth', function () { if (Auth::guest()) { Url::redirect("@login"); return false; } else { return true; } }); Route::filter('guest', function () { if (Auth::guest()) { Url::redirect('/'); } }); Route::filter('csrf', function () { if (Session::token() != Res::post('_token')) { return false; } else { return true; } });
App::setLocale($cookie_lang); } else { if (!empty($browser_lang) and in_array($browser_lang, Config::get('app.languages'))) { if ($browser_lang != $cookie_lang) { Cookie::forever('language', $browser_lang); Session::put('language', $browser_lang); } App::setLocale($browser_lang); } else { App::setLocale(Config::get('app.locale')); } } }); App::after(function ($request, $response) { $lang = Session::get('language'); if (!empty($lang)) { $response->withCookie(Cookie::forever('language', $lang)); } }); Route::filter('auth', function () { if (!Sentry::check()) { return Redirect::guest('/'); } }); Route::filter('api.patient', function () { if (!Cache::has('_token_')) { return Api\V1\Helpers::Mgs("Api No Acesss. Api. Token"); } }); Route::filter('api.cache', function () { if (!Cache::has('_token_')) { Sentry::logout();
<?php App::after(function ($request, $response) { $response->headers->set('Cache-Control', 'nocache, no-store, max-age=0, must-revalidate'); $response->headers->set('Pragma', 'no-cache'); $response->headers->set('Expires', 'Fri, 01 Jan 1990 00:00:00 GMT'); }); /*App::missing(function($exception) { return Redirect::to('/'); }); */ //Login Screens - No need any Authentication, Accessible by All Route::get('/', 'HomeController@home'); Route::get('/login', 'HomeController@home'); Route::post('/login', 'LoginController@Login'); Route::get('/forgot', 'LoginController@ForgotPassword'); Route::post('forgotpasswordprocess', 'LoginController@ForgotPasswordProcess'); Route::post('ForgotPasswordProcessforadmin', 'LoginController@ForgotPasswordProcessforadmin'); Route::get('/facebook_login', 'LoginController@loginWithFacebook'); Route::get('/twitter_login', 'LoginController@loginWithTwitter'); Route::get('/google_login', 'LoginController@loginWithGoogle'); /// Admin Login /// Route::get('admin', 'LoginController@admin'); Route::post('adminlogin', 'LoginController@adminLogin'); Route::get('forgotadmin', 'LoginController@forgotadmin'); //Create User - For Temporary, It was Accessible without Authentication Route::get('/createuser', 'LoginController@CreateUserLayout'); Route::post('/createuserprocess', 'LoginController@CreateUserProcess'); Route::get('/userregister', function () { //return View::make('user/register/userregister'); });
/* |-------------------------------------------------------------------------- | Application & Route Filters |-------------------------------------------------------------------------- | | Below you will find the "before" and "after" events for the application | which may be used to do any work before or after a request into your | application. Here you may also register your custom route filters. | */ App::before(function ($request) { // }); App::after(function ($request, $response) { // $response->headers->set('Access-Control-Allow-Origin', '*'); // return $response; }); /* |-------------------------------------------------------------------------- | Authentication Filters |-------------------------------------------------------------------------- | | The following filters are used to verify that the user of the current | session is logged into this application. The "basic" filter easily | integrates HTTP Basic authentication for quick, simple checking. | */ Route::filter('auth', function () { if (!Request::header('Authorization')) { return Response::json(array('message' => Request::header()), 401); }
/* |-------------------------------------------------------------------------- | Application & Route Filters |-------------------------------------------------------------------------- | | Below you will find the "before" and "after" events for the application | which may be used to do any work before or after a request into your | application. Here you may also register your custom route filters. | */ App::before(function ($request) { // }); App::after(function ($request, $response) { // }); /* |-------------------------------------------------------------------------- | Authentication Filters |-------------------------------------------------------------------------- | | The following filters are used to verify that the user of the current | session is logged into this application. The "basic" filter easily | integrates HTTP Basic authentication for quick, simple checking. | */ Route::filter('auth', function () { if (Auth::guest()) { if (Request::ajax()) { return Response::make('Unauthorized', 401);
App::after(function ($request, $response) { // if (App::Environment() != 'local') { if ($response instanceof Illuminate\Http\Response) { $output = $response->getOriginalContent(); $re = '%# Collapse whitespace everywhere but in blacklisted elements. (?> # Match all whitespans other than single space. [^\\S ]\\s* # Either one [\\t\\r\\n\\f\\v] and zero or more ws, | \\s{2,} # or two or more consecutive-any-whitespace. ) # Note: The remaining regex consumes no text at all... (?= # Ensure we are not in a blacklist tag. [^<]*+ # Either zero or more non-"<" {normal*} (?: # Begin {(special normal*)*} construct < # or a < starting a non-blacklist tag. (?!/?(?:textarea|pre|script)\\b) [^<]*+ # more non-"<" {normal*} )*+ # Finish "unrolling-the-loop" (?: # Begin alternation group. < # Either a blacklist start tag. (?>textarea|pre|script)\\b | \\z # or end of file. ) # End alternation group. ) # If we made it here, we are not in a blacklist tag. %Six'; $output = preg_replace($re, " ", $output); if ($output === null) { exit("PCRE Error! File too big.\n"); } $response->setContent($output); } } });