DEV Community: Abrar Ahmad

Get the Table Name From a Model in Laravel

Abrar Ahmad — Thu, 25 Apr 2024 14:19:39 +0000

Sometimes we need to reference table names throughout our codebase, like when we're using the DB facade.

Although table names don't change often, I still get an uneasy feeling of hardcoding them. It's so much better to reference the model directly so we have one source of truth for the table name.

So, let's learn how to do that! We'll also create a trait that allows static access to any of our model table names to keep our code a little tidier.

If you don't know, Laravel provide a method to get table name from model instance

((new User))->getTable()

Above code should return the table name, in our case its users.

But we don't have new instances always. Its better if we can get the table name statically.
We can get the table name by following.

Add method in model

public static function getTableName() 
{
    return with(new static)->getTable();
}

Get the table name statically

User::getTable() // users

Tip

You can put method in trait and drop it any mode.

Laravel Package for Generating Local Disk Temporary URL

Abrar Ahmad — Fri, 03 Nov 2023 15:22:02 +0000

A while ago I wrote an article on how you can generate the temporary URL for a local disk like we do for S3. You can read the full article here https://dev.to/abrardev99/laravel-temporary-url-for-local-storage-driver-50of.

I needed the same functionality in multiple projects so I ended up adding the same code again and again. So I created a package to achieve temporary URL generation 😍.

First Release

Packages come with some nice configurations.

This is the contents of the published config file:

return [
    'disk' => ['local'],

    'middleware' => ['web', 'signed']
];

Usage

Configuration

This package needs zero configuration, just install and it's good to go. However, if your local disk is different or you want to add another disk, you can configure it. You can add multiple local disks in the config using the disk key.

The package applies web and signed middleware on routes by default, however, you can configure middleware(s) using the middleware key.

Generate Temporary URL

You can use the same syntax used for S3 disk.

Storage::disk('local')->temporaryUrl('file.txt', now()->addMinutes(5));

Partial Update JSON Column in Postgres

Abrar Ahmad — Wed, 01 Nov 2023 07:54:19 +0000

Recently, I stumbled upon a use case where I need to partially update the JSON column.

What has not worked for me

Set using ->> operator

I thought I could do something along those lines before realizing it doesn't work 😞

UPDATE task SET data->>'status' = 'completed';

Using json_set and jsonb_set functions

Upon a quick Google search, I found that Postgres has a json_set function to partially set json values, But I always get the "function does not exist" error.

What has worked for me

I found a workaround which is using string replacement instead. Take a look at the example:

UPDATE task SET data = replace(data::text, '"status":"pending"', '"status":"completed"')::json;

How it is working

We are using the Postgres replace function to replace a string. Postgres supports typecasting. We are converting JSON field to string, replacing the required text, converting it back to JSON, and updating the entire data column with the new values.

Note

This works perfectly for my use case but you have to take into consideration eg speed and chances of data inconsistency while replacing the string.

Enjoy

Laravel Temporary URL for local storage driver

Abrar Ahmad — Tue, 19 Apr 2022 09:57:09 +0000

Recently, I needed to use a temporary URL. Laravel supports temporary URLs out of the box with S3 drivers. I was using a local disk, but Laravel does not support a temporary URL feature for the local disk. If you are getting this exception, you are on the right article.
RuntimeException with message 'This driver does not support creating temporary URLs.'

I decided to add the temporary URL logic for my local disk. We'll accomplish this via Laravel signed URLs.

The below steps describe how to implement the getTemporaryUrl function in your Laravel app.

Step 1: Add the following code in the AppServiceProvider boot method.

Storage::disk('local')->buildTemporaryUrlsUsing(function ($path, $expiration, $options) {
            return URL::temporarySignedRoute(
                'local.temp',
                $expiration,
                array_merge($options, ['path' => $path])
            );
        });

Notice that URL::temporarySignedRoute receives route name local.temp, which we need to define.

Step 2: Add the route in web.php

Route::get('local/temp/{path}', function (string $path){
    return Storage::disk('local')->download($path);
})->name('local.temp');

This will allow downloading of the file using a temporary URL.

Now you can easily generate a temporary URL for the local disk.

disk = Storage::disk('releases-local');

return $disk->temporaryUrl($this->path, now()->addMinutes(5));

PS

Your feedback is welcome if you want to suggest improvements or know any better way.

Pipeline Pattern in Laravel

Abrar Ahmad — Sat, 07 Aug 2021 13:41:07 +0000

PP = Pipeline Pattern

Today, we will learn the Pipeline Pattern and how to use it in Laravel. You can read in depth about PP at HERE. PP can be implemented differently in any language but we'll be seeing in PHP Laravel as Laravel already using this pattern at it's core.

What is Pipeline Pattern

Pipeline is a design pattern specifically optimized to handle stepped changes to an object. Think of an assembly line, where each step is a pipe and by the end of the line, you have your transformed object.

There are vast implementations of PP but to understand easily let's implement a filtering functionality using the pipeline pattern and Laravel.

Example

Let's say we are building filtering system in Laravel, we can filter Post by different parameters like is active or not, sort by ASC or DESC.

Before Implementing PP.

PostController.php

In the index method, we are performing filters.



public function index(Request $request)
    {
        $query = Post::query();

        if ($request->has('active')) {
            $query->where('active', $request->input('active'));
        }

       if ($request->has('sort')) {
            $query->orderBy('title', $request->input('sort'));
        }

        /* get filtered data */
        $posts = $query->get();

        return view('demo', compact('posts'));
    }

Let's convert this mess into beautiful filter pipeline.

PostController.php

To implement Pipeline pattern, we need to make little refactoring. Index method will looks like below



public function index(Request $request)
    {
     $posts = app(Pipeline::class)
            ->send(Post::query())
            ->through([
                \App\Filters\Active::class,
                \App\Filters\Sort::class
            ])
            ->thenReturn()
            ->get();

     return view('demo', compact('posts'));
    }

*send() method will pass your query to handle method
*through() method get the parameter as classes to pass through them. In simple words this is the list of filter classes
*thenReturn() will return the final output
It's all provided by Laravel except we need to create Filter classes which being passed in through() method.

Active class

Create Active class under app/Filters namespace.



namespace App\Filters;

use Closure;

class Active

{

    public function handle($request, Closure $next)

    {

        if (! request()->has('active')) {

            return $next($request);

        }

    return $next($request)-&gt;where('active', request()-&gt;input('active'));
}



}

Sort class

Create Active class under app/Filters namespace.



namespace App\Filters;

use Closure;

class Sort

{

    public function handle($request, Closure $next)

    {

        if (! request()->has('sort')) {

            return $next($request);

        }

    return $next($request)-&gt;orderBy('title', $request-&gt;input('sort'));
}



}

That's it.

Now if I want to add an other filter, I need to make new class let's say Published and this class in through() method and implement filter logic in class handle method.

Conclusion

It might feel overwhelm to implement Pipelines just for two filters but it will be much clean and beneficial for large number of filter or any other complex implementation.

Cleaning Filter Classes

PS: We can clean filter classes by extracting common code in base class. Comment below if you want refactoring of Filter classes in next article.
Until next,
Ahmad

Peasy way to Show Alerts in Laravel Livewire

Abrar Ahmad — Wed, 30 Sep 2020 14:32:17 +0000

What we will achieve

Note

This article assumes that you know the basics knowledge of the Laravel and Livewire package.

Why

We are going to show Alert messages in Laravel Livewire. If you have little work experience with Livewire you may feel that showing alerts are not easy in the Livewire approach. Also, Laravel notify and Laravel Sweetlert not working. Because these libs are request based while Livewire does not use the traditional Laravel request cycle.

Approach

Here I up came with different and easy alerts setup. For alerts, I'm using a javascript toastr library.

Code

Assuming you have a base layout added necessary javascript and CSS. In the base layout, we have to catch an event dispatched by Livewire, See the script section.

app.blade.php

<!DOCTYPE html>
<html>
<head>
   <title>Laravel Livewire Alert</title>
   <link href="https://cdnjs.cloudflare.com/ajax/libs/toastr.js/latest/toastr.min.css" rel="stylesheet">
   @livewireStyles
</head>
<body>
 @livewire('addPost')  // adding livewire component 


 @livewireScripts
 <script 
 src="https://cdnjs.cloudflare.com/ajax/libs/toastr.js/lates 
  t/toastr.min.js"></script>

<script>
window.addEventListener('alert', event => { 
             toastr[event.detail.type](event.detail.message, 
             event.detail.title ?? '') toastr.options = {
                    "closeButton": true,
                    "progressBar": true,
                }
            })
 </script>

</body>
</html>

add-post.blade.php

 // other form element 
   ...
 <button type="button" wire:click="save">Save</button>

AddPost.php

 public function save()
  {
    // validation 
    ...
    // save
    ....

    // show alert
    $this->dispatchBrowserEvent(
    'alert', ['type' => 'success',  'message' => 'Saved']);
  }

Summing up

So, we have addPost component, in the blade file on save or on any button click method we dispatch a browser event from the Livewire PHP component,
We are catching this component in Javascript from base Layout and showing toaster using toastr library you can use other libraries like SweetAlert

That's it! Thanks for reading. If you have a question or need source code for the above tutorial please comment below.

Cover Image by Colin Watts on Unsplash

Question: How to better structure Laravel Livewire code and components?

Abrar Ahmad — Fri, 24 Jul 2020 18:18:54 +0000

I'm building an app using Livewire. If you have some experience with Livewire please take some time to answer.

I'm trying to keep my livewire components code clean. How we can separate validation logic just like custom Requests in the controller as there is not Request object in the Livewire component.

My current approach: I make separate method for validation for now? But I'm looking for something much better like custom Requests.

class Add extends Component
{
 public function store()
    {
     $this->Validation();

     $property = new Property();
     $property->user_id = ...

    }
}

Also, If is there any better approach for structuring components? My current approach is below:

Any suggestions will be appreciated.

Becoming a better Laravel developer by using the SOLID design principles. Part 2

Abrar Ahmad — Wed, 22 Jul 2020 04:33:40 +0000

This article is part 2 of Becoming a better Laravel developer by using the SOLID design principles article series. You can see part one S - Single-responsibility principle here

Today, we will discuss the second letter of SOLID which is O - Open-closed principle.

What is O - Open-closed principle

According to the official definition

software entities should be open for extension, but closed for modification.

Entities can be classes, modules, functions, etc. The definition meaning that extends functionality by adding new code instead of changing existing code.
It is quite confusing to understand by title. So let's see it with examples in Laravel.

Let's say we have an e-commerce system that involves payments. So, we have PaymentController and in that controller, we have pay method which has two payment methods for now 1) Credit Card 2) Paypal and looks like below:

PaymentController.php

public function pay(Request $request)
    {
        $payment = new Payment();
        if($type == 'credit'){
            // do credit card payments
            $payment->paymentWithCreditCard();
        }else {
            //do paypal payments
            $payment->paymentWithPaypal();
        }
    }

and our Payment class looks like this:
Payment.php

class Payment
{

    public function paymentWithCreditCard()
    {
        // logic for credit card payments 
    }

    public function paymentWithPaypal()
    {
        // logic for paypal payments
    }
}

What happens when we want to add a new payment method let's say wire transfer

In pay method we add a new if condition and call an appropriate method from the Payment class.
So the pay method looks like below:
PaymentController.php

public function pay(Request $request)
    {
        $payment = new Payment();
        if($type == 'credit'){
            // do credit card payments
            $payment->paymentWithCreditCard();
        }else if($type == 'paypal') {
            //do paypal payments
            $payment->paymentWithPaypal();
        }
        else {
            //do wire transfer payments
            $payment->paymentWithWiretransfer();
        }
    }

and modifying the Payment class:
Payment.php

class Payment
{

    public function paymentWithCreditCard()
    {
        // logic for credit card payments
    }

    public function paymentWithPaypal()
    {
        // logic for paypal payments
    }

    public function paymentWithWiretransfer()
    {
        // logic for wire transfer payments
    }
}

So what will happen next What if we have another payment method called Cash on Delivery, we have added another if and then a new method in the Payment class. Another payment method comes called Coupon Payment and we are again modifying classes. Remember what does this principle says, Open for extension but close for modifications. so we are breaking this principle here.
So, how to fix it, let's apply Open Close Principle here.

Let's make a new interface with a method named pay read more about interfaces in PHP.
PayableInterface.php

interface PayableInterface
{
    public function pay();
}

Make a class for each payment method and extend it with the PayableInterface interface.
CreditCardPayment.php

class CreditCardPayment implements PayableInterface
{

    public function pay()
    {
        // Implement Credit Card payment logic
    }
}

PaypalPayment.php

class PaypalPayment implements PayableInterface
{

    public function pay()
    {
        // Implement paypall payment logic
    }
}

CreditCardPayment.php

class WiretransferPayment implements PayableInterface
{

    public function pay()
    {
        // Implement Wire transfer payment logic
    }
}

Now, make a new class
PaymentFactory.php

class PaymentFactory
{
    public function initializePayment($type)
    {
        if($type == 'credit'){
            // do credit card payments
            return new CreditCardPayment;
        }else if($type == 'paypal') {
            //do paypal payments
            return new PaypalPayment;
        }
        else if ($type == 'wire') {
            //do wire transfer payments
            return new WiretransferPayment;
        }
    }
}

and finally our pay method in
PaymentController.php. This pay method asks PaymentFactory todo the payments and factory handle itself everything.

public function pay(Request $request)
    {
        $paymentFactory = new PaymentFactory();
        $paymentMethod = $paymentFactory->initializePayment($request->type);
        $paymentMethod->pay();
    }

So what will happen next What if we have another payment method called Cash on Delivery we will make a new class called CashOnDeliveryPayment.php and implement the same payableInterface which will give us pay method to put cash on delivery logic there.

That's it. We solve the issue of modifying the classes now if the new payment method comes we extend functionality by adding new class instead of modifying the existing one.

Please comment down below if you do not understand any part of the article.

Becoming a better Laravel developer by using the SOLID design principles. Part 1

Abrar Ahmad — Fri, 17 Jul 2020 07:51:17 +0000

I'm starting a series of explaining and using SOLID Design Principales specifically in Laravel. Today, I will try to cover the first design principle S.

What is SOLID

S.O.L.I.D is an acronym for the first five object-oriented design(OOD)** principles** by Robert C. Martin, popularly known as [Uncle Bob (https://en.wikipedia.org/wiki/Robert_Cecil_Martin).

S.O.L.I.D stands for

S - Single-responsibility principle
O - Open-closed principle
L - Liskov substitution principle
I - Interface segregation principle
D - Dependency Inversion Principle

Purpose of SOLID Design Principales

To make the code more maintainable.
To make the code easier to read and understand
To make it easier to quickly extend the system with new functionalities without breaking the existing ones.
To make the clean code.

Let's look at S - Single-responsibility principle.

According to the official definition of Single-responsibility principle

A class should have one and only one reason to change.

What does that mean? let's understand with an example in Laravel.
Let's assume you have a store method in the controller (for example store method in PostController) and store method look like below with validation


namespace App\Http\Controllers

use App\Http\Controllers\Controller;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Validator;
use App\Post;

class PostController extends Controller
{
    public function store(Request $request)
    {

        // validate incoming request

        $validator = Validator::make($request->all(), [
           'title' => 'required|string|max:200',
           'description' => 'required|string',
       ]);


       // finally store our post

    }
}

let's implement the Single-responsibility principle here, Laravel provide Form Request object out of the box. Make Form Request using an artisan command

php artisan make:request StoreBlogPost

Which will create new Request class in app\Http\Request\StoreBlogPost.

<?php

namespace App\Http\Requests;

use Illuminate\Foundation\Http\FormRequest;

class StoreBlogPost extends FormRequest
{
    /**
     * Determine if the user is authorized to make this request.
     *
     * @return bool
     */
    public function authorize()
    {
        return true;
    }

    /**
     * Get the validation rules that apply to the request.
     *
     * @return array
     */
    public function rules()
    {
        return [
           'title' => 'required|string|max:200',
           'description' => 'required|string',
        ];
    }

}

Now change our PostController to use our StoreBlogPost.


namespace App\Http\Controllers

use App\Http\Controllers\Controller;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Validator;
use App\Post;

class PostController extends Controller
{
    public function store(StoreBlogPost $request)
    {

       // finally store our post

    }
}

It will automatically validate the request data and return validated requests. Now you can $request the same as you use the Request object. You can do a lot of other stuff with Form Request like custom messages, custom validations, etc for more visit Larave official documentation.

If you like the article please consider like and follow me, there are 4 other parts coming understanding SOLID and using in the Laravel app.

Cheers!

How to use Laravel Blade @stack('scripts')

Abrar Ahmad — Tue, 14 Jul 2020 15:08:29 +0000

I see a lot of people are not getting benefits from laravel blade fully. One of blade directive @stack('scripts') is very helpful when you have javascript need to execute in the child page.

I create a fresh Laravel installation to demo an example. I have to make auth scaffolding with laravel/ui package because I'm using Laravel 6.

What is stack('anyname') directive

Stack directive as self-explaining it stacks the scripts where you want to stack them.

How to use

Let's say you have a master view and child views. And you have some javascript operations specifically related to child page may be an Ajax request. Now it is not good practice to put every javascript on the master page. It will slow down the speed because it is executing child pages scripts that don't need.

So what we need to do, in our master page just before closing body tag make @stack like below code.

 <script src="{{ asset('js/app.js') }}" ></script> @stack('child-scripts')

Now in our child page, let's say home, you have alert specific to the child, how to do that

@extends('layouts.app')
@section('content')
<div>I'm child</div>
@endsection

@push('child-scripts')
<script>
alert('I\'m coming from child')
</script>
@endpush

And alert is coming from child

My thoughts:

It is a very clean way of writing javascript.
It improves code readability and performance.
And it will always go to the end of the page as recommended where you put @stack, directive does not matter from where push is coming.