Stories by Syed Tahir Ali Jan on Medium

Event-driven Development in Laravel

Syed Tahir Ali Jan — Sun, 01 Oct 2023 13:09:31 GMT

This article was originally published on tahirjan.com

In the world of modern web development, creating interactive and responsive applications is key to providing a seamless user experience. Laravel, a popular PHP framework, offers a robust foundation for building such applications. One powerful concept that Laravel brings to the table is event-based development. In this article, we’ll explore how to harness the power of events in Laravel by creating a real-world example: ordering food from an online restaurant menu.

What are Events in Laravel?

Events in Laravel allow you to create and handle custom events within your application. These events can be triggered at specific points in your code and can be listened to by one or more event listeners. Event-based development follows the Publish-Subscribe pattern, where publishers emit events, and subscribers listen for and react to those events.

Setting Up the Laravel Project

Before we dive into the code, make sure you have Laravel installed on your system. If not, you can follow the installation instructions on the Laravel website.

Let’s start by creating a new Laravel project named “Restaurant."

laravel new Restaurant

Now, navigate to your project’s root folder and open it in your favorite code editor.

Creating the Menu

In our food ordering example, we’ll begin by creating a menu of delicious items. We’ll define these items as an array in our code.

// routes/web.php

Route::get('/', function () {
    $menu = [
        'Burger' => 10,
        'Pizza' => 12,
        'Pasta' => 8,
        'Salad' => 6,
    ];

    return view('menu', ['menu' => $menu]);
});

Here, we define a route that renders a view named “menu" and passes an array of food items with their prices.

Creating the Menu View

Next, we’ll create a menu view that displays the available food items and allows users to place an order.






    Food Menu


    Food Menu

    
        @foreach($menu as $item => $price)
            
                {{ $item }} - ${{ $price }}
                
                    @csrf
                    
                

            

        @endforeach

In this view, we iterate over the menu items, display their names and prices, and provide an “Order” button for each item. The form associated with each item will submit a POST request to the “order” route with the item name as a parameter. I know this looks bad but bear with me for this simple example.

Defining the Event

Now, let’s define an event that represents an order being placed. We’ll call it “FoodOrderedEvent."

php artisan make:event FoodOrderedEvent

This command generates a new event class in the “app/Events" directory. Open the "FoodOrderedEvent.php" file and add a public property to hold the ordered item.


// app/Events/FoodOrderedEvent.php

namespace App\Events;

use ...

class FoodOrderedEvent
{
    use Dispatchable, InteractsWithSockets, SerializesModels;

    public string $item;
  
    public function __construct(string $item)
    {
        $this->item = $item;
    }

    ...
}

Creating an Event Listener

Next, we’ll create an event listener to handle the food orders. Run the following command to generate an event listener.

php artisan make:listener OrderListener

Open the “OrderListener.php" file in the "app/Listeners" directory. In the "handle" method, we'll simulate processing the order by logging a message.


// app/Listeners/OrderListener.php

namespace App\Listeners;

use App\Events\FoodOrderedEvent;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Queue\InteractsWithQueue;

class OrderListener
{
     public function handle(FoodOrderedEvent $event)
     {
         $item = $event->item;
         Log::info("Order placed for $item.");
     }
}

Registering the Event Listener

To ensure that our event listener is registered and listening for events, open the “EventServiceProvider.php" file in the "app/Providers" directory. Add the following line to the "$listen" array:

// app/Providers/EventServiceProvider.php

namespace App\Providers;

use Illuminate\Auth\Events\Registered;
use Illuminate\Auth\Listeners\SendEmailVerificationNotification;
use Illuminate\Foundation\Support\Providers\EventServiceProvider as ServiceProvider;
use Illuminate\Support\Facades\Event;

class EventServiceProvider extends ServiceProvider
{
     protected $listen = [
         FoodOrderedEvent::class => [
             OrderListener::class,
         ],
         Registered::class => [
              SendEmailVerificationNotification::class,
        ],
    ];
    
    ....
}

This configuration tells Laravel to listen for “FoodOrderedEvent" events and handle them using the "OrderListener" listener.

Triggering the Event

Now, we need to trigger the “FoodOrderedEvent" event when a user places an order. Update the "web.php" file to define a route that handles food orders.

// routes/web.php

Route::post('/order/{item}', function ($item) {
    event(new FoodOrderedEvent($item));
    return redirect('/');
})->name('order');

In this route, we use the “event” helper function to fire the “FoodOrderedEvent" event with the selected item as a parameter. After triggering the event, we redirect the user back to the menu.

Testing the Application

Finally, you can start your Laravel development server and visit http://localhost:8000 to explore the food menu and place orders. Each time an order is placed, the event listener will log a message in the Laravel log files.

php artisan serve

Conclusion

Event-based development in Laravel provides a powerful way to decouple components of your application and handle various tasks asynchronously. In this example, we’ve seen how to create a simple food ordering system using Laravel events. You can extend this concept to build more complex and interactive applications with ease. Events are a fundamental tool in Laravel’s toolkit, enabling you to create elegant and responsive web applications. Happy coding!

Setting Up a Laravel Project on Ubuntu VPS with Nginx, Let’s Encrypt, and MariaDB

Syed Tahir Ali Jan — Fri, 29 Sep 2023 13:44:14 GMT

This article was originally published on tahirjan.com on March 25th, 2018:

Setting Up a Laravel Project on Ubuntu VPS with Nginx, Let's Encrypt, and MariaDB - Syed Tahir Ali Jan

Are you ready to take your Laravel project live on the web? If you’re running your application on an Ubuntu VPS and want to ensure secure and efficient hosting, you’ve come to the right place. In this guide, we’ll walk through the process of setting up your Laravel project with Nginx, Let’s Encrypt for HTTPS, and MariaDB for your database.

This is a no complex straightforward fastest deployment setup for learning purposes only, for a more managed approach, you have to setup CI/CD pipeline with test, staging, and production servers.

Prerequisites

Before we dive in, make sure you have the following:

An Ubuntu-based VPS (Virtual Private Server) with SSH access.
A Laravel project ready to deploy.
A domain name pointed to your VPS’s IP address.

Step 1: SSH into Your VPS

If you’re using Windows, you can use PowerShell or PuTTY to connect to your server.

Open your terminal and SSH into your VPS by running the following command:

ssh username@your_server_ip

Replace username with your server's username and your_server_ip with your VPS's IP address.

Step 2: Update and Upgrade

Let’s ensure your server is up to date. Run these commands:

sudo apt update

sudo apt upgrade

This ensures that you have the latest package information and updates installed.

Step 3: Install Nginx

Nginx is a powerful web server and reverse proxy that we’ll use to serve your Laravel application. Install it with:

sudo apt -y install nginx

Once Nginx is installed, start and enable it:

sudo systemctl start nginx

sudo systemctl enable nginx

Step 4: Install MariaDB

MariaDB is an excellent choice for your database needs. Install it with:

sudo apt install -y mariadb-server mariadb-client

During the installation, you’ll be prompted to set a root password. Make sure to choose a strong one.

Start and enable MariaDB:

sudo systemctl start mariadb
			
sudo systemctl enable mariadb

You can secure your MariaDB installation by running, the command-line installation wizard will guide you through the process and ask for your inputs:

sudo mysql_secure_installation

Step 5: Create a Database and User

Log into the MariaDB shell as the root user:

sudo mysql -u root -p

Create a database for your Laravel project. Replace dbname with your desired database name:

CREATE DATABASE dbname;

Create a user and grant privileges. Replace username and password with your chosen credentials:

CREATE USER 'username'@'localhost' IDENTIFIED BY 'password';

GRANT ALL PRIVILEGES ON dbname.* TO 'username'@'localhost';

FLUSH PRIVILEGES;

EXIT;

Step 6: Install PHP and Required Extensions

Install PHP and necessary extensions:

sudo apt install -y php-fpm php-mysql php-json php-curl php-mbstring php-xml php-zip

Step 7: Configure Nginx

Create a new Nginx server block configuration file for your Laravel project:

sudo nano /etc/nginx/sites-available/laravel

Add the following configuration, replacing your_domain with your domain name and your_project_path with the path to your Laravel project's public directory:

server {
	listen 80;
	server_name your_domain;

	root /your_project_path/public;
	index index.php;

	location / {
		try_files $uri $uri/ /index.php?$query_string;
	}

	location ~ \.php$ {
	        include snippets/fastcgi-php.conf;
	      	fastcgi_pass unix:/var/run/php/php7.2-fpm.sock;
      	}

	location ~ /\.ht {
		deny all;
	}

	error_log /var/log/nginx/laravel_error.log;
	access_log /var/log/nginx/laravel_access.log;
}

Save the file and create a symbolic link to enable the configuration:

sudo ln -s /etc/nginx/sites-available/laravel /etc/nginx/sites-enabled/

Test the configuration:

sudo nginx -t

If the test is successful, reload Nginx:

sudo systemctl reload nginx

Step 8: Install Let’s Encrypt Certificates

To secure your Laravel project with HTTPS, we’ll use Let’s Encrypt. Install the Certbot client:

sudo apt install -y certbot python3-certbot-nginx

Obtain and install a certificate for your domain:

sudo certbot --nginx -d your_domain

Follow the prompts to configure Nginx to use the certificate.

Step 9: Configure Laravel .env

Navigate to your Laravel project directory and edit the .env file to configure your database settings:

cd /your_project_path
			
nano .env

Update the DB_DATABASE, DB_USERNAME, and DB_PASSWORD fields with your database information.

Step 10: Assign Proper permissions:

Run the following commands to set the proper file permissions:

sudo chown -R www-data:www-data /your_project_path 

sudo chown -R 755 /your_project_path/bootstrap

sudo chmod -R 755 /your_project_path/storage

Step 11: Migrate and Seed

Run Laravel’s migration and seeding commands to set up your database:

php artisan migrate
			
php artisan db:seed

Step 12: Restart Nginx and PHP-FPM

Restart Nginx and PHP-FPM to apply the changes:

sudo systemctl restart nginx
			
sudo systemctl restart php7.2-fpm

Step 13: Access Your Laravel Project

Open your web browser and visit your domain over HTTPS. You should see your Laravel project up and running, securely hosted on your Ubuntu VPS.

Congratulations! You’ve successfully set up a Laravel project on an Ubuntu VPS using Nginx, Let’s Encrypt for HTTPS, and MariaDB. Your project is now live on the web and ready for the world to see. Happy coding!

The magic of extract() function in PHP

Syed Tahir Ali Jan — Fri, 29 Sep 2023 10:56:00 GMT

This article was originally published on https://tahirjan.com on February 27, 2019

The magic of extract() function in PHP - Syed Tahir Ali Jan

PHP is a versatile language, it offers numerous functions that simplify coding tasks. One of which is extract(), which can be a powerful tool in your PHP toolkit. In this article, we will delve into the extract() function, explore its uses, and provide code examples to illustrate its practical applications.

Understanding extract()

The extract() function in PHP is used to import variables from an associative array into the current symbol table. It effectively transforms array keys into variable names and assigns their corresponding values to these variables. This can be especially handy when you need to work with data retrieved from forms, databases, or other sources.

Syntax:

extract(array, extract_type, prefix);

array: The source array containing key-value pairs to extract as variables.
extract_type (optional): A constant that specifies how to handle naming conflicts.
prefix (optional): A string to prepend to the variable names.

Use Cases and Examples

Let’s explore some common scenarios where the extract() function can be useful.

Scenario 1: Handling Form Data

When processing data submitted through an HTML form, you often receive an associative array with input names as keys and user-submitted values as values. extract() can help simplify the code.

// Simulated form data 

$data = ['name' => 'John Doe', 'email' => 'john@example.com', 'age' => 30]; 

extract($data); 

echo $name; // Output: John Doe 
echo $email; // Output: john@example.com
echo $age; // Output: 30

Scenario 2: Working with Database Results

When fetching data from a database, you often receive rows as associative arrays. extract() can make your code more concise.

// Simulated database result 
$row = ['id' => 101, 'product_name' => 'Widget X', 'price' => 19.99, ];

extract($row); 

echo $id; // Output: 101 
echo $product_name; // Output: Widget X 
echo $price; // Output: 19.99p

Scenario 3: Avoiding Naming Conflicts

You can use the optional extract_type parameter to resolve the naming conflicts when extracting variables.

$user = 'Alice'; 
$conflictingData = [ 'user' => 'Bob', 'message' => 'Hello, World!', ]; 

extract($conflictingData, EXTR_OVERWRITE); echo $user; // Output: Bob echo

$message; // Output: Hello, World!

By setting EXTR_OVERWRITE, the variable $user is overwritten with the value from the array.

Scenario 4: Using a Prefix

To prevent variable name clashes with existing variables, you can specify a prefix.

$existingVar = 'This will not be overwritten'; 

$data = ['existingVar' => 'This is safe', 'newVar' => 'Hello, PHP!',]; 

extract($data, EXTR_PREFIX_ALL, 'prefix'); 

echo $existingVar; // Output: This will not be overwritten 
echo $prefix_existingVar; // Output: This is safe 
echo $prefix_newVar; // Output: Hello, PHP!

By adding the prefix ‘prefix_’, you ensure that extracted variables won’t conflict with existing ones.

The extract() function in PHP is a powerful tool for simplifying code when working with associative arrays. It allows you to transform array keys into variable names effortlessly. However, it should be used with caution to avoid unexpected variable clashes. By understanding its usage and applying it judiciously, you can streamline your PHP code and make it more efficient when dealing with data from various sources.

Laravel: String manipulations with ‘Str’ class

Syed Tahir Ali Jan — Sun, 04 Feb 2018 14:22:03 GMT

Laravel: String manipulations with ‘Str’ class https://programiz.com

Laravel already provides powerfull helpers for string manipulations, but I was wondering what’s behind these convinient helpers. The Laravel string helpers is powered by Illuminate\Support\Str class. Let's explore what methods it contains and how we can use them. For this example I will be using 'Lorem Ipsm ....' for subject testing. Here's the list of all the methods used, you can jump right to your desired method from here:

1- after($subject, $search) : string

This method chops off all the characters including $search from the start in the $subject and returns the rest of the string. Let's test this method:

2- ascii($value, $language = ‘en’) : string

This method returns the ascii equivalent of the $value string in the $language specified.

3- before($subject, $search) : string

This is opposite of after() method. This will only keep the characters before the$search characters:

4- camel($value) : string

This method will return a camel-case string. It will remove any spaces and join the words as shown below:

5- contains($haystack, $needles) : bool

This method returns boolean true or false if a string $haystack contains a string / characters $needles. This is a case-sensitive method, means if it has a work 'tomorrow', it will return false for 'Tomorrow' as demonstrated below:

6- endsWith($haystack, $needles) : bool

This method tests if $haystack ends with $needles which can be a string or an array. Let’s check the example below:

7- finish($value, $cap) : string

This method add a padding to the end of the string. In other words, right-pad the string, as shown below:

8- is($pattern, $value) : bool

This method tests $value against the $pattern which can be a string or an array of strings and returns true or false if the string contains the pattern. As shown below in the example:

9- kebab($value) : string

This method turns your string into a kebab-case string.

10- length($value, $encoding = null) : int

This method uses mbstring extension’s mb_strlen() function for length, for non-ascii (Unicode) strings you have to provide $encoding scheme name such as UTF-8, UTF-16 etc.

11- limit($value, $limit = 100, $end = ‘…’) : string

This method limits the string at a $limit, the default value for limit is 100 characters which is excluding the $end text.

12- lower($value) : string

This method converts the string to a lower-case string.

13- words($value, $words = 100, $end = ‘…’) : string

This method limits the string to the number of words just like limit() method.

14- plural($value, $count = 2) : string

This method converts a given word or last word of the string to plural form.

15- random($length = 16) : string

This method generates a random string, the default length of the returned string is 16.

16- replaceArray($search, array $replace, $subject)

This method replaces all the instances of $search in $subject with $replace in a starting order, you will get more clarity with the following example:

17- replaceFirst($search, $replace, $subject) : string

This method will only replace the first occurance of $search with $replace in the $subject string as shown in the example below:

18- replaceLast($search, $replace, $subject) : string

Like replaceFirst() this method replaces the last occurance of $search with $replace in the $subject string.

19- start($value, $prefix) : string

This method adds $prefix to the starting of the $value. In other words it left-pads the string.

20- upper($value) : string

This method converts $value to upper-case string. It uses mb_strtoupper().

21- title($value) : string

This method converts $value to title-case string.

22- singular($value) : string

Opposite ofplural() method, it converts plural word $valule into a singular word.

23- slug($title, $separator = ‘-’, $language = ‘en’) : string

Turns given string into a slug-case string which can be useful for SEO friendly urls. It will remove any non-printable characters, special characters and convert unicode into ascii characters.

By default, the separator used is ‘-’ but you can specify your own, like I used a ‘+’ sign:

24- snake($value, $delimiter = ‘_’) : string

This method will convert the string $value into a snake-case string with $delimiter specified, an _ will be used if unspecified.

25- startsWith($haystack, $needles) : bool

This method tests if a given string $haystack starts with a string or one of strings in the array $needles.

26- studly($value) : string

This method will return a studly-case string of $value.

This method returns a sub-string of a $string from position $start, $length is optional but you can specify to return the number of characters to be return, it will return the rest of the string if not specified.

This method uses mbstring’s mb_substr() function:

28- ucfirst($string) : string

I don’t know how this method compares to the PHP native ucfirst() function in terms of speed and memory usage but it’s there. This method capitalizes the first character / letter of the string given.

Originally published at tahirjan.com.

Laravel: Add @method() & @csrf to Blade

Syed Tahir Ali Jan — Fri, 02 Feb 2018 04:49:39 GMT

Taylor Otwell tweeted about his plans to add @method() and @csrf. I'm currently using Laravel 5.5 so I have to add these to a ServiceProvider to make use of it. This tutorial discusses how to add such helpers to your edition of Laravel.

Let’s start right off from creating a ServiceProvider:

php artisan make:provider BladeServiceProvider

or just create a class called BladeServiceProvider in your app\Providers directory and add the following code:

namespace App\Providers;
use Illuminate\Support\ServiceProvider;
class BladeServiceProvider extends ServiceProvider
{
    /**
    * Bootstrap the application services. 
    *
    * @return void 
    */
    public function boot()
    {
        //
    }
    /**
     * Register the application services. 
     * 
     * @return void 
     */
     public function register()
     {
         //
     }
}
Now let’s add logic for @method in the boot method of BladeServiceProvider
Blade::directive('method', function ($method) {
    return '';
});
Now let’s add logic for @csrf helper like above.
Blade::directive('csrf', function () {
    return '';
});
Your code should look similar to the following:
namespace App\Providers;
use Blade;
use Illuminate\Support\ServiceProvider;
class BladeServiceProvider extends ServiceProvider
{
    /**
     * Bootstrap the application services. 
     *
     * @return void 
     */
     public function boot()
     {
        Blade::directive('csrf', function () {
            return '';
        });
        Blade::directive('method', function ($method) {
            return '';
        });
     }
     /** 
      * Register the application services. 
      * 
      * @return void 
      */
      public function register()
      {
          //
      }
}
Now add BladeServiceProvider::class to the providers array in your config\app.php file like this:
'providers' => [
    ...
    App\Providers\BladeServiceProvider::class,
    ...
Now finally, you can add @method() and @csrf in Blade template conveniently like this:
<form action="..." class="...">
    @csrf
    @method('put')
    @hidden('user_id',$user->id)
    <input type="first_name" name="first_name">
form>
Thanks for reading!
Originally published at tahirjan.com.

Laravel: Clearing Cache with a click of a button (Artisan Shortcuts)

Syed Tahir Ali Jan — Thu, 01 Feb 2018 18:00:48 GMT

In this tutorial we will learn how to purge compiled views and cache by using Laravel Commands.

Switching back and forth between applications might be cumbersome during development for some folks who have a single monitor. Thanks to the commands in Laravel, we can create and call those commands from anywhere.

Before you begin, keep in mind that you should only use this method for Development purposes. Because purging and re-caching might effect your site’s performance

Let’s start by creating a controller for our operations like this:

php artisan make:controller DevClearCacheController

Now add following methods to DevClearCacheController class like this:

namespace App\Controllers;
class DevClearCacheController extends Controller
{
    public function clear_views()
    {
        \Artisan::call('view:clear');
        return redirect()->back()->with('status','Views Cleared!');
    }
    public function clear_cache()
    {
        \Artisan::call('cache:clear');
        return redirect()->back()->with('status','Cache Cleared!');
    }
    // you can also add methods for queue:start, queue:restart etc.
}
Now let’s add these to the web.php file in the routes directory.
...
Route::get('clear-views', '[email protected]_views')
     ->name('clear-views');
Route::get('clear-cache', '[email protected]_cache')
    ->name('clear-cache');
...
Now, let’s create a view that contains our buttons (I prefer to add these in navbar):



    
    
    
    
    {{ config('app.name', 'Artisan Shortcuts') }}    



    
        
            
            Clear Views

            Clear Cache

            

        

    



@if (session('status'))
{{ session('status') }}
 @endif
Test App



Now let’s test our application, the result will be similar to the following:
Originally published at tahirjan.com.
https://medium.com/media/fc78cb15c51ca2cbc387138848d5e91f/hrefPlease click 👏 button below a few times to show your support! ⬇⬇ Thanks!
Laravel: Clearing Cache with a click of a button (Artisan Shortcuts) was originally published in Quick Code on Medium, where people are continuing the conversation by highlighting and responding to this story.

Custom events in Vue with $emit and Responsive Image goodness

Syed Tahir Ali Jan — Tue, 23 Jan 2018 11:34:40 GMT

Vue provides great functionality when creating components. One great thing is $emit. You can not only trigger a custom event but you can also send data through it.

This article discusses the use of $emit with the implementation of responsive-image like we see in medium.com articles, the result will be similar to the image below:

Finished Product

According to Vuejs.org:

$emit: Trigger an event on the current instance. Any additional arguments will be passed into the listener’s callback function.

Lets implement a responsive image in Vue to utilize the $emit functionality.

Step 1:

Lets start by a clean html template:

https://medium.com/media/563d43abd7be7fa7e8f39b522f1a0ebf/href

Nothing fancy here.

Step 2:

Now lets add Vue goodness to it.

https://medium.com/media/7f71802564691d081c9d0c0643a90cc3/href

Your result shouldn’t look different that the following image:

Custom events in Vue with $emit and Responsive Image goodness | Initial setup

Step 3:

Let’s add a basic code to the application so that it will show our low-resolution image only. I’m calling this component, BetterImage.

As you can notice I’ve also added other properties like orignalUrl, lowresUrl, biWidth, biHeight for future use.

The naming convention of properties in declaration is camelCase while in HTML, the naming convention is kebab-case.

The plan here is that first a low-res image is downloaded, and along-side a high-res image is also downloaded in the background, so that when the high-res image is downloaded, it is then presented with a nice effect.

https://medium.com/media/d778e0925a0663a4fe27cf6edd3f147b/href

As the application is loaded, it will retrive a low-res image. It’s worth mentioning here that I’m using Cloudinary for this example, it gives you a flexible API for image manipulations so you can request an image with specific operation on demand like this:

http://res.cloudinary.com/YOUR_USER_NAME/image/upload/w_25,q_auto:low/RESOURCE_NAME_WITH_.EXTENSION

Here, w_25 means width of 25 pixels, and q_auto:low means serve me image of low quality. More on this: https://cloudinary.com/documentation/image_transformations

Your image will result will look similar to the image below:

Custom events in Vue with $emit and Responsive Image goodness | Low resoulition image downloaded

Step 3 (Final Step):

Now we have basic functionality, let’s add the rest of the code.

What I want for my image, I want to have an image of low quality to show-up first with a blur and desaturated effect while the orignal high-res image is being downloaded in the background, once it is downloaded, the image will have a transition to a colored image and a de-bluring effect, so let’s get right to it:

https://medium.com/media/5226955469092eb15b69bbfa1a996c14/href

The code above shows the use of $emit function which trigger an event called downloaded, we have set

Our final product will look somthing similar to this:

Custom events in Vue with $emit and Responsive Image goodness | Image downloaded

Thanks for reading!

Originally published at tahirjan.com.

Save time by handling POST, PUT, and DELETE in a single FormRequest in Laravel 5

Syed Tahir Ali Jan — Sun, 21 Jan 2018 11:45:51 GMT

https://medium.com/media/f17499b221151347cf0aafbf6b6038b5/href

Imported from: tahirjan.com

This article might seem stupid but I was tired of adding FormRequest for common HTTP verb (PUT, POST, DELETE) used in the controller.

Though separating these files might have their benefits in a large application where other checks are needed to be performed but it was cumbersome for me for small scale applications.

Let’s learn using an example:

namespace App\Http\Controllers;
class CategoriesController extends Controller
{
    // Uses GET request
    public function index()
    {
    }
 
    // Uses GET request
    public function create()
    {
    }
    // Uses POST request
    public function store(Request $request)
    {
    }
    // uses GET request
    public function edit()
    {
    }
    // uses PUT request
    public function update(Request $request, Category $category)
    {
    }
}
Consider you have a CategoriesController like this:
You can create separate FormRequest (CreateCategoryFormRequest, UpdateCategoryFormRequest, DeleteCategoryFormRequest) files for every type of request, or if you're like me, you can create only one FormRequest file and handle every type of request within the file.
What I’d do next is create a FormRequest like this:
php artisan make:request CategoryFormRequest
this will generate the following class in the Requests directory of your Laravel application.
namespace App\Http\Requests;
use Illuminate\Foundation\Http\FormRequest;
class CategoryFormRequest extends FormRequest
{
   /**
    * Determine if the user is authorized to make this request.
    *
    * @return bool 
    */
    public function authorize()
    {
        return false;
    }
   /**
    * Get the validation rules that apply to the request.
    *
    * @return array
    */
    public function rules()
    {
        return [
            //
        ]; 
    }
}
As you can see, you get a plain class. Now I’d add a switch statement to handle different requests:
namespace App\Http\Requests;
use Illuminate\Foundation\Http\FormRequest;
class CategoryFormRequest extends FormRequest
{
  /** 
   * Determine if the user is authorized to make this request. 
   *
   * @return bool 
   */
   
   public function authorize()
   {
      // an extra layer of security,
      // you can check for user role and permission to check if
      // user can do this particular task here,
      // you can also skip it by return true;
      if(auth()->check())
      {
          // I'm using Entrust for user role management
          $user = auth()->user();
          switch($this->getMethod)
          {
              case 'post':
              case 'POST':
                return $user->hasPermission('create-category');
              case 'put':
              case 'PUT':
                return $user->hasPermission('update-category');
 
              case 'DELETE':
              case 'delete':
                return $user->hasPermission('delete-category');
           }
        }
        return false;
      }
      /**
       *  Get the validation rules that apply to the request.
       *
       * @return array 
       */
      public function rules()
      {
          switch ($this->getMethod())
          {
             // handle creates
             case 'post':
             case 'POST':
               return [
                 'name' => 'required|unique:categories,name'
               ];
             // Handle updates
             case 'put':
             case 'PUT':
               return [
                 'category_id' => 'required|exists:categories,id',
                 'name'        => [
                    'required',
                    Rule::unique('categories')->ignore(request('category_id))
                 ];
                 // handle deletions
             case 'delete':
             case 'DELETE':
               return [
                 'category_id' => 'required|exists:categories,id'
               ];
          }
          // return empty array for obvious reasons
          return [ // ];
     }
}
This is it
Originally published at tahirjan.com.

Separation of Admin Section on a different port in Laravel 5.x

Syed Tahir Ali Jan — Tue, 16 Jan 2018 06:39:53 GMT

https://medium.com/media/a9bf43bba9a7d6094729644592b46a18/href

I was working on a project where client wanted to have admin area on a separate port for privacy reasons.

I consulted old friend Google and searched for the any existing implementations. To my dismay, none of the solutions worked for me.

I then thought about the problem and opened RuoteServiceProvider in app\Providers directory in my project.

After a detailed inspection of the file, it hit me.

There is a map() method in this class (RouteServiceProvider) with the following code:

public function map()
{
   $this->mapApiRoutes();
   $this->mapWebRoutes();
}

It means you can add your custom routes to it based on condition, so I quickly changed the implementation to the following:

public function map()
{
   switch(request()->getPort())
   {
      case 80:
      case 8080:
      case 443:
          $this->mapApiRoutes();
          $this->mapWebRoutes();
          break;
     // choose a port that is not used by another server
      case 8975:
          $this->mapAdminWebRoutes();
          break;
    }
}

Notice I’m scanning port number now for every request, that will have it’s own implications and a small over-head, also, I was unable to add an SSL certificate to this port as HTTPS uses port 443.

Please do comment if you know any technique to add SSL certificate to custom port or if I’m doing something wrong where

Now I added the following method maprAdminWebRoutes to RouteServiceProvider class:

protected function mapAdminWebRoutes()
{
   Route::middleware('web')
      ->namespace($this->namespace)
      ->group(base_path('routes/admin-web.php'));
}

Then I added admin-web.php file to the routes directory and added my routes to the file.

We not done yet!

In order for this to work, we also need to add port number to our nginx sites-enabled/YOUR-DOMAIN-CONF-FILE.conf file:

server {
   listen 8975;
   server_name YOUR_DOMAIN_NAME;
   root '/path/to/your/application/public/;

...

And that’s pretty much it.

Now you can access your custom routes on your custom port(s).

I hope you enjoyed this as much as I did when I implemented this.

Thanks for reading!

Laravel FormRequest Mutators / Attribute Casting

Syed Tahir Ali Jan — Fri, 12 Jan 2018 17:37:46 GMT

https://medium.com/media/e6ffb9a3bf19d66f49391ec007beef7f/href

When I was handling form requests in Laravel controller, I felt a need for some intermediate class or a trait in the FormRequest. A a quick Google search revealed that I was not alone but there wasn’t any package available to accomplish what I needed.

Why do we need this package?

To give you guys idea what I wanted, let’s put what I wanted to accomplish.

To create/update user’s details I was doing the following.

...
public function store(UserFormRequest $request)
{
    $first_name = ucwords($request->first_name);
    $last_name = ucwords($request->last_name);
    $fullname = $first_name . ' ' . $last_name;

    ...
    $user = User::create([
        ...
        'first_name' => $first_name,
        'last_name'  => $last_name,
        ...

]);

...

    return redirect(route('users.index'))
            ->with(['message' => "User ({$fullname}) created"]);
}

I was not happy with the code above because it made my controller method look dirty by putting decorative stuff into the controller, there must be a separation of concern here.

I thought for a moment and said to myself, I must do something about it and started digging about Laravel Requests. Soon I learned about validate() method that resides in ValidatesWhenResolvedTrait, which is used in FormRequest class.

The implementation

I began by creating a Trait called RequestCasterTrait and added my casting methods like so:

...

protected function castToLowerCaseWords(): void
{
    if (property_exists($this, 'toLowerCaseWords') && $this->toLowerCaseWords)
    {
        foreach ($this->toLowerCaseWords as $key)
        {
            if ($this->request->has($key))
            {
                $this->request->set($key, strtolower(request($key)));
            }
        }
    }
}

...

Now I added another method to calls all the necessary methods:

public function mapCasts(): void
{
    $this->castToLowerCaseWords();
    $this->castToUpperCaseWords();
    $this->castUCFirstWords();
    $this->castToSlugs();
    $this->castToInteger();
    $this->castToFloats();
    $this->castToBoolean();
    $this->castJsonToArray();

    // call this in last so for the fields that need to be casted first
    $this->castJoinFields();
}

I decided to use the validate() method because it is called before data is either passed back to form with errors or passed to controller. Here is the method in the ValidatesWhenResolvedTrait:

trait ValidatesWhenResolvedTrait
{

    /**
     * Validate the class instance.
     *
     * @return void
     */
    public function validate()
    {
        $this->prepareForValidation();

        $instance = $this->getValidatorInstance();

        if (! $this->passesAuthorization()) {
            $this->failedAuthorization();
        } elseif (! $instance->passes()) {
            $this->failedValidation($instance);
        }
    }
    ...

I overrided this method to accommodate my needs:

public function validate()
{
    $this->prepareForValidation();

    $instance = $this->getValidatorInstance();

    if (!$this->passesAuthorization())
    {
        $this->failedAuthorization();
    }
    else if (!$instance->passes())
    {
        $this->failedValidation($instance);
    }

    if ($instance->passes())
    {
        $this->mapCasts();
    }
}

The casts and conversions will only take place when the validations pass the FormRequest’s rules. And, that’s pretty much it.

Now let’s start using it in our dummy FormRequest and Controller:

UserFormRequest

namespace App\Http\Requests\Admin;

use Stahiralijan\RequestCaster\Traits\RequestCasterTrait;
use Illuminate\Foundation\Http\FormRequest;

class UserFormRequest extends FormRequest
{
   use RequestCasterTrait;

   protected $toUCFirstWords = ['first_name','last_name'];
   protected $joinStrings = ['fullname'=>' |first_name,last_name'];

   public function authorize()
   {
      return TRUE;
   }

   public function rules()
   {

      return [

         'first_name' => 'required',
         'last_name' => 'required',

];

Let me explain what’s going on here:

First you need to import the trait by use Stahiralijan\RequestCaster\Traits\RequestCasterTrait and then use this trait in the class like shown in the code above.

Here I wanted to Capitalize first name and last name, and join both names to create a new field called fullname. You can use the following attributes for mutation / casting:

$toLowerCaseWords: Applies strtolower() to the selected field(s).
$toUpperCaseWords: Applies strtoupper() to the selected field(s).
$toUCFirstWords: Applies ucwords() to the selected field(s).
$toSlugs: Applies str_slug() to the selected field(s).
$toIntegers: Casts selected field(s) to int.
$toFloats: Casts selected field(s) to float.
$toBooleans: Casts selected field(s) to bool.
$toArrayFromJson: Applies json_decode() to the selected fields.

$joinStrings is a special attribute that takes joins two or more fields, you can specify joining rule in the following manner:

protected $joinStrings = ['newFieldName' => 'glue|first_field,second_field,....,nthfield'];

The result of the above UserFormRequest for $first_name = 'Tahir'; $last_name = 'Jan'; will be $fullname = 'Tahir Jan'; as we have provided a space ' ' for a glue. Now lets see how we can use the UserFormRequest in our controller’s store method:

public function store(UserFormRequest $request)
{

   // Here first_name will be 'Tahir' even if user submitted 'tahir'
   // for other casted fields you get the ides

   User::create($request->all());

   return redirect(route('users.index'))
            ->with(['message'=>"User ({$request->fullname}) created"]);

I’ve also created a special method called collection() which returns an Illuminate\Support\Collection so that we get a collection of all the fields instead of an array by $request->all() method. We can use it in controller like this:

public function store(UserFormRequest $request)
{
   $request->collection()->map(function($item){
      ...
      // go nuts
   });
   // or like this for debugging

   $request->collection()->dd(); // thanks to the upgrades in Laravel 5.5
   // or
   $request->collection()->dump();

...

You can install this package in your Laravel 5.5+ application:

composer require stahiralijan/request-caster

Future plans

It would be nice to have a mutator/caster that would run a user method(s) in a similar fashion before FormRequest validates the data.

I don’t know if this package will get broken in next Laravel release because of ValidatesWhenResolvedTrait, please help me by test it in older versions of Laravel.

I hope this package helps you in reducing your dev-time and increases your productivity.

Thanks for reading!