Forem: Ghulam Mujtaba

Eloquent in Laravel

Ghulam Mujtaba — Fri, 06 Sep 2024 17:15:49 +0000

What is Eloquent?

Eloquent is Laravel's Object-Relational Mapping (ORM) system. It allows you to interact with your database using PHP classes and objects.

Key Features:

Simplifies database interactions
Defines database tables as PHP classes (models)
Supports CRUD operations (Create, Read, Update, Delete)
Defines relationships between tables

Basic Example:

Let's say we have a jobs table in your database. With Eloquent, you can create a Job model to interact with that table:

// app/Models/Job.php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Job extends Model
{
    protected $table = 'job_listings';
protected $fillable = ['title' , 'salary'];
}

That's it! We can now use the Job model to perform database operations, like creating a new job.
Eloquent provides a simple and elegant way to work with your database in Laravel.

Understanding View Data and Route Wildcards

Ghulam Mujtaba — Sat, 31 Aug 2024 16:11:18 +0000

Today, I learned about view data and route wildcards in a Laravel project.

View Data:

In Laravel, view data refers to the data passed from a controller to a view (template) for display. This data is typically stored in an array and passed to the view using the view() helper function or the View facade. The data is then accessible in the view using Blade syntax, enabling dynamic content display.

Route Wildcards:

Route wildcards in Laravel are placeholders in a route's URI that match any value. They are denoted by a {} syntax. For example:

Route::get('/jobs/{id}', function ($id) { ... });

In the web.php file, we have the following routes:

<?php
use Illuminate\Support\Arr;
use Illuminate\Support\Facades\Route;

Route::get('/', function () {
    return view('home');
});

Route::get('/jobs', function () {
    return view('jobs', [
        'jobs' => [
            [
                'id' => 1,
                'title' => 'Director',
                'salary' => '$50,000'
            ],
            [
                'id' => 2,
                'title' => 'Programmer',
                'salary' => '$10,000'
            ],
            [
                'id' => 3,
                'title' => 'Teacher',
                'salary' => '$40,000'
            ]
        ]
    ]);
});

Route::get('/jobs/{id}', function ($id) {
    $jobs = [
        [
            'id' => 1,
            'title' => 'Director',
            'salary' => '$50,000'
        ],
        [
            'id' => 2,
            'title' => 'Programmer',
            'salary' => '$10,000'
        ],
        [
            'id' => 3,
            'title' => 'Teacher',
            'salary' => '$40,000'
        ]
    ];
    $job = Arr::first($jobs, fn($job) => $job['id'] == $id);
    return view('job', ['job' => $job]);
});

Route::get('/contact', function () {
    return view('contact');
});

In this example, {id} is a wildcard that matches any value, allowing the route to handle requests like /jobs/1, /jobs/2, etc. The value matched by the wildcard is then passed to the route's closure or controller method as a parameter ($id in this case). Wildcards can be used to create flexible and dynamic routes.

The route file allows us to view two files: jobs.blade.php and job.blade.php.

Jobs Listing File

The first file lists jobs on the screen when a user clicks on the jobs tab:

<x-layout>
    <x-slot:heading>
        Job Listings
    </x-slot:heading>
    <ul>
        @foreach ($jobs as $job)
            <li>
                <a href="/jobs/{{ $job['id'] }}" class="text-blue-500 hover:underline">
                    <strong>{{ $job['title'] }}:</strong> Pays {{ $job['salary'] }} per year.
                </a>
            </li>
        @endforeach
    </ul>
</x-layout>

File to view single job data

The second file displays detailed data for a single job when a user clicks on the desired job:

<x-layout>
    <x-slot:heading>
        Job
    </x-slot:heading>
    <h2 class="font-bold text-lg">{{ $job['title'] }}</h2>
    <p>
        This job pays {{ $job['salary'] }} per year.
    </p>
</x-layout>

These views utilize Blade syntax to display dynamic content passed from the controller. The jobs view displays a list of jobs, while the job view displays details of a single job.

Laravel Herd Installation

Ghulam Mujtaba — Thu, 08 Aug 2024 18:26:36 +0000

Intro to laravel

Laravel Herd is a fast and native development environment for Windows and macOS, specifically designed for Laravel and PHP development.

Steps to download and install Laravel Herd:

Open a web browser and search for "Laravel Herd" or visit the official website at (link unavailable).
Click on the download button corresponding to your operating system (Windows or macOS).
Click on the download button to start the download process.
Once the download is complete, navigate to the location where the file was saved.
Click on the file to start the installation process.
Follow the installation prompts to complete the installation.
Once installed, you're ready to start developing with Laravel.

Steps to configure and set up a new Laravel project:

Open a terminal and set the directory where you want to store your Herd project. For example:

cd C:\Users\Herd

This sets the directory to C:\Users\Herd.

Run the following command to create a new Laravel project in the specified directory:

laravel new shops

Replace "shops" with your desired project name.

Select a starter kit (if prompted). Laravel offers various HH starter kits to help you get started with your project.
Choose a testing framework (if prompted). You can select either Pest or PHPUnit for testing your application.
Follow the remaining prompts to complete the setup process. This may include setting up dependencies, configuring environment variables, and more.
Once the setup is complete, navigate to your project directory:

cd shops

To open the project in code editor of your own choice write the name of editor in terminal, add a blank space and full stop then hit Enter key to open project code like.

code .

This command is used to open project in Visual Studio Code editor.

Start the development server using the following command:

php artisan serve

This will start the Laravel development server, and we can access cour project in a web browser at http://shops.test/.

I hope that you have clearly understood it

Getting Started with Laravel: Creating a 3-Page Layout

Ghulam Mujtaba — Thu, 08 Aug 2024 18:09:26 +0000

Starting the Laravel Project

Let's start our Laravel project by opening the terminal and running the command code . to open the project in VS Code. Make sure the correct directory is selected where the project code is present.

Adding Routes and Views

First, let's add a route and view to our project. Open the web.php file in the routes directory and add the following code:

Route::get('/about', function () {
    return "Welcome to About Page";
});

Testing the Route

To test this route, refresh the project in your browser and update the search bar to (http://shops.test/about) and hit Enter. We should see the string "Welcome to About Page" displayed correctly.

Creating a 3-Page Layout

Next, let's create a 3-page layout using layout files. Create three new files:

welcome.blade.php
about.blade.php
contact.blade.php

Add the same code to all three files:

<x-layout>
    Welcome to Home Page
</x-layout>

Creating the Layout File

Let's create a new directory resources/components and add a new file layout.blade.php. Add the following basic HTML code and navigation bar:

<!DOCTYPE html>
<html>
<head>
    <title>Web Development</title>
</head>
<body>
    <nav>
        <a href="/">Home</a>
        <a href="/about">About</a>
        <a href="/contact">Contact</a>
    </nav>
    <?php echo $slot ?>
</body>
</html>

Note: The <?php echo $slot ?> line is used to inject page-specific content into the layout.

Adding Routes for Pages

Finally, let's add routes for our three pages. Open the web.php file and add the following code:

Route::get('/', function () {
    return view('welcome');
});

Route::get('/about', function () {
    return view('about');
});

Route::get('/contact', function () {
    return view('contact');
});

With these changes, we should now have a basic Laravel project with a navigation bar and three pages: Home, About, and Contact.

I hope that you have understood it clearly.

Exception in OOP php

Ghulam Mujtaba — Tue, 30 Jul 2024 06:23:23 +0000

Exception

In OOP PHP, an exception is an object that represents an error or unexpected behavior in a program. It's a way to handle and manage errors in a more structured and organized way.

Purpose

The purpose of exceptions is to:

Separate error handling code from regular code
Provide a way to handle errors in a centralized and reusable way
Allow for more informative and specific error messages

How to Use Exceptions

Try: Wrap code that might throw an exception in a try block.
Throw: Use the throw keyword to create and throw an exception.
Catch: Use a catch block to handle an exception.

An example related to exception is:

<?php 

class TeamException extends Exception {
    public static function fromTooManyMembers() {
        return new static('You may not add more than 3 team members.');
    }
}

class Member {
    public $name;
    public function __construct($name) {
        $this->name = $name;
    }
}

class Team {
    protected $members = [];
    public function add(Member $member) {
        if(count($this->members) === 3){
            throw TeamException::fromTooManyMembers();
        }
        $this->members[] = $member;
    }
    public function members() {
        return $this->members;
    }
}

class TeamMembersController {
    public function store() {
        $team = new Team;
        try{
            $team->add(new Member('John Doe'));
            $team->add(new Member('Ghulam Mujtaba'));
            $team->add(new Member('Ali Hassan'));
            $team->add(new Member('Ahmad Ali'));
            var_dump($team->members());
        } catch(TeamException $e ) {
            var_dump($e -> get message());
        }
    }
}

(new TeamMembersController())->store();

In this code snippet, we have a TeamException class that extends the built-in Exception class. This custom exception is used to represent an error when trying to add more than 3 members to a team.

When we run this code, it will output the exception object with the error message "You may not add more than 3 team members." This demonstrates how exceptions can be used to handle errors in a more structured and informative way.

I hope that you have clearly understood it.

Exception in OOP php

Ghulam Mujtaba — Tue, 30 Jul 2024 06:23:22 +0000

Exception

In OOP PHP, an exception is an object that represents an error or unexpected behavior in a program. It's a way to handle and manage errors in a more structured and organized way.

Purpose

The purpose of exceptions is to:

Separate error handling code from regular code
Provide a way to handle errors in a centralized and reusable way
Allow for more informative and specific error messages

How to Use Exceptions

Try: Wrap code that might throw an exception in a try block.
Throw: Use the throw keyword to create and throw an exception.
Catch: Use a catch block to handle an exception.

An example related to exception is:

<?php 

class TeamException extends Exception {
    public static function fromTooManyMembers() {
        return new static('You may not add more than 3 team members.');
    }
}

class Member {
    public $name;
    public function __construct($name) {
        $this->name = $name;
    }
}

class Team {
    protected $members = [];
    public function add(Member $member) {
        if(count($this->members) === 3){
            throw TeamException::fromTooManyMembers();
        }
        $this->members[] = $member;
    }
    public function members() {
        return $this->members;
    }
}

class TeamMembersController {
    public function store() {
        $team = new Team;
        try{
            $team->add(new Member('John Doe'));
            $team->add(new Member('Ghulam Mujtaba'));
            $team->add(new Member('Ali Hassan'));
            $team->add(new Member('Ahmad Ali'));
            var_dump($team->members());
        } catch(TeamException $e ) {
            var_dump($e -> get message());
        }
    }
}

(new TeamMembersController())->store();

I hope that you have clearly understood it.

Value Objects and Mutability in OOP

Ghulam Mujtaba — Tue, 30 Jul 2024 06:08:29 +0000

Value Object

A Value Object represents a set of values and has three key characteristics:

Immutability: It's state cannot be changed once created.
Values: It holds a set of values (in this case, the age).
Equality criteria: It's equal by value (not by reference).

The Age class is a Value Object because it represents a single value (age) and is immutable.

Immutability:

Immutability means an object's state cannot be changed after creation. The Age class is immutable because:

The age property is private and only settable through the constructor.
There are no setter methods to change the age property.
The increment method returns a new Age object with the incremented value, rather than modifying the existing object.


<?php 

class Age {
    private $age;

    public function __construct($age) {
        if ($age < 0 || $age > 120) {
            throw new InvalidArgumentException('That doesn't make sense');
        }
        $this->age = $age;
    }

    public function increment() {
        return new self($this->age + 1);
    }

    public function get() {
        return $this->age;
    }
}

$age = new Age(37);
$age = $age->increment();
var_dump($age->get()); // int(38)

function register(string $name, Age $age) {
    // ...
}

In this example we don't have equality criteria but we can implement by using the 'equals' method.

Why use Value Objects and Immutability?

Using Value Objects and Immutability makes our code:

Easier to understand: Predictable behavior without unexpected changes.
Safer: Multiple parts of our program can't modify each other's data.
Simpler: No need to worry about changing existing data.
Reusable: Use the same data in multiple places without worrying about changes.

By using Value Objects and Immutability, we can make our code more reliable, easier to understand, and simpler to maintain.

Object Composition and Abstractions in OOP

Ghulam Mujtaba — Sun, 28 Jul 2024 17:32:01 +0000

Object composition and abstraction are fundamental concepts in PHP object-oriented programming (OOP).

Object Composition:

Object composition is a technique where an object is made up of one or more other objects. This allows for:

Code reuse
Easier maintenance
More flexibility

In PHP, object composition is achieved by including one class within another using a property or method.

Abstraction:

Abstraction is the concept of showing only the necessary information to the outside world while hiding the internal details. In PHP, abstraction is achieved using:

Abstract classes
Interfaces
Encapsulation (access modifiers)

Abstraction helps to:

Reduce complexity
Improve code organization
Increase flexibility

An example of object composition and abstraction in PHP is:

<?php 

// Abstraction
abstract class Vehicle {
  abstract public function move();
}

// Object Composition
class Car {
  private $engine;

  public function __construct(Engine $engine) {
    $this->engine = $engine;
  }

  public function move() {
    $this->engine->start();
    echo "Car is moving";
  }
}

class Engine {
  public function start() {
    echo "Engine started";
  }
}

$car = new Car(new Engine());
$car->move();

In this example, the Car class is composed of an Engine object, demonstrating object composition. The Vehicle abstract class provides abstraction, hiding the internal details of the move method from outside.

I hope that you have clearly understood it.

Value Objects and Mutability in OOP

Ghulam Mujtaba — Sun, 28 Jul 2024 17:23:11 +0000

Value objects are immutable objects that represent a set of values. They are used to encapsulate data and behavior, and are often used in domain-driven design.

Characteristics of Value Objects:

Immutable (cannot be changed once created)
Equal by value (not by reference)
No identity (no unique ID)
Can be used as array keys or hash map keys

Mutability:

Mutability refers to the ability of an object to change its state after creation.

Types of Mutability:

Mutable: Can change state after creation (e.g., arrays, objects with setters)
Immutable: Cannot change state after creation (e.g., value objects, strings)

Best Practices:

Use immutable objects when possible (e.g., value objects, data transfer objects)
Use mutable objects when necessary (e.g., entities, domain objects)
Avoid mixing mutable and immutable objects in the same class

<?php 

class Money {
  private $amount;
  private $currency;

  public function __construct($amount, $currency) {
    $this->amount = $amount;
    $this->currency = $currency;
  }

  public function getAmount() {
    return $this->amount;
  }

  public function getCurrency() {
    return $this->currency;
  }

  public function equals(Money $other) {
    return $this->amount === $other->amount && $this->currency === $other->currency;
  }
}

Benefits of Immutable Objects:

Thread-safety
Easy to reason about and test
Can be used as cache keys or hash map keys
Reduces side effects and bugs

By using value objects and controlling mutability, we can write more predictable, maintainable, and scalable code in PHP OOP.

Value Objects and Mutability in OOP

Ghulam Mujtaba — Sun, 28 Jul 2024 17:22:59 +0000

Value objects are immutable objects that represent a set of values. They are used to encapsulate data and behavior, and are often used in domain-driven design.

Characteristics of Value Objects:

Immutable (cannot be changed once created)
Equal by value (not by reference)
No identity (no unique ID)
Can be used as array keys or hash map keys

Mutability:

Mutability refers to the ability of an object to change its state after creation.

Types of Mutability:

Mutable: Can change state after creation (e.g., arrays, objects with setters)
Immutable: Cannot change state after creation (e.g., value objects, strings)

Best Practices:

Use immutable objects when possible (e.g., value objects, data transfer objects)
Use mutable objects when necessary (e.g., entities, domain objects)
Avoid mixing mutable and immutable objects in the same class

<?php 

class Money {
  private $amount;
  private $currency;

  public function __construct($amount, $currency) {
    $this->amount = $amount;
    $this->currency = $currency;
  }

  public function getAmount() {
    return $this->amount;
  }

  public function getCurrency() {
    return $this->currency;
  }

  public function equals(Money $other) {
    return $this->amount === $other->amount && $this->currency === $other->currency;
  }
}

Benefits of Immutable Objects:

Thread-safety
Easy to reason about and test
Can be used as cache keys or hash map keys
Reduces side effects and bugs

By using value objects and controlling mutability, we can write more predictable, maintainable, and scalable code in PHP OOP.

Encapsulation in OOP

Ghulam Mujtaba — Sat, 27 Jul 2024 17:38:01 +0000

Encapsulation is a fundamental concept in Object-Oriented Programming (OOP) that binds together the data and the methods that manipulate that data, keeping both safe from outside interference and misuse.

In PHP, encapsulation is achieved by using classes and objects to wrap data (properties) and methods that operate on that data. This helps to:

Hide internal implementation details
Protect data from external interference
Improve code organization and structure
Enhance data security and integrity

How to achieve encapsulation in OOP php?

To achieve encapsulation in PHP, we can use:

Access modifiers (public, protected, private) to control access to properties and methods
Constructors to initialize objects
Getters and setters to access and modify properties

<?php 

class BankAccount {
    private $balance;

    public function __construct($initialBalance) {
        $this->balance = $initialBalance;
    }

    public function getBalance() {
        return $this->balance;
    }

    public function deposit($amount) {
        $this->balance += $amount;
    }

    public function withdraw($amount) {
        if ($amount <= $this->balance) {
            $this->balance -= $amount;
        }
    }
}

$account = new BankAccount(1000);
echo $account->getBalance(); // Outputs: 1000
$account->deposit(500);
echo $account->getBalance(); // Outputs: 1500
$account->withdraw(200);
echo $account->getBalance(); // Outputs: 1300

In this example, the BankAccount class encapsulates the $balance property and provides methods to interact with it, while hiding the internal implementation details.

I hope that you have clearly understood it.

Handshakes and Interfaces in OOP

Ghulam Mujtaba — Thu, 25 Jul 2024 12:12:33 +0000

Handshakes

In OOP PHP, "handshakes" refer to the process of ensuring that a class implements a specific interface or extends a specific class. This is done using the implements keyword for interfaces and the extends keyword for inheriting classes.

Interface

An interface in PHP is a contract that specifies a set of methods that must be implemented by any class that implements it. Interfaces are defined using the interface keyword and cannot contain any implementation code.

Example

<?php

interface Newsletter{
    public function subscribe($email);
}
class CompaignMonitor implements Newsletter{
    public function subscribe($email){
        die('subscribinng with compaign monitor');
    }
}
class Drip implements Newsletter{
    public function subscribe($email){ 
        die('subscribinng with Drip');
    }}
class NewsletterSubscriptionsController{
    public function store(Newsletter $newsletter){
        $email = 'janesmith@gmail.com';
        $newsletter ->subscribe($email);
    }}
$controller = new NewsletterSubscriptionsController();

$controller->store(new CompaignMonitor());

I hope that you have clearly understood it.