Forem: DaleLanto

Laravel 8 - Accessors and Mutators (Eloquent in 2 Steps)

DaleLanto — Fri, 04 Mar 2022 09:14:09 +0000

Laravel Accessors and Mutators are custom, user defined methods. Accessors are used to format the attributes when you retrieve them from database. Whereas, Mutators are used to format the attributes before saving them into the database.

Lets' Start Creating and Using Accessor and Mutators!

Suppose that you have a Model that looks like this:

app/Product.php



<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;

class Product extends Model
{
    use HasFactory;

    protected $fillable = [
        'name', 'amount', 'description'
    ];

    // Mutator for Name column
    // when "name" will save, it will convert into lowercase
    public function setNameAttribute($value)
    {
        $this->attributes['name'] = strtolower($value);
    }
}

and a Controller that looks like this:

ProductController.php



<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use App\Models\Product;

class ProductController extends Controller
{
    public function setProduct()
    {
        $product = new Product();

        $product->name = "Sample Product 1";
        $product->amount = 12;
        $product->description = "Sample product created";

        $product->save();
    }
}

also a route that looks like this:

web.php



Route::get('product', [ProductController::class, 'setProduct']);

Step 1: Create Mutators In The Model

A mutator transforms an Eloquent attribute value when it is set. Mutators work when we save data inside database table.

Syntax to create mutators –

To define a mutator, define a set{Attribute}Attribute method on your model where {Attribute} is the “studly” cased name of the column which we want to get altered when saved.

Paste this in app/Product.php



public function setNameAttribute($value)
    {
        $this->attributes['name'] = strtolower($value);
    }

It should now look like this:



<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;

class Product extends Model
{
    use HasFactory;

    protected $fillable = [
        'name', 'amount', 'description'
    ];

    // Mutator for Name column
    // when "name" will save, it will convert into lowercase
    public function setNameAttribute($value)
    {
        $this->attributes['name'] = strtolower($value);
    }
}

Check the result

Go to URL: http://127.0.0.1/product

The result should look something like this:

Step 2: Create Accessors In The Model

An accessor transforms an Eloquent attribute value when it is accessed. It works when we fetch data from table.

Syntax to create accessor –

To define an accessor, create a get{Attribute}Attribute method on your model where {Attribute} is the “studly” cased name of the column.

Open Product.php and add this code into it



public function getNameAttribute($value)
    {
        return strtoupper($value);
    }

Open ProductController.php controller file and add this method into it.



public function getProducts()
    {
        $products = Product::get();

        foreach ($products as $product) {

            echo $product->name . "<br/>";
        }
    }

Open web.php and add this route into it.



Route::get('list-product', [ProductController::class, 'getProducts']);

Check the Result

URL: http://127.0.0.1/list-product

You should see the list of names (name of product) each in uppercase. This is because we have altered value by accessor method.

Hurray! We have successfully created and used accessors and mutators , use this on your future projects to improve the readability , stability and performance of your code!

Laravel 8 - Scopes (3 Easy Steps)

DaleLanto — Fri, 04 Mar 2022 06:35:17 +0000

Scoping is one of the superpowers that eloquent grants to developers when querying a model. Scopes allow developers to add constraints to queries for a given model.

In simple terms laravel scope is just a query, a query to make the code shorter and faster. We can create custom query with relation or anything with scopes.

In any admin project we need to get data using status base, just like active, pending, draft something else. Instead of writing the same query everytime just use scopes and you're done!

Let's Start Creating our Scope!

Let's create a simple with today() scope and it will get only today records.

Step 1: Create Scope in Model

We will add today scope in our post model. So when we query in controller then we will use that scope in laravel model.

app/Post.php



<?php

namespace App;

use Illuminate\Database\Eloquent\Model;

class Post extends Model
{
    public $table = "posts";

    protected $fillable = [
        'id', 'title', 'body', 'status'
    ];

    public function scopeToday($query)
    {
        return $query->whereDate('created_at', \Carbon\Carbon::today());
    }
}

Step 2: Use the scope in your controller

Go to you controller and use the scope by pasting this:



Post::today()->get();

We can also include parameters to make the scope more dynamic!

Step 3: Make the Scope Dynamic by Adding Parameters

Lets go back to the model and add parameters to the scope

app/Post.php



/**
     * Scope created awhile ago
     */
public function scopeToday($query)
    {
        return $query->whereDate('created_at', \Carbon\Carbon::today());
    }
/**
     * New Dynamic Scope
     */
public function scopeStatus($query, $type)
    {
        return $query->where('status', $type);
    }

Use Both in your controller!



Post::status(1)->today()->get();

Hurray! We have succesfully created our scopes (local scopes) and used it, now use it to your projects and make your code more readable and stable!

I don't recommend the usage of Global Scopes because it can mess up the readability of queries when you are working with a team, specially if there are new members of the team.

But if you want to use it click here

Instead just use Local Scopes which we discussed here and you are good to go!

Laravel 8 - Traits (3 Easy Steps)

DaleLanto — Fri, 04 Mar 2022 03:57:27 +0000

Using traits is one of the best practices alongside OOP(Object-Oriented Programming) and [SOLID Principles] in PHP.(https://dev.to/dalelantowork/solid-principles-object-oriented-programming-in-php-3p3e)

What is a Trait?
Traits are a mechanism for code reuse in single inheritance languages such as PHP.

A trait is intended to reduce some limitations of single inheritance by enabling a developer to reuse sets of methods freely in several independent classes living in different class hierarchies.

In simple terms Traits is a group of methods that you want to include within another class. You can easily reuse that methods to another class. Trait is save to write same code again and again.

Let's Start Creating Our Own Custom Trait!

We will create one trait ImageTrait and in that trait we will write code for image upload.

Whenever we need to upload image then we can use this ImageTrait trait.

Step 1: Create Traits file and ImageTrait

Create a folder inside app directory named Traits and inside it create ImageTrait

Let's create a new trait with verifyAndUpload() function. Paste the code below:

app/Traits/ImageTrait.php



<?php

namespace App\Traits;

use Illuminate\Http\Request;

trait ImageTrait {

    /**
     * @param Request $request
     * @return $this|false|string
     */
    public function verifyAndUpload(Request $request, $fieldname = 'image', $directory = 'images' ) {

        if( $request->hasFile( $fieldname ) ) {

            if (!$request->file($fieldname)->isValid()) {

                flash('Invalid Image!')->error()->important();

                return redirect()->back()->withInput();

            }

            return $request->file($fieldname)->store($directory, 'public');

        }

        return null;

    }

}

Step 2: Create the controller that will use ImageTrait

Paste the code below.

app/Http/Controllers/ItemController.php



<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use App\Item;

class ItemController extends Controller
{
     /**
     * Display a listing of the resource.
     *
     * @return \Illuminate\Http\Response
     */
    public function create()
    {
        return view('imageUpload');
    }

    /**
     * Display a listing of the resource.
     *
     * @return \Illuminate\Http\Response
     */
    public function store(Request $request)
    {
        $input = $request->all();

        $input['image'] = '';

        Item::create($input);

        return back()
            ->with('success','record created successfully.');

    }
}

Step 3: Insert and use ImageTrait on your Controller

Paste the uses of ImageTrait.
app/Http/Controllers/ItemController.php



use App\Traits\ImageTrait;

at the top part



use ImageTrait;

inside the controller class



$input['image'] = $this->verifyAndUpload($request, 'image', 'images');

using the function inside the trait

Now it should like this!



<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use App\Item;
use App\Traits\ImageTrait;

class ItemController extends Controller
{
    use ImageTrait;
     /**
     * Display a listing of the resource.
     *
     * @return \Illuminate\Http\Response
     */
    public function create()
    {
        return view('imageUpload');
    }

    /**
     * Display a listing of the resource.
     *
     * @return \Illuminate\Http\Response
     */
    public function store(Request $request)
    {
        $input = $request->all();

        $input['image'] = $this->verifyAndUpload($request, 'image', 'images');

        Item::create($input);

        return back()
            ->with('success','record created successfully.');

    }
}

Hurray we have successfully created and applied Traits! You can now use this in your projects and improve the readability and stability of your code!

Laravel 8 - SweetAlert2 with AJAX (3 Easy Steps)🍬🍭🧁

DaleLanto — Sat, 26 Feb 2022 05:04:44 +0000

What is SweetAlert2?

SweetAlert2 is a beautiful, customizable, accessible replacement for javascript's pop-up boxes with zero dependencies!

STEP 1: Create Controller

Create user controller using this command:



php artisan make:controller UserController

Open user controller and paste this code:



<?php

namespace App\Http\Controllers;

use App\Models\User;
use Illuminate\Http\Request;

class UserController extends Controller
{
    // all users
    public function users()
    {
        $users = User::all();
        return view('users', compact('users'));
    }

    // delete user
    public function delete($id)
    {
        $delete = User::destroy($id);

        // check data deleted or not
        if ($delete == 1) {
            $success = true;
            $message = "User deleted successfully";
        } else {
            $success = true;
            $message = "User not found";
        }

        //  return response
        return response()->json([
            'success' => $success,
            'message' => $message,
        ]);
    }
}

Here we’ve created two functions. One for getting all users and another for deleting user.

Step 2: Define Routes & Insert Fake data

Let’s define routes for those two functions:



<?php

use App\Http\Controllers\UserController;
use Illuminate\Support\Facades\Route;

Route::get('users', [UserController::class, 'users']);
Route::post('delete/{id}', [UserController::class, 'delete']);

Now let's insert some fake user data using factory and seeder:



\App\Models\User::factory(5)->create(); // 5 fake user data

Read more about factory and seeder here.

Step 3: Set SweetAlert2 with AJAX in the Blade File

Create a view named users.blade.php and paste this code:



<!doctype html>
<html lang="en">
<head>
    <!-- meta tags -->
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
    <!-- csrf-token -->
    <meta name="csrf-token" content="{{ csrf_token() }}">
    <!-- Bootstrap CSS -->
    <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/5.0.0-alpha2/css/bootstrap.min.css">
    <!-- jquery -->
    <script src="https://code.jquery.com/jquery-3.5.1.min.js"></script>
    <!-- SweetAlert2 -->
    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/limonte-sweetalert2/10.5.1/sweetalert2.min.css">
    <script src="https://cdnjs.cloudflare.com/ajax/libs/limonte-sweetalert2/10.5.1/sweetalert2.all.min.js"></script>

    <title>How to Use SweetAlert2 with AJAX in Laravel 8.x</title>
</head>
<body class="container" style="margin-top: 40px;">

<div class="row" style="margin-bottom: 20px;">
    <div class="col-lg-12 margin-tb">
        <div class="pull-left">
            <h3>Users</h3>
        </div>
    </div>
</div>

<table class="table table-bordered">
    <tr>
        <th>ID</th>
        <th>Name</th>
        <th>Email</th>
        <th width="280px">Actions</th>
    </tr>
    @foreach ($users as $user)
        <tr>
            <td>{{ $user->id }}</td>
            <td>{{ $user->name }}</td>
            <td>{{ $user->email }}</td>
            <td>
                <button class="btn btn-danger" onclick="deleteConfirmation({{$user->id}})">Delete</button>
            </td>
        </tr>
    @endforeach
</table>

<script type="text/javascript">
    function deleteConfirmation(id) {
        swal.fire({
            title: "Delete?",
            icon: 'question',
            text: "Please ensure and then confirm!",
            type: "warning",
            showCancelButton: !0,
            confirmButtonText: "Yes, delete it!",
            cancelButtonText: "No, cancel!",
            reverseButtons: !0
        }).then(function (e) {

            if (e.value === true) {
                var CSRF_TOKEN = $('meta[name="csrf-token"]').attr('content');

                $.ajax({
                    type: 'POST',
                    url: "{{url('/delete')}}/" + id,
                    data: {_token: CSRF_TOKEN},
                    dataType: 'JSON',
                    success: function (results) {
                        if (results.success === true) {
                            swal.fire("Done!", results.message, "success");
                            // refresh page after 2 seconds
                            setTimeout(function(){
                                location.reload();
                            },2000);
                        } else {
                            swal.fire("Error!", results.message, "error");
                        }
                    }
                });

            } else {
                e.dismiss;
            }

        }, function (dismiss) {
            return false;
        })
    }
</script>
</body>
</html>

Now that we've finished setting everything up, let's check it out!

Run and See Output

Run the Laravel project



php artisan serve

Visit this route http://localhost:8000/users and you will see a page like this:

Click Delete button and the SweetAlert2 confirmation box will appear:

Click Yes button, the data will be deleted via AJAX and you will see a confirmation message like this:

Hurray! We have succesfully created and tested sweetalert2, use this on your future projects to make it more beautiful!

Laravel 8 - DataTables Server Side Rendering (5 easy steps) 💾📈📊

DaleLanto — Fri, 25 Feb 2022 12:07:49 +0000

DataTables has two fundamental modes of operation:

Client-side processing - where filtering, paging and sorting calculations are all performed in the web-browser.

Server-side processing - where filtering, paging and sorting calculations are all performed by a server.

What does DataTables Server Side Rendering mean?

Imagine about the situation when you see thousands, hundreds of thousands or millions of records, and you have to scan through every record to get the required information.

Seems like difficult right? But not only that imagine the toll it would give to the browser, you're website will literally blackout.

Here comes Datatables which makes our work less miserable and offers quick search, pagination, ordering, sortingfunctionalities to manage the data dynamically in the table.

I will also give tips on how to improve the performance and speed of your Datatables at the end!

Lets start creating our DataTables!

Step 1: Create the Laravel App and Install Yajra DataTables

Run the below-mentioned artisan command to install a new laravel application.



composer create-project laravel/laravel laravel-yajra-datatables --prefer-dist

Then install the Yajra DataTable plugin in Laravel



composer require yajra/laravel-datatables-oracle

Go to config/app.php file and paste this inside:



.....
.....
'providers' => [
    ....
    ....
    Yajra\DataTables\DataTablesServiceProvider::class,
]
'aliases' => [
    ....
    ....
    'DataTables' => Yajra\DataTables\Facades\DataTables::class,
]
.....
.....

Run vendor publish command



php artisan vendor:publish --provider="Yajra\DataTables\DataTablesServiceProvider"

Easy right? Now that setups is done let's create our files!

Step 2: Create Model and Migrations

Run command to create a model



php artisan make:model Student -m

Open database/migrations/timestamp_create_students_table.php file and paste



public function up()
{
    Schema::create('students', function (Blueprint $table) {
        $table->id();
        $table->string('name');
        $table->string('email')->unique();
        $table->string('username');
        $table->string('phone');
        $table->string('dob');
        $table->timestamps();
    });
}

Open app/Models/Student.php and paste in the $fillable array.



<?php
namespace App\Models;
use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;
class Student extends Model
{
    use HasFactory;
    protected $fillable = [
        'name',
        'email',
        'username',
        'phone',
        'dob',
    ];    
}

Run migration



php artisan migrate

We can't have a datatable without data right? So lets' create it!

Insert Dummy Data or Records

Open the database/seeds/DatabaseSeeder.php file and add the following code



<?php
use Illuminate\Database\Seeder;
use Illuminate\Support\Facades\DB;
use Faker\Factory as Faker;
class DatabaseSeeder extends Seeder
{
    /**
     * Seed the application's database.
     *
     * @return void
     */
    public function run()
    {
        $faker = Faker::create();
        $gender = $faker->randomElement(['male', 'female']);
        foreach (range(1,200) as $index) {
            DB::table('students')->insert([
                'name' => $faker->name($gender),
                'email' => $faker->email,
                'username' => $faker->username,
                'phone' => $faker->phoneNumber,
                'dob' => $faker->date($format = 'Y-m-d', $max = 'now')
            ]);
        }
    }
}

Run the following command to generate dummy data:



php artisan db:seed

Now you will have data that looks something like this!

Easy right? 2 Steps all just for the setup! 3 Easy steps left for the actual datatable lol!

Step 3: Create DataTable Controller

Create a controller using the below command



php artisan make:controller StudentController

Open app/Http/Controllers/StudentController.php file and add the following code



<?php
namespace App\Http\Controllers;
use Illuminate\Http\Request;
use App\Models\Student;
use DataTables;
class StudentController extends Controller
{
    public function index()
    {
        return view('welcome');
    }

    public function getStudents(Request $request)
    {
        if ($request->ajax()) {
            $data = Student::latest()->get();
            return Datatables::of($data)
                ->addIndexColumn()
                ->addColumn('action', function($row){
                    $actionBtn = '<a href="javascript:void(0)" class="edit btn btn-success btn-sm">Edit</a> <a href="javascript:void(0)" class="delete btn btn-danger btn-sm">Delete</a>';
                    return $actionBtn;
                })
                ->rawColumns(['action'])
                ->make(true);
        }
    }
}

Step 4: Define Route

Open routes/web.php and add the given code



<?php
use Illuminate\Support\Facades\Route;
use App\Http\Controllers\StudentController;

Route::get('students', [StudentController::class, 'index']);
Route::get('students/list', [StudentController::class, 'getStudents'])->name('students.list');

Step 5: Create the View and Display Data inside the DataTable

Open resources/views/welcome.blade.php file and place the following code.



<!DOCTYPE html>
<html>
<head>
    <title>Laravel 8|7 Datatables Tutorial</title>
    <meta name="csrf-token" content="{{ csrf_token() }}">
    <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.5.0/css/bootstrap.min.css"/>
    <link href="https://cdn.datatables.net/1.10.21/css/jquery.dataTables.min.css" rel="stylesheet">
    <link href="https://cdn.datatables.net/1.10.21/css/dataTables.bootstrap4.min.css" rel="stylesheet">
</head>
<body>

<div class="container mt-5">
    <h2 class="mb-4">Laravel 7|8 Yajra Datatables Example</h2>
    <table class="table table-bordered yajra-datatable">
        <thead>
            <tr>
                <th>No</th>
                <th>Name</th>
                <th>Email</th>
                <th>Username</th>
                <th>Phone</th>
                <th>DOB</th>
                <th>Action</th>
            </tr>
        </thead>
        <tbody>
        </tbody>
    </table>
</div>

</body>
<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.9.1/jquery.js"></script>  
<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery-validate/1.19.0/jquery.validate.js"></script>
<script src="https://cdn.datatables.net/1.10.21/js/jquery.dataTables.min.js"></script>
<script src="https://stackpath.bootstrapcdn.com/bootstrap/4.5.0/js/bootstrap.min.js"></script>
<script src="https://cdn.datatables.net/1.10.21/js/dataTables.bootstrap4.min.js"></script>
<script type="text/javascript">
  $(function () {

    var table = $('.yajra-datatable').DataTable({
        processing: true,
        serverSide: true,
        ajax: "{{ route('students.list') }}",
        columns: [
            {data: 'DT_RowIndex', name: 'DT_RowIndex'},
            {data: 'name', name: 'name'},
            {data: 'email', name: 'email'},
            {data: 'username', name: 'username'},
            {data: 'phone', name: 'phone'},
            {data: 'dob', name: 'dob'},
            {
                data: 'action', 
                name: 'action', 
                orderable: true, 
                searchable: true
            },
        ]
    });

  });
</script>
</html>

The DataTable() method is defined, and the AJAX request is fetching the data from the server and displaying the name, email, user name, phone number and date of birth with the help of Yajra DataTable package.

We have also set orderable and searchable properties to true, so that you can search the data smoothly and make your programming tasks prosperous.

Now lets check it!

Run the following command and check our progress on the browser.



php artisan serve

This is what it should look like!

Hurray! We did it and in just 5 Easy and Quick Steps!

Here are some related links to help you understand more about DataTables and Yajra:

Datatables in Laravel: Default and AJAX (Demo Project)
You will see here the 3 different types of handling DataTables:
1. Laravel + HTML (Load Table on Page Load)
2. Laravel + AJAX = DataTable (Client Side Rendering)
3. Laravel + Yajra = DataTable (Server Side Rendering)
DataTables
Yajra Laravel DataTables Demo

Tips on how to improve your DataTables!

There are several ways in which you can speed up DataTables.

Tip #1 Enable Paging



$('#example').dataTable( {
    "paging": true
} );

Tip #2 Disable OrderClasses



$('#example').dataTable( {
  "orderClasses": false
} );

Tip #3 Enable DeferRender



$('#example').dataTable( {
  "ajax": "sources/arrays.txt",
  "deferRender": true
} );

Tip #4 Enaber ServerSide



$('#example').dataTable( {
  "serverSide": true,
  "ajax": "xhr.php"
} );

Tip #5 Lighten the load on your query!

Instead of getting all the columns and relationships on your query which can lead to a long time of loading, simplify your query by getting only the necessary columns and data you need before passing it on the client-side.

You can read more about it here

Laravel 8 - Audit for Beginners (5 easy steps) ✍🏻📒💾

DaleLanto — Thu, 24 Feb 2022 04:36:42 +0000

Laravel Auditing is a Laravel package that aims to make it easy to track eloquent model changes. The documentation describes Laravel Auditing as follows:

Laravel Auditing allows you to keep a history of model changes by simply using a trait. Retrieving the audited data is straightforward, making it possible to display it in various ways.

Along with model changes, each audit record contains the User Agent, audit URL, and the IP address of the user. One of the main use-cases of the package is looking at suspicious activities or unexpected changes in the model.

You can read more about it here.

Now that you have an understanding of Laravel Auditing lets dive right in the codes!

Step 1: Install the package

In the first step we have to install our package. So open your terminal and run this below command

composer require owen-it/laravel-auditing

Step 2: Generate and publish the vendor and the audits table migration by:

php artisan vendor:publish --provider "OwenIt\Auditing\AuditingServiceProvider" --tag="migrations"

Run Migrate:

php artisan migrate

Step 3: Export the config file for the later adjustment

php artisan vendor:publish --provider "OwenIt\Auditing\AuditingServiceProvider" --tag="config"

Step 4: Apply in the Model

Let's say I have a Product model like this:

namespace App\Models;

use Illuminate\Database\Eloquent\Model;
class Product extends Model
{
    protected $guarded = [];
}

Add update to your Product model like this:

namespace App\Models;

use Illuminate\Database\Eloquent\Model;
use OwenIt\Auditing\Contracts\Auditable;
use OwenIt\Auditing\Auditable as AuditableTrait;

class Product extends Model implements Auditable
{
    use AuditableTrait;

    protected $guarded = [];
}

And that's it.

Step 5: Check the audits table in the database and you should see the auditing rows for the product.

SELECT * FROM `audits`

id user_type user_id event auditable_type auditable_id old_values new_values url ip_address user_agent tags created_at updated_at

1 App\Models\User 976 created App\Models\Product 1297 [] {"title":"Quisquam autem id ei","description":"Exc... http://laravel-prep.test/en/products 127.0.0.1 Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWeb... NULL 2020-11-29 10:44:48 2020-11-29 10:44:48

2 App\Models\User 976 created App\Models\Product 1298 [] {"title":"Ullamco laboriosam","description":"Repel... http://laravel-prep.test/en/products 127.0.0.1 Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWeb... NULL 2020-11-29 10:44:57 2020-11-29 10:44:57

3 App\Models\User 976 updated App\Models\Product 1296 {"title":"Quisquam autem id ei"} {"title":"Voluptatibus sunt i"} http://laravel-prep.test/en/products/1296 127.0.0.1 Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWeb... NULL 2020-11-29 10:50:49 2020-11-29 10:50:49

4 App\Models\User 976 deleted App\Models\Product 1297 {"id":1297,"title":"Quisquam autem id ei","descrip... [] http://laravel-prep.test/en/products/1297 127.0.0.1 Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWeb... NULL 2020-11-29 10:51:14 2020-11-29 10:51:14

Hurray! we have now applied, run and tested Laravel Auditing in 5 easy steps. Hope this helped!

To continue making use of laravel-auditing in a more indepth guide and manner here is a related link:

Laravel Auditing Package: Track all Your Model Changes

Laravel 8 - API Resources for Beginners (10 Steps) ⭐⭐⭐

DaleLanto — Tue, 22 Feb 2022 03:07:37 +0000

What does API Resources mean?

API Resources acts as a transformation layer that sits between our Eloquent models and the JSON responses that are actually returned by our API.
API resources present a way to easily transform our models into JSON responses.

Sample commands for creating the resource class and resource collection using php artisan

create a resource class



$ php artisan make:resource UserResource

create a resource collection using either



$ php artisan make:resource Users --collection
$ php artisan make:resource UserCollection

This is the representation of the database api we are gonna create.

Lets start by creating a new laravel app

$ laravel new book-reviws-api

STEP 1: Create models and migrations

The book reviews API will have three models: User, Book and Rating.

We’ll start by creating the Book model:
$ php artisan make:model Book -m

Next, let’s open the migration file generated for the Book model and update the up() method as below:

database/migrations/TIMESTAMP_create_books_table.php



 public function up()
    {
      Schema::create('books', function (Blueprint $table) {
        $table->increments('id');
        $table->unsignedInteger('user_id');
        $table->string('title');
        $table->text('description');
        $table->timestamps();
      });
    }

We’ll do the same for the Rating model:
$ php artisan make:model Rating -m

Open the migration file generated for the Rating model and update the up() method as below:

database/migrations/TIMESTAMP_create_ratings_table.php



public function up()
    {
      Schema::create('ratings', function (Blueprint $table) {
        $table->increments('id');
        $table->unsignedInteger('user_id');
        $table->unsignedInteger('book_id');
        $table->unsignedInteger('rating');
        $table->timestamps();
      });
    }

Run the the command below to run the migrations:
$ php artisan migrate

Remember to enter your database details in the .env file before running the command above.

STEP 2: Define relationships between models

A user can add as many books as they wish, but a book can only belong to one user. So, the relationship between the User model and Book model is a one-to-many relationship.

Let’s define that. Add the code below inside the User model:

app/User.php



public function books()
    {
      return $this->hasMany(Book::class);
    }

Next, let’s define the inverse relationship on the Book model:

app/Book.php



public function user()
    {
      return $this->belongsTo(User::class);
    }

Likewise, a book can be rated by various users, hence a book can have many ratings. A rating can only belong to one book. This is also a one-to-many relationship.

Add the code below in the Book model:

app/Book.php



public function ratings()
    {
      return $this->hasMany(Rating::class);
    }

Then we define the inverse relationship inside the Rating model:

app/Rating.php



public function book()
    {
      return $this->belongsTo(Book::class);
    }

STEP 3: Allowing mass assignment on some fields

To avoid getting the mass assignment error which Laravel will throw by default, we need to specify the columns we want to be mass assigned.

Let’s add the snippet below to our models respectively:

app/Book.php



protected $fillable = ['user_id', 'title', 'description'];

app/Rating.php



protected $fillable = ['book_id', 'user_id', 'rating'];

STEP 4: Defining API routes

Let’s define our routes. Open routes/api.php and add the line below to it:



  Route::apiResource('books', 'BookController');
    Route::post('books/{book}/ratings', 'RatingController@store');

Since we are building an API, we make use of apiResource() to generate API only routes.

Also, we define a route that will be used to rate a specified book. For instance, /books/53/ratings will be used to rate the book with the ID of 53.

Note:
When building APIs with Laravel, it is recommended to use the apiResource() method while defining resourceful routes, this will generate only API specific routes (index, store, show, update and destroy). Unlike when you use the resource() method, which will in addition to generating API specific routes, also generate create and edit routes, which aren’t needed when building an API.

STEP 5: Creating the book resource

Before we move on to create theBooksController, let’s create a book resource class. We’ll make use of the artisan command make:resource to generate a new book resource class. By default, resources will be placed in the app/Http/Resources directory of our application.

$ php artisan make:resource BookResource

Once that is created, let’s open it and update the toArray() method as below:

app/Http/Resources/BookResource.php



 public function toArray($request)
    {
      return [
        'id' => $this->id,
        'title' => $this->title,
        'description' => $this->description,
        'created_at' => (string) $this->created_at,
        'updated_at' => (string) $this->updated_at,
        'user' => $this->user,
        'ratings' => $this->ratings,
      ];
    }

As the name suggests, this will transform the resource into an array.

We can access the model properties directly from the $this variable.

Now we can make use of the BookResource class in our controller.

STEP 6: Creating the book controller

Let’s create the BookController. For this, we’ll make use of the API controller generation feature
$ php artisan make:controller BookController --api

Next, open it up and paste the following code into it:

app/Http/Controllers/BookController.php



    use App\Book;
    use App\Http\Resources\BookResource;

// ...

    public function index()
    {
      return BookResource::collection(Book::with('ratings')->paginate(25));
    }

    public function store(Request $request)
    {
      $book = Book::create([
        'user_id' => $request->user()->id,
        'title' => $request->title,
        'description' => $request->description,
      ]);

      return new BookResource($book);
    }

    public function show(Book $book)
    {
      return new BookResource($book);
    }

    public function update(Request $request, Book $book)
    {
      // check if currently authenticated user is the owner of the book
      if ($request->user()->id !== $book->user_id) {
        return response()->json(['error' => 'You can only edit your own books.'], 403);
      }

      $book->update($request->only(['title', 'description']));

      return new BookResource($book);
    }

    public function destroy(Book $book)
    {
      $book->delete();

      return response()->json(null, 204);
    }

Functionalities:

The index() method fetches and returns a list of the books that have been added.

The store() method creates a new book with the ID of the currently authenticated user along with the details of the book, and persists it to the database. Then we return a book resource based on the newly created book.

The show() method accepts a Book model (we are using route model binding here) and simply returns a book resource based on the specified book.

The update() method first checks to make sure the user trying to update a book is the owner of the book . If the user is not the owner of the book, we return an appropriate error message and set the HTTP status code to 403. Otherwise we update the book with the new details and return a book resource with the updated details.

Lastly, the destroy() method deletes a specified book from the database. Since the specified book has been deleted and no longer available, we set the HTTP status code of the response returned to 204.

STEP 7: Creating the rating resource

Just as we did with the BookResource, we’ll also create a rating resource class:
$ php artisan make:resource RatingResource

Once that is created, let’s open it and update the toArray() method as below:

app/Http/Resources/RatingResource.php



public function toArray($request)
    {
      return [
        'user_id' => $this->user_id,
        'book_id' => $this->book_id,
        'rating' => $this->rating,
        'created_at' => (string) $this->created_at,
        'updated_at' => (string) $this->updated_at,
        'book' => $this->book,
      ];
    }

Again, we pass along the attributes we want to be converted to JSON when sending the response.

STEP 8: Creating the rating controller

Next, create the RatingController that will make use of the RatingResource:
$ php artisan make:controller RatingController

Next, open it up and paste the following code into it:

app/Http/Controllers/RatingController.php



 use App\Book;
    use App\Rating;
    use App\Http\Resources\RatingResource;

// ...

    public function store(Request $request, Book $book)
    {
      $rating = Rating::firstOrCreate(
        [
          'user_id' => $request->user()->id,
          'book_id' => $book->id,
        ],
        ['rating' => $request->rating]
      );

      return new RatingResource($rating);
    }

The store() is used to rate a specified book. We are using the firstOrCreate() which checks if a user has already rated a specified book.

We add the user rating to the specified book and persist it to the database. Then we return a rating resource based on the newly added rating.

STEP 9: Getting average rating

The last feature that’s left is getting the average rating made on a book

Add the line of code below to the toArray() method of

app/Http/Resources/BookResource.php



'average_rating' => $this->ratings->avg('rating')

We are using the ratings relationship defined of the Book model to fetch all the ratings that have be made on the specified book.

Then, using collection avg(), we get the average of the ratings.

Passing rating to the avg() function indicates that we want to calculate the average based on the book rating.

Now, whenever the BookResource is used, the response will contain the average rating of the book.

Sample book resource response:

Sample rating resource response:

STEP 10: Handling resource not found

By default when a specified model is not found, Laravel will throw a ModelNotFoundException and renders a 404 page. Since we are building an API, we want to handle the exception and throw an API friendly error message.

Add the code below to the render method of

app/Exceptions/Handler.php



if ($exception instanceof ModelNotFoundException && $request->wantsJson()) {
      return response()->json([
        'error' => 'Resource not found'
      ], 404);
    }

This checks if the exception thrown is an instance of ModelNotFoundException and the request wants JSON, then we simply return a response with an error message of Resource not found and set the HTTP status code to 404

Don't forget! The API requests will need the header Accept: application/json in postman.

Laravel 8 - "Cruddy by Design" A Controller Structure for Beginners 🔥🔥🔥

DaleLanto — Sun, 20 Feb 2022 13:56:01 +0000

One of the easiest to understand Controller structures in Laravel is "Cruddy by Design" by Adam Wathan.

After the conference he published a new GitHub repo that contains the demo app he refactored on stage. The 4 main tips to improve your code come as PRs on the repo with an full description on why the change is valuable. Very cool stuff.

Link of the video.

I highly recommend this method specially for beginners when you implement this and are working with a team, by looking at the logic of things in a CRUD way you can easily know where to find the code you need looking simply at the routes or controllers.

There's no real cost to having 10x as many controllers, given you can organise them and standardise naming. This approach has allowed several applications to remain easy to understand and manage as complexity grows; the http interface feels no more complex every time You add a new controller. If you were a developer introduced to a new codebase and you knew it used this approach, you would immediately know what "PodcastTagsController" does and how to use it without even looking in it. You could open routes/web.php in my application and immediately understand the majority of how people interact with the application over http.

Git Workflow with Agile Jira for Beginners 📘📖🖥️

DaleLanto — Fri, 18 Feb 2022 13:05:17 +0000

Agile Git Workflow with Jira

This documentation will show the git standard workflow for medium sized to big tech companies.

When working with a system that would be use by thousands of users every second it would be best to separate the backend and frontend system.

For example:
PHP Laravel API - for the backend
React JS - for the front end

Step by step guide when creating new branch based on your task

After Cloning the specific repository, Branch out always to master/main branch to avoid deprecated version.

Sample Git workflow:

Checkout master:

git checkout master

Make sure master is up to date:

git pull

Checkout feature branch:

git checkout feature/V1-1/create-user-roles

Branch name must based on the task you will develop, if it’s a Feature, Fix or Bug.

Also add to the Jira ticket number if available.
You can use slash for separator.

Example Branch name:
feature/V1-1/create-user-roles
Format:
[Feature, HotFix, Bug]/JIRA Ticket Number/task description

Git commit messages: Make useful and readable message when commit the branch.
And also add Jira ticket when making messages.

Format:
[Jira Ticket Number] [Feature, Bug, Fix] : commit messages
Example:
[V1-1] feature: adding user roles migratons

This is a very useful convention when integrating with Jira and Github.

Push the new branch

git push --set-upstream origin develop feature/V1-1/create-user-roles

Merge/Pull request: Always request to the develop branch only, to avoid issues on the master/develop Branch

The tech lead or tech manager will be the one to merge and combine the pull requests.

Always check carefully your Jira ticket number when creating and commit branch.
This will help the team to add changelog to Jira task from Github commit.

When you are currently working on a task and need to update the master branch without deleting your progress or messing up the codes you can do a git stash.

git stash

Update the master/main branch

git pull origin master

Bring your changes back

git stash pop

Branch Tagging/Versioning

All task from the Sprint will be merged to the develop branch once it’s already done from code review/checking

Develop Branch must be compared to the main/master Branch if there’s any conflicts and Behind/Ahead commits.

Merge Develop branch to master branch once it already clean from any conflicts.

Make semantic number from the master branch to create a release/tags versioning

Sample Tags Versioning

userapi - V1
userchatapi - V2

Instructions

Format:
MAJOR.MINOR.PATCH

MAJOR version when you make incompatible API changes,
MINOR version when you add functionality in a backwards compatible manner, and
PATCH version when you make backwards compatible bug fixes.

Example:
v1.0.0

Semantic versioning is very useful for the deployment process when it comes to Production servers, You can easily rollback specific version from the clean version when the installed version is buggy.

PHP Laravel 8 - Best Naming Conventions for APIs ⭐⭐⭐⭐⭐

DaleLanto — Fri, 18 Feb 2022 10:13:10 +0000

This here are the basic naming conventions which are followed by most big tech companies that uses PHP.

This naming conventions is in compliance with Laravel [PHP] coding Standards with PSR specifications.

Best combined with SOLID Principles

And remember to follow the KISS Principle whenever possible

Listed here are the naming standards:

For Classes, Interfaces/Contracts, Traits: use PascalCase
For Constants: use TITLE_CASE
For Functions/Methods, Class Properties, Variables: use camelCase
For Array Indices/Database Field Names/Model Fillables/Model Relations: use lower_snake_case
For Routes: use lower-kebab-case

Below are the standards use cases and samples :

For Classes, Interfaces/Contracts, Traits: usePascalCase

Class:



class AuthController extends Controller
{
    //
}

Interface/Contracts



interface LoginInterface 
{
    /**
}

Traits



trait Audit
{
    /**
}

For Constants: use TITLE_CASE



namespace App\Constants;

class AppConstant {
    const DEFAULT_PAGE = 1;
    const DEFAULT_PAGE_LIMIT = 10;
    const MAX_PAGE_LIMIT = 100;
    const ALPHANUMERIC_CHARACTERS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
    const NUMERIC_CHARACTERS = '0123456789';
    const ALPHA_CHARACTERS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
    const UPPERCASE_ALPHA_CHARACTERS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
    const LOWERCASE_ALPHA_CHARACTERS = 'abcdefghijklmnopqrstuvwxyz';
}

For Functions/Methods, Class Properties, Variables: use camelCase

Functions/Methods



public function refreshToken() : JsonResponse {
        return $this->loginService->refreshToken();
    }

Class Properties



class AuthController extends Controller
{
    // these are the class properties
    protected $loginService;
    protected $logoutService;

}

Variables



public function __construct(LoginService $loginService, LogoutService $logoutService) {
        $this->loginService = $loginService;
        $this->logoutService = $logoutService;
    }

For Array Indices/Database Field Names/Model Fillables/Model Relations: use lower_snake_case

Array Indices



foreach($age as $x => $x_value) {
  return $x_value;
}

Database Field Names



 public function up()
    {
        Schema::create('audits', function (Blueprint $table) {
            $table->id();
            $table->string('user_type')->nullable();
            $table->unsignedBigInteger('user_id')->nullable();
            $table->index(['user_id', 'user_type']);
        });
    }

Model Fillables



protected $fillable = [
        'first_name',
        'last_name',
        'username',
        'email',
        'password',

    ];

For Routes: use lower-kebab-case



Route::group(['middleware' => 'auth:api'], function() {
        Route::post('refresh-token', [AuthController::class, 'refreshToken']);
        Route::post('logout', [AuthController::class, 'logout']);
    });

Rate limiting and Throttling - System Design (Explained)

DaleLanto — Mon, 14 Feb 2022 15:43:31 +0000

If you're here then you probably came from this link.

How do Applications Rate Limit?

Applications can use a variety of techniques to rate limit their clients.

The basic outcome from the client side is the same though: if you exceed a certain number of requests per time window, your requests will be rejected and the API will throw you a ThrottlingException. Throttling exceptions indicate what you would expect – you’re either calling too much, or your rate limits are too low. Either or, you should slow down your rate of calling.

The most popular rate limiting or throttling technique that I’ve encountered in the real world is the Token Bucket Algorithm.

In fact, its the most popular method used in Amazon Web Services APIs so its important to be familiar with it if you’re using AWS. Lets explore it below.

The Token Bucket Algorithm

The Token Bucket Algorithm has two major components, burst and refill (sometimes called sustain). We define them below.

#1 Burst

corresponds to the number of Tokens that are available for a client. The Tokens are consumed every time a request comes in.

In this example, imagine that a token is a 1:1 mapping to a drop of water in a bucket.

Burst actually refers to the size of the bucket (aka the number of drops that are within it available for consumption).

The more burst capacity you have, the more receptive the server is of high volume, but low frequency traffic.

Keep in mind here that each client has their own bucket.

#2 Refill/Sustain

corresponds to the rate in which the backend service refills water into your bucket.

It is essentially the replenishment rate of how fast the backend will give you more opportunities to call the API.

An important concept of the token bucket algorithm is the time unit used to define the burst/refill.

Usually this operates in seconds for most respectable APIs. This means that your burst capacity is calculated on a per second basis (too many requests exceeding the burst rate in a single second will cause Throttling).

Similarly, refill/sustain is usually on a per second basis (you receive new tokens or water on a per-second basis).

The time unit here could be anything though from milliseconds to seconds to minutes to hours – its really up to you.

Another thing to keep in mind is that the burst rate(size) is usually greater than or equal to the refill / sustain rate.

Practically speaking, this makes sense – the bucket capacity we are pouring our water into is usually greater than the rate we are pouring water in.

For example, if we have a bucket that is 1 Litre capacity, it wouldn’t make much sense to have a sustain rate or pouring rate of 2 Litres per second – it would mean that you’re pouring at a rate that is constantly making the bucket overflow which doesn’t make much sense.

So lets think about some different combinations of high/low burst and sustain limits and the implications it has on the client of a rate limited api.

High Burst, Low Refill/Sustain

This combination means that the client will be allowed to make infrequent, bursty calls to an API. However if the client has too many bursts before the bucket has gone back to maximum capacity, the next burst of calls will fail

Equal Burst and Refill/Sustain

If your burst is equivalent to your refill/sustain, you essentially have a static limit per time unit, i.e. 10 requests allowed per second. This configuration is more similar to the Time Window rate limiting algorithm.

The main strength of the Token Bucket Algorithm is that it allows you to build an API that is accommodating of low frequency, bursty workloads. At the same time, you can prevent too many bursts from occurring from a single client by controlling their refill rate.

Implications of a Rate Limited API

Server Perspective

From the server perspective, Rate Limiting means that you need to either use existing rate limiting features in web servers, or build your own to control traffic.

For example, here’s an example from NGINX showing a rate limited API by client IP address at a rate of 1 request / second:

http {
    #...
    limit_req_zone $binary_remote_addr zone=one:10m rate=1r/s;
}

Using IP address is a bit ill advised here since its very easy for customers to change their IP addresses at well.

Ideally, you would want to use some client identity name or access token to identify a client in order to control their rates.

This is how it works with the Twitter API where with each request you attach your developer access token. This lets Twitter identify you consistently and apply rate limits to just you and nobody else.

Client Perspective

If you’re a Client, or a user of a rate limited API, there are some important things to be aware of. Most importantly, you as the client need to be aware of your rate limits.

This helps you design your system in such a way that you won’t exceed the rates provisioned by your resource server.

Secondly, its important to implement a robust retry policy with exponential backoff when faced with a ThrottlingException from a rate limited API.

In the real world, I usually see a retry policy that consists of 3 attempts, with an exponentially increasing sleep duration between each attempts.

This makes it such that your request takes a progressively longer sleep between each attempt, giving the resource server the opportunity to ‘catch up’ and assign you more tokens.

Conclusion

Its important to know what Rate Limiting / Throttling is from both the client and the server perspective.

If you’re a developer using an open source API, I guarantee you that you will at some point be facing the dreaded ThrottlingException or RateLimitedExceedException from these APIs. Its important to know how to handle them in any case.

If you’re a resource owner / service builder, Rate Limiting / Throttling is an important concept that helps regulate the resources of your service per client so that you can ensure a consist experience for ALL users.

Its important to know how it works, and some of the algorithms that are available to you. The Token bucket is one of the most popular and wide-spread used.

API Rate Limiting in System Design for Beginners (Simple and Easy)

DaleLanto — Mon, 14 Feb 2022 15:26:31 +0000

What is Rate Limiting?

Rate limits are calculated in Requests Per Second (RPS). For example, let’s say a developer only wants to allow a client to call the API a maximum of 10 times per minute.

In this case the developer would apply a rate limit to their API expressed as “10 requests per 60 seconds”.

This means that the client will be able to successfully call the API up to 10 times within any 60 second interval and after that the user will get an error stating their rate limit has been exceeded if they call it an 11th time within that time frame.

Why is this important in API?

In the realm of API management, rate limiting is one of the fundamental aspects of managing traffic to your APIs. Rate limiting can easily become one of the easiest and most efficient ways to control traffic to your APIs.

Rate limiting can help with API overuse caused by accidental issues within client code which results in the API being slammed with requests.

On the malicious side, a denial of service attack meant to overwhelm the API resources can also be easily executed without rate limits in place.

Yes, we are talking about DDOS Attacks!

All popular websites use rate limiting, here are some examples:

Github

Bitly

Linked In

Twitter

In simple terms we can categorize rate limiting in two type:

#1 API-level rate limiting

API-level rate limiting assesses all traffic coming into an API from all sources and ensures that the overall rate limit is not exceeded.

Overwhelming an endpoint with traffic is an easy and efficient way to execute a denial of service attack.

By using a global rate limit you can easily ensure that all incoming requests are within a specific limit.

This limit may be calculated by something as simple as having a good idea of the maximum amount of requests you could expect from users of your API.

It may also be something more scientific and precise like the amount of requests your system can handle while still performing at a high-level.

This may be easily uncovered with some performance testing in order to establish this threshold.

this is used on the server side

An API-level global rate limit may be used as an extra line of defence around attempted denial of service attacks. For instance, if you have load tested your current system and established a performance threshold that you would not want to exceed to ensure system availability and/or performance then you may want to set a global rate limit as a defence to make sure that it is not exceeded

#2 Key-level rate limiting

Key-level rate limiting is more focused on controlling traffic from individual sources and making sure that users are staying within their prescribed limits.

This approach to rate limiting allows you to configure a policy to rate limit in several ways: limiting the rate of calls the user of a key can make to all available APIs, another form of global rate limiting just from one specific user, and limiting the rate of calls to specific individual APIs, also known as a “per API rate limit”.

this is used on the client side

For key-level rate limiting you will be aiming to ensure that one particular user or system accessing the API is not exceeding a determined rate. This makes sense in a scenario such as APIs which are associated with a monetisation scheme where you may allow so many requests per second based on the tier in which that consumer is subscribed or paying for.

Great! You now understand what rate limiting is and the importance of it in APIs, if you want a more specific explanation on rate limiting click this link!