Though PHP doesn’t necessarily have much concept of sugaring, I across this one example sometime back. The idea here is to add a given set of values to an array but at the alternating ends.

Example

For a given set of values, 10, 12, 124, 349, 43, 0, 493, 3, 32. The output should have values pushed to each end alternatively. So, the first value into the array would be 10, 2nd would be 12, pushed to the end (or at the start), 3rd pushed other and so on.

#1    #2    #3    #4    #5    #6    #7    #8    #9
                                                32
                                    493   493   493
                        43    43    43    43    43
            124   124   124   124   124   124   124
10    10    10    10    10    10    10    10    10
      12    12    12    12    12    12    12    12
                  349   349   349   349   349   349
                              0     0     0     0
                                          3     3

The function here loops over an array pushes values in array $e alternatively.

$x = [10, 12, 124, 349, 43, 0, 493, 3, 32];
$i = 0;
foreach ($e as $v) {
      (array_.[unshift,push][++$i%2])($e,$d);
}

It’s an array with the two function names ['array_push','array_unshift'] with [++$i%2] as the index of the array alternating between a 0 or 1 so will evaluate to the other function each time. PHP’s “variable functions” let you assign a variable to a function and execute by calling with parenthesis (ex: $f='array_push'; $f($e,$d); == array_push($e,$d)) so the ($e,$d) is then calling the evaluated element of the array.

Just a shorter way to do

if (++$i%2)
      array_push($e,$d);
else
      array_unshift($e,$e);

The post PHP syntactic sugar code example appeared first on Abhishek G.

$originalDate = "2010-03-21";
$newDate = date("d-m-Y", strtotime($originalDate));

It’s that simple. Do not need any package or library, this is built-in functionality. Now the original date, could be Y-m-d or Y-m-d H:i or Y-m-d H:i:s, where H is hour, i is minute and s is seconds, the above example works for all formats.

This week I had a small python script to fix. Firstly, for almost anything in Python you need to import packages and I used datetime package, the issue with this was datetime.strptime(date, format) expects date to be formatted same as format for it to convert into datetime object.

For example, if the date was say 2021-06-10 11:10 and the format provided was %Y-%m-%d %H:%M:%S it just wouldn’t work. Python expects the format be %Y-%m-%d %H:%M that is without expecting seconds.

Fix: After a few google searches and trials came across this.

import dateutil.parser
yourdate = dateutil.parser.parse(datestring)

The only library I was able to find was dateutil.parser which would convert any string date to datetime object be it 2010-03-21 or 2010-03-21 10:12 or 2010-03-21 10:12:13.

The post Python convert random string date format to Datetime appeared first on Abhishek G.

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.

/**
 * A list of the exception types that should not be reported.
 *
 * @var array
 */
protected $dontReport = [
    AuthenticationException::class,
    \Illuminate\Auth\Access\AuthorizationException::class,
    \Symfony\Component\HttpKernel\Exception\HttpException::class,
    ModelNotFoundException::class,
    \Illuminate\Session\TokenMismatchException::class,
    ValidationException::class,
];

Next is protected $dontFlash which holds the variables for which we don’t want values to be shown when the exception is being report. Most common of these are password or authorization token.

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

Next we define ourselves the structure of json that we’d like to return in case any of the above exception occurs. For this we create an $errorObj variable and initErrorObj function that defines the structure.

/**
 * @var stdClass
 */
private $errorObj;

/**
 * setup basic error Obj with main properties
 *
 * Optional properties that can be added:
 * - details = [];
 * - innererror = [];
 *
 * @return stdClass
 */
private function initErrorObj()
{
    $this->errorObj = new \stdClass();
    $this->errorObj->code = "";
    $this->errorObj->message = "";
    $this->errorObj->target = "";
}

Next we configure the exception render method which will check if there exists a function for the raised exception and do the needful.

/**
 * 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)
{
    $this->initErrorObj();

    $reflect = new \ReflectionClass($exception);
    $method = 'handle' . $reflect->getShortName();

    if (method_exists($this, $method)) {
        $this->errorObj->code = $reflect->getShortName();

        return $this->$method($exception)->header('Access-Control-Allow-Origin', '*');
    }

    return parent::render($request, $exception);
}

Authentication Exception

Whenever an user tries to make an unauthorized request, an AuthenticationException is raised by Laravel. Over here if the request is made via API call requesting JSON response we return a JSON response otherwise redirect the user to login page.

/**
 * Convert an authentication exception into an unauthenticated response.
 *
 * @param  \Illuminate\Http\Request  $request
 * @param  \Illuminate\Auth\AuthenticationException  $exception
 * @return \Illuminate\Http\Response 401
 */
protected function unauthenticated($request, AuthenticationException $exception)
{
    if ($request->isJson() || $request->expectsJson()) {
        $this->errorObj = new \stdClass();
        $this->errorObj->code = "AuthenticationException";
        $this->errorObj->message = $exception->getMessage();
        $this->errorObj->message .= " You are not authorised to make this request.";
        $this->errorObj->target = "query";
        
        return response()->json(['error' => $this->errorObj], 401);
    }

    return redirect()->guest('login');
}

Method Not Allowed Http Exception

This is when the route exists for the request made but the request type does not. Say making a post request when a get request is required would end up throwing MethodNotAllowedHttpException.

/**
 * MethodNotAllowedHttpException
 * The used HTTP method is not allowed on this route in the API
 *
 * @param MethodNotAllowedHttpException $exception
 * @return \Illuminate\Http\Response 405
 */
protected function handleMethodNotAllowedHttpException(MethodNotAllowedHttpException $exception)
{
	$this->errorObj->message = "The used HTTP method is not allowed on this route in the API.";
	$this->errorObj->target = "query";
	
	return response()->json(['error' => $this->errorObj], 405);
}

Model Not Found Exception

This is when a Model is missing. Wonder how this would happen?

/**
 * ModelNotFoundException
 * The model is not found with given identifier
 * https://restpatterns.mindtouch.us/HTTP_Status_Codes/422_-_Unprocessable_Entity
 *
 * @param ModelNotFoundException $exception
 * @return \Illuminate\Http\Response 422
 */
protected function handleModelNotFoundException(ModelNotFoundException $exception)
{
	$fullmodel = $exception->getModel();
	$choppedUpModel = explode('\\', $fullmodel);
	$cleanedUpModel = array_pop($choppedUpModel);
	$this->errorObj->message = $cleanedUpModel . " model is not found with given identifier.";
	$this->errorObj->target = $cleanedUpModel;
	
	return response()->json(['error' => $this->errorObj], 422);
}

Not Acceptable Http Exception

This is when the route and method are both correct but the headers mis-match. Preferably Accept or Content-type headers not appropriately set for an API would throw NotAcceptableHttpException.

/**
 * NotAcceptableHttpException
 * The used HTTP Accept header is not allowed on this route in the API
 *
 * @param NotAcceptableHttpException $exception
 * @return \Illuminate\Http\Response 406
 */
protected function handleNotAcceptableHttpException(NotAcceptableHttpException $exception)
{
	$this->errorObj->message = "The used HTTP Accept header is not allowed on this route in the API.";
	$this->errorObj->target = "query";
	
	return response()->json(['error' => $this->errorObj], 406);
}

Not Found Http Exception

This is when a request is made to a route that does not exist for the API hence throwing NotFoundHttpException with 404 http response code.

/**
 * NotFoundHttpException
 * The requested path could not match a route in the API
 *
 * @param NotFoundHttpException $exception
 * @return \Illuminate\Http\Response 404
 */
protected function handleNotFoundHttpException(NotFoundHttpException $exception)
{
	$this->errorObj->message = "The requested path could not match a route in the API.";
	$this->errorObj->target = "query";
	
	return response()->json(['error' => $this->errorObj], 404);
}

Post Too Large Exception

This is when a size of request is too large for the API to handle. Usually occurs with multipart/form-data request sending large files resulting in PostTooLargeException.

/**
 * PostTooLargeException
 * The used HTTP method is not allowed on this route in the API
 *
 * @param PostTooLargeException $exception
 * @return \Illuminate\Http\Response 413
 */
protected function handlePostTooLargeException(PostTooLargeException $exception)
{
	$this->errorObj->message = "The payload size too large for the server to handle.";
	$this->errorObj->target = "request";
	
	return response()->json(['error' => $this->errorObj], 413);
}

Validation Exception

One of the most use functionality of Laravel is it’s validation module. A single place to format all validation messages is here. Here is an example showing how to customize error message format with ValidationException.

/**
 * ValidationException
 * Parameters did not pass validatio
 * https://github.com/Microsoft/api-guidelines/blob/master/Guidelines.md#examples
 *
 * @param ValidationException $exception
 * @return \Illuminate\Http\Response 400
 */
protected function handleValidationException(ValidationException $exception)
{
    $this->errorObj->message = "Parameters did not pass validation";
    $this->errorObj->target = "parameters";
    $this->errorObj->details = [];

    foreach ($exception->validator->errors()->getMessages() as $field => $message) {
        $details = new \stdClass();
        $details->code = "NotValidParameter";
        $details->message = $message[0];
        $details->target = $field;
        if ($field === 'Channel') {
            $details->code = "ParentChildMismatch";
            $details->message = "The requested service did not find a match for the given channel identifier";
        }
        $this->errorObj->details[] = $details;
    }

    return response()->json(['error' => $this->errorObj], 400);
}

The original code for these Laravel Exception was written by Github user Stad Gent and can be found here.

The post Laravel Custom Exception Handlers appeared first on Abhishek G.

#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.

/**
 * ValidationException
 * Parameters did not pass validation
 *
 * @param ValidationException $exception
 * @return \Illuminate\Http\Response 400
 */
protected function handleValidationException(ValidationException $exception)
{
	$errors = $this->formatErrorBlock($exception->validator);

	$first = '';
	if (!empty($errors) && !empty($errors[0]))
		$first = $errors[0]['message'];

	$json = new \stdClass;
	$json->success = false;
	$json->success_code = 400;
	$json->message = $first;
	$json->errors = $errors;

	return response()->json($json, 400);
}

Next I created formatErrorBlock that would loop through all the default error block created by laravel and format them as required.

public function formatErrorBlock($validator)
{
	$errors = $validator->errors()->toArray();
	$return = array();

	foreach ($errors as $field => $message) {
		$r = ['field' => $field];

		foreach ($message as $key => $msg) {
			if ($key) {
				$r['message'.$key] = $msg;
			} else {
				$r['message'] = $msg;
			}
		}

		$return[] = $r;
	}

	return $return;
}

Notice the if else block in foreach loop. That is because Laravel at times returns multiple errors for a single key hence, I post-fixed the further messages with it’s respective array key.

The post Customizing Laravel validation JSON message format appeared first on Abhishek G.

1. 30th Anniversary of PAC-MAN
Google came out with one of the most addictive classic Pac-man game doodle on it’s 30th Anniversary on May 21, 2010. Go ahead and give it a try.

2. Basketball 2012
If you’re into basket ball, this one is definitely for you.

3. Atari Breakout
Atari’s famous 1978 hit Breakout is on google as well. To play this game, open google, type Atari Breakout and hit enter. Now switch the tab to google images and you’re there.

4. Google Halloween 2016 Google game
If you love halloween and cats this one of for you. This game has 5 levels and is really fun.

The post Time killer and addictive Google Games appeared first on Abhishek G.