Laravel Custom Exception Handlers

laravel

Laravel throws a large number of exceptions and is very easy to customize them to suit our needs as required.

Note: These exceptions are most helpful if you’re building an API.

The code for common exception handler lies in the {project_root}/app/Exceptions/ folder, named Handler.php. The default file looks like this in Laravel 5.7.

<?php

namespace App\Exceptions;

use Exception;
use Illuminate\Foundation\Exceptions\Handler as ExceptionHandler;

class Handler extends ExceptionHandler
{
    /**
     * A list of the exception types that are not reported.
     *
     * @var array
     */
    protected $dontReport = [
        //
    ];

    /**
     * A list of the inputs that are never flashed for validation exceptions.
     *
     * @var array
     */
    protected $dontFlash = [
        'password',
        'password_confirmation',
    ];

    /**
     * Report or log an exception.
     *
     * @param  \Exception  $exception
     * @return void
     */
    public function report(Exception $exception)
    {
        parent::report($exception);
    }

    /**
     * Render an exception into an HTTP response.
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  \Exception  $exception
     * @return \Illuminate\Http\Response
     */
    public function render($request, Exception $exception)
    {
        return parent::render($request, $exception);
    }
}

Some of the common exceptions that we’re going to handle in this tutorial are AuthenticationException, MethodNotAllowedHttpException, ModelNotFoundException, NotAcceptableHttpException, NotFoundHttpException, PostTooLargeException, ValidationException.

Below is the explanation for each variable, functions and handler implemented.

protected $dontReport = [] is the array of exceptions that Laravel wouldn’t report. Here we’re going to mention the exceptions that we don’t want laravel to report.

Continue reading “Laravel Custom Exception Handlers”

Customizing Laravel validation JSON message format

laravel request validation customize error message format

By default laravel gives a good enough JSON format for validation errors but what if you want to customize it?

#Original JSON format
{
    "message": "The given data was invalid.",
    "errors": {
        "email": [
            "Please enter email address."
        ],
        "password": [
            "Please enter password."
        ]
    }
}

But for this particular project I decided to change the format to this.

{
    "success": false,
    "success_code": 400,
    "message": "Please enter email address.",
    "errors": [
        {
            "field": "email",
            "message": "Please enter email address."
        },
        {
            "field": "password",
            "message": "Please enter password."
        }
    ]
}

To achieve this I created a ValidationException handler function in app/Exceptions/Handler.php which helped me catch all the exceptions raised as a result of failed validations.

Continue reading “Customizing Laravel validation JSON message format”

Error handling in PHP with Error logger working

Error handling in PHP with Error logger working

Logging errors in php is easy, cool and helpful when it comes to test the site for errors as I explained it in my earlier post Logging errors to file in PHP but only till the site is at developer’s end and you working on it. Once you take the site live its just not good anymore. Once you take it on the production end, you cannot show the errors to the user or in case if its even 100% error free you will find that 1 in a 100 person who likes to messup with the sites. Being a programmer you gotta be ready for it. This is the place where comes error handling into play.

Here is a simple script. Just place these two functions in a file and include it at the right place. Probably including from the point onward from where you expect and error would be just perfect.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
// Define a custom error handler
function userErrorHandler($errno, $errstr, $errfile = '', $errline = 0, $errcontext = array()) {
	// Getting error type
	$errorType = array (
			E_ERROR				=> 'ERROR',
			E_WARNING			=> 'WARNING',
			E_PARSE				=> 'PARSING ERROR',
			E_NOTICE			=> 'NOTICE',
			E_CORE_ERROR		=> 'CORE ERROR',
			E_CORE_WARNING		=> 'CORE WARNING',
			E_COMPILE_ERROR		=> 'COMPILE ERROR',
			E_COMPILE_WARNING	=> 'COMPILE WARNING',
			E_USER_ERROR		=> 'USER ERROR',
			E_USER_WARNING		=> 'USER WARNING',
			E_USER_NOTICE		=> 'USER NOTICE',
			E_STRICT			=> 'STRICT NOTICE',
			E_RECOVERABLE_ERROR	=> 'RECOVERABLE ERROR'
			);
 
	if (array_key_exists($errno, $errorType)) {
		$err = $errorType[$errno];
	} else {
		$err = 'CAUGHT EXCEPTION';
	}
 
	// Getting the error log file from php.ini
	$file 		= ini_get('error_log');
 
	// Creating the error log script, same as normal logger would do
	$error_string 	= "[" . date("d-M-Y H:i:s", $_SERVER['REQUEST_TIME']) . '] PHP ' . $err . '::' . $errstr . " in " . $_SERVER['SCRIPT_FILENAME'] . " on line " . $errline . "\r\n";
 
	// Logging error to a certain file
	error_log($error_string, 3, $file);
 
	// Check if the error code is not included in error_reporting
	if (!(error_reporting() &amp; $errno)) {
		return;
	}
 
	// Restore default handlers to prevent errors in errors
	restore_error_handler();
 
	if (function_exists('restore_exception_handler')) {
		restore_exception_handler();
	}
 
	// Load error page
	require('_errors/error.php');
	exit();
}
set_error_handler('userErrorHandler');
 
// Define a custom handler for uncaught exceptions
if (function_exists('set_exception_handler')) {
	function userExceptionHandler($exception) {
		// Restore default handlers to prevent errors in errors
		restore_error_handler();
		if (function_exists('restore_exception_handler')) {
			restore_exception_handler();
		}
 
		// Load error page
		require('error.php');
		exit();
	}
	set_exception_handler('userExceptionHandler');
}

Note: Once you start error handling in real time error logging stops. To overcome this a short code is included inside the function that uses PHP’s error_log function to log errors. So if you have a specifc error log file, just point it towards that.

Good luck!!!

Increase PHP Script Execution Time Limit

Every once in a while I need to process a HUGE file. Though PHP probably isn’t the most efficient way of processing the file, I’ll usually use PHP because it makes coding the processing script much faster. To prevent the script from timing out, I need to increase the execution time of the specific processing script. Here’s how I do it.

1
ini_set('max_execution_time', 60); //60 seconds = 1 minutes

Place this at the top of your PHP script and let your script loose!

N-level menu using recursion

Recently I needed to come up with a code that would help me create a n-level menu and breadcrumb for that. So for that I wrote this code which works with great ease and provides huge flexibility. Also I kept it really low so that it is easy to embedded it in any kind of design. This is just the half part of my code which prints the menu.

Function:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
$table	= 'menu';
 
function showMenu($ulclass, $liclass, $father) {
	$showmenu_query = "select * from $table where menu_father='" . $father . "' order by menu_order";
	$exec_showmenu = mysql_query($showmenu_query);
 
	if ( !$exec_showmenu) {
		echo "Query failed. Check your query.<br /><br />Error Returned: " . mysql_error();
		return false;
	}
 
	$toAppend = '<ul class="' . $ulclass . '">';
 
	while($row_showmenu=mysql_fetch_assoc($exec_showmenu)) {
		$toAppend.= '<li class="' . $liclass . ' &nbsp; '. $row_showmenu['menu_class'] . '">';
		$toAppend.= '<a href="' . stripslashes($row_showmenu['menu_slug']) . '">' . stripslashes($row_showmenu['menu_name']);
		$toAppend.= '</a>';
 
		$submenu_query="select * from $table where menu_father='" . $row_showmenu['menu_id'] . "'";
		$exec_submenu = mysql_query($submenu_query);
		if( mysql_num_rows($exec_submenu)>0 ) {
			$toAppend.= $showMenu($ulclass, $liclass, $row_showmenu['menu_id']);
		}
 
		$toAppend.= '</li>';
	}
 
	$toAppend.= '</ul>';
	return $toAppend;
}

Continue reading “N-level menu using recursion”