DEV Community: Anas Hussain

NumPy on Ubuntu: From Zero to First Arrays

Anas Hussain — Wed, 27 Aug 2025 03:35:11 +0000

Why this post?

Today I set up a clean Python workspace on Ubuntu and ran my first NumPy code. I wrote down every step so you (or future‑me) can repeat it in minutes.

Prerequisites
Install Python and pip
Create a Virtual Environment
Install NumPy and Jupyter
Launch Jupyter Notebook
Your First NumPy Operations
Shut Down & Deactivate
Common Pitfalls & Fixes
What’s Next

Prerequisites

Ubuntu (works on 20.04/22.04/24.04+)
Terminal access
Basic comfort running shell commands

Tip: Commands with $ go in your terminal. Don’t copy the $ itself.

Install Python and pip

Ubuntu ships with Python 3, but let’s make sure the essentials are installed and up‑to‑date.

$ sudo apt update && sudo apt install -y python3 python3-pip python3-venv
$ python3 --version
$ pip3 --version

Create a Virtual Environment

Make a dedicated folder for your NumPy learning so packages don’t leak into system Python.

$ mkdir -p ~/numpy-learning && cd ~/numpy-learning
$ python3 -m venv numpy-venv
$ source numpy-venv/bin/activate
(numpy-venv) $ which python

You should see something like /home/you/numpy-learning/numpy-venv/bin/python. The (numpy-venv) prefix means the environment is active.

Why venv? Each project gets its own clean set of packages. No conflicts.

Install NumPy and Jupyter

First, bring pip up to date, then install the tools we need:

(numpy-venv) $ python -m pip install --upgrade pip
(numpy-venv) $ pip install numpy jupyter

Optional but handy for data work:

(numpy-venv) $ pip install matplotlib pandas

Verify installs:

(numpy-venv) $ python -c "import numpy as np; print(np.__version__)"
(numpy-venv) $ jupyter --version

Launch Jupyter Notebook

Start the notebook server. Your browser will open automatically (or you’ll get a URL with a token to paste into your browser):

(numpy-venv) $ jupyter notebook

In the Jupyter UI:

Click New → Python 3 (ipykernel).
Rename it to numpy_basics.ipynb (click the title at the top).

Take a look into my Jupyter UI

Your First NumPy Operations

Create a few cells and run the following. (Click a cell and press Shift+Enter to run.)

Cell 1 — Import & version

import numpy as np
print("NumPy version:", np.__version__)

Cell 2 — Create arrays

# 1D and 2D arrays
a = np.array([1, 2, 3, 4, 5])
b = np.array([[1, 2, 3],
              [4, 5, 6]])
print("a:", a)
print("b:\n", b)

Cell 3 — Properties

print("a.shape:", a.shape, "a.dtype:", a.dtype)
print("b.shape:", b.shape, "b.ndim:", b.ndim, "b.size:", b.size)

Cell 4 — Indexing & slicing

print("First of a:", a[0])
print("Last two of a:", a[-2:])
print("b second column:", b[:, 1])

Cell 5 — Vectorized operations

print("a * 2:", a * 2)
print("a + 10:", a + 10)
print("a ** 2:", a ** 2)

Cell 6 — Broadcasting

row = np.array([10, 20, 30])
print("b + row:\n", b + row)

Cell 7 — Aggregations

arr = np.array([10, 20, 30, 40, 50])
print("sum:", np.sum(arr))
print("mean:", np.mean(arr))
print("std:", np.std(arr))
print("min:", np.min(arr), "max:", np.max(arr))

Cell 8 — Reshape

reshaped = b.reshape(3, 2)
print("reshaped b (3x2):\n", reshaped)

That’s it — your first NumPy session is done!

Shut Down & Deactivate

When you’re finished for the day:

In the Jupyter tab: File → Save and Checkpoint.
In the terminal where Jupyter is running: press Ctrl + C and confirm to stop the server.
Deactivate your virtual environment:

(numpy-venv) $ deactivate

Next time, come back with:

$ cd ~/numpy-learning
$ source numpy-venv/bin/activate
(numpy-venv) $ jupyter notebook

Common Pitfalls & Fixes

❌ pip installs to the wrong place

Always use python -m pip ... inside your venv to be explicit.

(numpy-venv) $ python -m pip install numpy jupyter

❌ jupyter: command not found after install

Make sure your venv is active (look for (numpy-venv)), then reinstall:

$ source numpy-venv/bin/activate
(numpy-venv) $ python -m pip install --upgrade pip jupyter

❌ Mixing system Python and venv Python

Check which Python is running:

(numpy-venv) $ which python

It should point to your project’s numpy-venv folder.

❌ Permission errors

Avoid sudo pip. Use a venv. If needed, upgrade pip:

(numpy-venv) $ python -m pip install --upgrade pip

What’s Next

Try JupyterLab for a modern UI:

  (numpy-venv) $ pip install jupyterlab
  (numpy-venv) $ jupyter lab

Explore: np.arange, np.linspace, np.random.rand, np.vstack, np.hstack.
Add matplotlib and plot your arrays.
Day 2 topics: boolean masking, fancy indexing, broadcasting tricks, and small exercises.

If this helped, drop a comment or share what you built with NumPy today! 💡🚀

Text to speech

Anas Hussain — Fri, 21 Feb 2025 09:22:50 +0000

Use python library to save text as .mp3 file

Laravel Application Setup with Docker: A Step-by-Step Guide

Anas Hussain — Tue, 14 Jan 2025 22:02:25 +0000

Prerequisites

A system with Docker support (Linux, macOS, or Windows).
Basic knowledge of Laravel and Docker.

Step 1: Install Docker

For Linux

Update your system packages:

   sudo apt-get update

Install Docker:

   sudo apt-get install -y docker.io

Start and enable Docker:

   sudo systemctl start docker  
   sudo systemctl enable docker

For macOS and Windows

Download and install Docker Desktop from Docker's official site.

Step 2: Set Up the Laravel Project

Clone the Project Repository

git clone <your-repo-url>  
cd <project-name>

Install Dependencies

composer install

Prepare the Environment

Create a .env file:

   cp .env.example .env

Generate the application key:

   php artisan key:generate

Update the `Dockerfile` and `docker-compose.yml`

Example `Dockerfile`

FROM php:8.2-apache  
WORKDIR /var/www/html  
COPY . .  
RUN docker-php-ext-install pdo pdo_mysql

Example `docker-compose.yml`

version: '3.8'  
services:  
  app:  
    build: .  
    ports:  
      - "8080:80"  
    volumes:  
      - .:/var/www/html  
    environment:  
      - APACHE_LOG_DIR=/var/log/apache2  
    depends_on:  
      - db  

  db:  
    image: mysql:8.0  
    environment:  
      MYSQL_ROOT_PASSWORD: root  
      MYSQL_DATABASE: laravel  
      MYSQL_USER: laravel  
      MYSQL_PASSWORD: secret

Build and Start Docker Containers

docker-compose build  
docker-compose up -d

Set Permissions

chmod -R 775 bootstrap/cache storage  
chown -R www-data:www-data bootstrap/cache storage  
chmod 775 database  
chown -R www-data:www-data database  
chmod 664 database/database.sqlite  
chown www-data:www-data database/database.sqlite

Migrate the Database

php artisan migrate

Step 3: Access the Application

Once the containers are running, access your Laravel application at:

http://localhost:8080

Step 4: Reference

Find the complete project code on GitHub:

GitHub Repository Link

Step 5: Most Used Docker Commands

Basic Commands

docker --version: Check Docker version.
docker ps: List running containers.
docker ps -a: List all containers.
docker images: List all Docker images.
docker pull <image>: Pull an image from Docker Hub.
docker build -t <name> .: Build an image from a Dockerfile.
docker run -d -p <host-port>:<container-port> <image>: Run a container.
docker exec -it <container-id> bash: Access a container's shell.
docker stop <container-id>: Stop a running container.
docker rm <container-id>: Remove a stopped container.

Advanced Commands

docker logs <container-id>: View container logs.
docker-compose up: Start services defined in docker-compose.yml.
docker-compose down: Stop and remove services.
docker volume ls: List volumes.
docker network ls: List networks.
docker inspect <container-id>: Inspect container details.
docker system prune: Clean up unused containers, images, and volumes.
docker cp <src> <container>:<dest>: Copy files to a container.
docker stats: View real-time resource usage.
docker tag <image-id> <new-name>: Tag an image.

Refer to the Docker Documentation for more commands and usage examples.

By following these steps, you’ll have a Laravel application running in Docker in no time!

Laravel Authentication Using Passport

Anas Hussain — Thu, 02 Jan 2025 12:01:17 +0000

Mastering Laravel Authentication with Passport: A Step-by-Step Guide

Authentication is a cornerstone of modern web applications. In Laravel, Passport provides a full OAuth2 server implementation, enabling API authentication seamlessly. This guide walks you through the entire process of setting up Laravel Passport, from installation to securing and testing your API.

Introduction

Why Use Laravel Passport?

Laravel Passport simplifies the complexities of OAuth2 authentication by integrating it tightly with Laravel's ecosystem. With Passport, you can:

Authenticate API users securely.
Generate personal access tokens for mobile and web clients.
Manage token expiration and revocation easily.

Prerequisites

Before diving in, ensure you have:

A basic understanding of Laravel.
A Laravel project (v10.x or later is recommended) installed and configured with a database.
PHP 8.0 or later installed.

If you don’t have a project set up, create one with:

composer create-project --prefer-dist laravel/laravel passport-auth
cd passport-auth

Step 1: Install Laravel Passport

Install the Package

Run the following command to add Passport to your project:

composer require laravel/passport

Publish and Migrate Passport Files

Publish the Passport migrations and configuration files:

php artisan vendor:publish --tag=passport-migrations
php artisan migrate

Step 2: Configure Laravel Passport

Install Encryption Keys and Clients

Run the installation command:

php artisan passport:install

This generates encryption keys and creates OAuth clients in your database. Make note of the output, especially the client IDs and secrets.

Optional: Create a Personal Access Client

To create a personal access client explicitly, run:

php artisan passport:client --personal

Step 3: Update the Model

Add the HasApiTokens trait to your user model:

use Laravel\Passport\HasApiTokens;

class User extends Authenticatable
{
    use HasApiTokens, Notifiable;

    // Other properties...
}

Step 4: Update Auth Configuration

Configure Passport as the driver for API guards in config/auth.php:

'guards' => [
    'api' => [
        'driver' => 'passport',
        'provider' => 'users',
    ],
],

Step 5: Register Passport Routes

In App\Providers\AppServiceProvider, load Passport's routes:

use Laravel\Passport\Passport;

public function boot(): void
{
    Passport::routes();
    Passport::tokensExpireIn(now()->addDays(15));
    Passport::refreshTokensExpireIn(now()->addDays(30));
    Passport::personalAccessTokensExpireIn(now()->addMonths(6));
}

Step 6: Build Authentication API Endpoints

Add Routes

Define API routes in routes/api.php:

use App\Http\Controllers\AuthController;

Route::post('/register', [AuthController::class, 'register']);
Route::post('/login', [AuthController::class, 'login']);
Route::middleware('auth:api')->get('/user', [AuthController::class, 'user']);

Create the Authentication Controller

Implement authentication methods:

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;
use App\Models\User;

class AuthController extends Controller
{
    public function register(Request $request)
    {
        $request->validate([
            'name' => 'required|string|max:255',
            'email' => 'required|string|email|max:255|unique:users',
            'password' => 'required|string|min:8',
        ]);

        $user = User::create([
            'name' => $request->name,
            'email' => $request->email,
            'password' => bcrypt($request->password),
        ]);

        return response()->json([
            'token' => $user->createToken('API Token')->accessToken,
        ], 201);
    }

    public function login(Request $request)
    {
        $credentials = $request->only('email', 'password');

        if (!Auth::attempt($credentials)) {
            return response()->json(['message' => 'Invalid credentials'], 401);
        }

        return response()->json([
            'token' => Auth::user()->createToken('API Token')->accessToken,
        ]);
    }

    public function user()
    {
        return response()->json(Auth::user());
    }
}

Step 7: Set Permissions for Encryption Keys

Ensure secure access to Passport keys:

chmod 600 storage/oauth-private.key storage/oauth-public.key
chown www-data:www-data storage/oauth-private.key storage/oauth-public.key

Verify permissions:

ls -l storage/oauth-*.key

Expected output:

-rw------- 1 www-data www-data 1704 Jan  2 12:00 oauth-private.key
-rw------- 1 www-data www-data  800 Jan  2 12:00 oauth-public.key

Step 8: Test the API

Use Postman or any API client to test endpoints:

Register: Send a POST request to /register with name, email, and password.
Login: Send a POST request to /login with email and password.
Get User Data: Send a GET request to /user with the token in the Authorization header.

Best Practices

Use HTTPS in production.
Rotate encryption keys periodically.
Validate inputs thoroughly.
Limit token scopes for better security.

Conclusion

Congratulations! You've successfully implemented API authentication using Laravel Passport. This setup provides a robust foundation for securing your API. Explore advanced Passport features like scopes, token revocation, and client credentials to further enhance your application's security.

Laravel Zero Downtime Deployments with Envoy

Anas Hussain — Sat, 28 Dec 2024 11:28:26 +0000

Introduction

Introduce the topic by explaining what Laravel Envoy is, its purpose, and why developers should consider using it for deployment automation. Highlight benefits like simplicity, SSH-based execution, and reusable scripts.

Example Introduction:

"Deploying Laravel projects manually can be repetitive and error-prone. With Laravel Envoy, you can automate your deployment process using simple and readable syntax. In this guide, I'll show you how to set up and use Laravel Envoy for seamless deployments."

Advantages of Zero Downtime Deployment

No Downtime: Users always interact with a live application during deployment.
Safe Rollback: If deployment fails, the previous release remains active.
Organized Releases: Each deployment is stored in a timestamped directory.

Step 1: Install Laravel Envoy

Explain how to install Laravel Envoy globally using Composer.

composer global require laravel/envoy

Ensure readers add Composer's global binaries to their system PATH if not already done.

export PATH="$PATH:$HOME/.composer/vendor/bin"

Or Install to your project dir

composer require laravel/envoy --dev

Step 2: Set Up SSH Access to Your Server

Explain how to set up SSH access to the server. Include steps for generating an SSH key and adding it to the server for password-less access.

ssh-keygen -t rsa -b 4096 -C "your_email@example.com"
ssh-copy-id username@your-server-ip

Test the connection:

ssh username@your-server-ip

Step 3: Create the Envoy Configuration File

Show how to create an envoy.blade.php file in the root of the Laravel project and explain its structure.

Example Configuration:

@servers(['web' => 'username@your-server-ip'])

@setup
    $repository = 'git@github.com:your-username/your-repo.git';
    $releases_dir = '/var/www/your-project/releases';
    $app_dir = '/var/www/your-project';
    $release = date('YmdHis');
    $new_release_dir = $releases_dir . '/' . $release;
@endsetup

@story('deploy')
    clone_repository
    run_composer
    update_symlinks
@endstory

@task('clone_repository', ['on' => 'web'])
    [ -d {{ $releases_dir }} ] || mkdir -p {{ $releases_dir }};
    git clone --branch=main {{ $repository }} {{ $new_release_dir }};
@endtask

@task('run_composer', ['on' => 'web'])
    cd {{ $new_release_dir }};
    composer install --optimize-autoloader --no-dev;
@endtask

@task('update_symlinks', ['on' => 'web'])
    ln -nfs {{ $new_release_dir }} {{ $app_dir }}/current;
    ln -nfs {{ $app_dir }}/shared/.env {{ $new_release_dir }}/.env;
@endtask

Explain each section:

@servers: Define remote servers.
@setup: Initialize variables for the deployment process.
@story: Sequence of tasks to execute.
@task: Individual steps like cloning the repository or running Composer.

Step 4: Deploy the Laravel Project

Explain how to run the deployment command using Envoy:

envoy run deploy

Highlight how Envoy connects via SSH and executes tasks in sequence.

Step 5: Test the Deployment

Guide readers on verifying the deployment:

Check the project directory on the server.
Ensure the symlinks are correctly pointing to the latest release.
Test the application in the browser.

Step 6: Add Cache Clearing and Maintenance Mode

Show how to enhance the script with cache clearing and maintenance mode commands.

Example Addition:

@task('clear_cache', ['on' => 'web'])
    php {{ $app_dir }}/current/artisan config:cache;
    php {{ $app_dir }}/current/artisan route:cache;
    php {{ $app_dir }}/current/artisan view:cache;
@endtask

@task('maintenance_mode', ['on' => 'web'])
    php {{ $app_dir }}/current/artisan down --message="Deployment in progress";
@endtask

Bonus: Rollback to Previous Release

Include an optional feature for rolling back to the previous release in case of failure.

Example Rollback Task:

@task('rollback', ['on' => 'web'])
    ln -nfs {{ $releases_dir }}/$(ls -t {{ $releases_dir }} | tail -n 2 | head -n 1) {{ $app_dir }}/current;
@endtask

Common Issues and Debugging Tips

Provide solutions to common problems like:

SSH authentication errors.
Missing permissions on the server.
Envoy not being recognized as a command.

"I hope this guide helps you simplify your Laravel deployments with Envoy. Let me know your thoughts or questions below! Don’t forget to follow for more Laravel tutorials."

References

Conclusion

Wrap up by emphasizing the power of automation in modern development workflows and inviting readers to share feedback or ask questions in the comments.

Laravel factory and seeder

Anas Hussain — Mon, 23 Dec 2024 04:39:58 +0000

1. Creating a Factory

Step 1: Generate the Factory

Run the following command to create a factory for your model:

php artisan make:factory ModelNameFactory --model=ModelName

Example:

php artisan make:factory DepartmentFactory --model=Department

This will create a file at database/factories/DepartmentFactory.php.

Step 2: Define the Factory

Open the factory file and define the data structure. Use realistic data for better testing.

namespace Database\Factories;

use App\Models\Department;
use Illuminate\Database\Eloquent\Factories\Factory;

class DepartmentFactory extends Factory
{
    protected $model = Department::class;

    public function definition()
    {
        return [
            'name' => $this->faker->word, // Generates a random department name
            'description' => $this->faker->sentence, // Short description
            'created_at' => now(),
            'updated_at' => now(),
        ];
    }
}

2. Creating a Seeder

Step 1: Generate the Seeder

Run the following command to create a seeder:

php artisan make:seeder SeederName

Example:

php artisan make:seeder DepartmentSeeder

This will create a file at database/seeders/DepartmentSeeder.php.

Step 2: Define the Seeder

In the seeder file, use the factory to generate records.

namespace Database\Seeders;

use App\Models\Department;
use Illuminate\Database\Seeder;

class DepartmentSeeder extends Seeder
{
    public function run()
    {
        // Generate 10 departments
        Department::factory(10)->create();
    }
}

3. Register the Seeder

Step 1: Add Seeder to DatabaseSeeder

In database/seeders/DatabaseSeeder.php, call the DepartmentSeeder:

namespace Database\Seeders;

use Illuminate\Database\Seeder;

class DatabaseSeeder extends Seeder
{
    public function run()
    {
        $this->call([
            DepartmentSeeder::class,
        ]);
    }
}

4. Run the Seeder

Run the following command to seed your database:

php artisan db:seed

To run a specific seeder:

php artisan db:seed --class=DepartmentSeeder

5. Professional Practices

Use Relationships in Factories If your model has relationships, define them in the factory:

   'user_id' => User::factory(), // Generates a user and assigns it to this model

Use Custom States Create states for specific variations of the model:

   public function admin()
   {
       return $this->state([
           'role' => 'admin',
       ]);
   }

Use it in seeders:

   Department::factory()->admin()->create();

Organize Seeders For large projects, organize seeders into modules:

   database/
   └── seeders/
       ├── Admin/
       │   ├── UserSeeder.php
       │   └── RoleSeeder.php
       ├── Product/
       │   └── ProductSeeder.php
       └── DepartmentSeeder.php

Testing with Factories Use factories in tests to generate test data:

   $department = Department::factory()->create();
   $this->assertDatabaseHas('departments', ['id' => $department->id]);

Clear and Seed For fresh testing, run:

   php artisan migrate:fresh --seed

6. Example Usage

If you have a Department model, you can now generate:

Random departments:

  Department::factory()->count(10)->create();

Custom departments:

  Department::factory()->create([
      'name' => 'Human Resources',
  ]);

Laravel Centralized Exception Handling

Anas Hussain — Sat, 21 Dec 2024 17:17:20 +0000

Introduction

Error handling is critical for building robust and user-friendly applications. In this post, we’ll explore three approaches to exception handling in Laravel and focus on configuring centralized exception handling in the bootstrap/app.php file using withExceptions.

Why Centralized Error Handling?

Keeps the code DRY by avoiding repetitive try-catch blocks.
Enhances maintainability by consolidating error handling logic in one place.
Improves user experience with consistent error responses.

Exploring Approaches to Exception Handling

1. Exception Handling per Method

Handle exceptions locally within each method.
Drawback: Repetitive code and harder to maintain.

Example:

public function store(Request $request) {
    try {
        // Code logic here
    } catch (QueryException $e) {
        return back()->with('error', 'Database error occurred.');
    }
}

2. Exception Handling in `bootstrap/app.php`

Centralized error handling at the application level.
Flexible, DRY, and maintainable.
Focus of this tutorial.

3. Custom Middleware for Exception Handling

Ideal for handling specific exceptions for routes or groups.
Adds complexity when handling application-wide errors.

Configuring Exception Handling in `bootstrap/app.php`

Step 1: Update the `bootstrap/app.php` File

Use Laravel's Application class to set up centralized exception handling with withExceptions.

Here’s the complete code snippet:

<?php

use Illuminate\Foundation\Application;
use Illuminate\Foundation\Configuration\Exceptions;
use Illuminate\Foundation\Configuration\Middleware;
use App\Http\Middleware\EnsureAdminIsAuthenticated;
use Illuminate\Http\Request;
use Illuminate\Database\QueryException;
use Illuminate\Database\Eloquent\ModelNotFoundException;
use Illuminate\Validation\ValidationException;
use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;

return Application::configure(basePath: dirname(__DIR__))
    ->withRouting(
        web: __DIR__ . '/../routes/web.php',
        api: __DIR__ . '/../routes/api.php',
        commands: __DIR__ . '/../routes/console.php',
        health: '/up',
    )
    ->withMiddleware(function (Middleware $middleware) {
        $middleware->alias([
            "admin_auth" => EnsureAdminIsAuthenticated::class,
        ]);
    })
    ->withExceptions(function (Exceptions $exceptions) {

        // Handling database query exceptions
        $exceptions->render(function (QueryException $e, Request $request) {
            Log::error('Database error: ' . $e->getMessage(), [
                'error' => $e->getMessage(),
                'url' => $request->fullUrl(),
                'user_id' => auth()->check() ? auth()->id() : 'guest',
            ]);

            return redirect()->back()->with('warning', 'A database error occurred. Please try again.');
        });

        // Handling not found exceptions
        $exceptions->render(function (NotFoundHttpException $e, Request $request) {
            if ($e->getPrevious() instanceof ModelNotFoundException) {
                Log::error('Model not found: ' . $e->getMessage(), [
                    'error' => $e->getMessage(),
                    'url' => $request->fullUrl(),
                    'user_id' => auth()->check() ? auth()->id() : 'guest',
                ]);

                return redirect()->back()->with('warning', 'Requested resource not found.');
            }
        });

        // Handling validation exceptions
        $exceptions->render(function (ValidationException $e, Request $request) {
            Log::error('Validation error: ' . $e->getMessage(), [
                'user_id' => auth()->id(),
                'url' => $request->fullUrl(),
                'input' => $request->all(),
            ]);

            return redirect()->back()->withErrors($e->validator)->withInput();
        });

        // Handling generic exceptions
        $exceptions->render(function (Exception $e, Request $request) {
            Log::error('An unexpected error occurred.', [
                'error' => $e->getMessage(),
                'trace' => $e->getTraceAsString(),
                'url' => $request->fullUrl(),
                'user_id' => auth()->check() ? auth()->id() : 'guest',
            ]);

            return redirect()->back()->with('warning', 'An unexpected error occurred. Please try again.');
        });

    })->create();

Step 2: Explanation of Each Exception

QueryException

Catches database-related errors.
Logs the error details and redirects users back with a warning.

ModelNotFoundException

Handles cases when a model cannot be found.
Logs the error and displays a user-friendly message.

ValidationException

Captures validation errors and sends them back to the form.
Logs the input data and errors for debugging.

Generic Exception

Catches all other unhandled exceptions.
Logs the error message and stack trace for further investigation.

Step 3: Testing the Configuration

Trigger each type of exception (e.g., invalid form data, nonexistent routes).
Verify the logs contain detailed error information.
Ensure the user sees friendly and consistent error messages.

Advantages of This Approach

Centralized Control: All exception logic in one place.
Improved User Experience: Users are redirected with helpful messages.
Debugging Made Easy: Logs provide detailed context for errors.

Conclusion

Centralized exception handling in bootstrap/app.php is an efficient way to manage errors in a Laravel application. By following this guide, you can handle exceptions systematically, maintain clean controllers, and enhance user experience.

Laravel Request Validation

Anas Hussain — Fri, 20 Dec 2024 18:09:01 +0000

Introduction:

Start with why request validation is important in Laravel:

Ensures clean, validated data for robust applications.
Makes controllers cleaner and more manageable.
Offers flexibility for custom rules and messages.

Mention briefly what the readers will learn:

How to create and configure a request class in Laravel.
Setting up validation rules and custom error messages.
Integrating the request class into a controller.

1. Creating a Request File

Begin by explaining what a request class is:

A request class centralizes input validation logic.

Command to Create the Request File:

php artisan make:request DesignationRequest

Explain what happens:

Laravel generates a DesignationRequest class in the App\Http\Requests directory.

2. Understanding the Generated Request Class

a) The `authorize()` Method

By default, authorize() returns false.
Change it to true to allow all users or implement authorization logic if needed.

public function authorize()
{
    return true;
}

b) The `rules()` Method

Define validation rules for the input fields.

Example:

public function rules()
{
    return [
        'name' => 'required|string|min:3|max:255',
        'description' => 'nullable|string|max:555',
    ];
}

c) The `messages()` Method

Customize error messages for specific fields.

Example:

public function messages()
{
    return [
        'name.required' => 'The designation name is required',
        'name.min' => 'The designation name must be atleast 3 characters',
        'name.max' => 'The designation name must not exceed 255 characters',
        'description.max' => 'The description must not exceed 555 characters'
    ];
}

3. Integrating the Request Class in the Controller

Explain how to configure the request file with a controller.

Add the use statement:

use App\Http\Requests\DesignationRequest;

Update the store method to use the request class:

public function store(DesignationRequest $request)
{
    $designation = Designations::create([
        'name' => $request->validated('name'),
        'description' => $request->validated('description'),
        'active_status' => $request->has('active_status') ? 1 : 0,
    ]);

    return redirect()->route('admin.designations.index')
        ->with('success', 'Designation created successfully!');
}

Laravel try-catch

Anas Hussain — Thu, 19 Dec 2024 04:15:10 +0000

1. Understand Laravel's Built-in Exception Handling

Laravel already provides a global exception handler in app/Exceptions/Handler.php. This is the first place exceptions are caught if not handled elsewhere. You can customize this to manage exceptions application-wide.

Register Custom Handlers:

  public function register()
  {
      $this->reportable(function (\Throwable $e) {
          \Log::error($e->getMessage());
      });
  }

2. Types of Exceptions You May Encounter

Here are some common exceptions to handle in Laravel:

Database Exceptions:
- QueryException: For SQL errors like syntax or constraint violations.
- ModelNotFoundException: When findOrFail fails to retrieve a record.

   try {
       $user = User::findOrFail($id);
   } catch (ModelNotFoundException $e) {
       \Log::error('User not found: ' . $e->getMessage());
       return response()->json(['error' => 'User not found'], 404);
   }

Validation Exceptions:
- ValidationException: When validation fails.

   try {
       $validated = $request->validate([
           'name' => 'required|string|max:255',
       ]);
   } catch (ValidationException $e) {
       return back()->withErrors($e->validator)->withInput();
   }

File System Exceptions:
- FileNotFoundException: When a file is missing.
- FileException: For general file system errors.

   try {
       Storage::disk('local')->delete($filename);
   } catch (FileException $e) {
       \Log::error('File operation failed: ' . $e->getMessage());
   }

Authentication Exceptions:
- AuthenticationException: When a user is not authenticated.
- AuthorizationException: For unauthorized access.

   try {
       $this->authorize('update', $post);
   } catch (AuthorizationException $e) {
       abort(403, 'You are not authorized to update this post.');
   }

HTTP Client Exceptions:
- RequestException: For errors in HTTP requests using Guzzle or Laravel's HTTP client.

   try {
       $response = Http::get('https://example.com/api');
   } catch (RequestException $e) {
       \Log::error('API call failed: ' . $e->getMessage());
   }

3. Best Practices for Using `try-catch`

A. Catch Specific Exceptions

Always catch specific exceptions rather than the generic Exception or Throwable. This ensures you can handle different errors appropriately.

try {
    $data = SomeModel::findOrFail($id);
} catch (ModelNotFoundException $e) {
    return response()->json(['error' => 'Record not found'], 404);
} catch (\Exception $e) {
    return response()->json(['error' => 'An unexpected error occurred'], 500);
}

B. Use Exception Messages and Codes

Include custom error messages and HTTP status codes for meaningful responses.

try {
    $response = Http::post('https://api.example.com/data', $data);
} catch (RequestException $e) {
    return response()->json(['error' => 'Failed to connect to API'], 503);
}

C. Log Exceptions

Use Laravel's Log facade to record exceptions for debugging purposes. Always include context.

try {
    $user = User::findOrFail($id);
} catch (ModelNotFoundException $e) {
    \Log::error('User retrieval failed', ['id' => $id, 'error' => $e->getMessage()]);
}

D. Fallbacks and Recovery

Design fallback mechanisms where applicable, such as retrying operations or defaulting to safe behavior.

try {
    $data = Cache::remember('data_key', 60, function () {
        return SomeModel::all();
    });
} catch (QueryException $e) {
    \Log::error('Database query failed: ' . $e->getMessage());
    $data = []; // Return an empty dataset as a fallback.
}

E. Avoid Overuse

Not every piece of code needs a try-catch block. Use it only for code that is prone to failure, such as database queries, file operations, or external API calls.

4. Advanced Techniques for Robustness

A. Custom Exception Classes

Define your own exception classes for specific scenarios.

class UserNotActiveException extends \Exception
{
    public function __construct($message = "User account is not active.")
    {
        parent::__construct($message, 403);
    }
}

B. Centralized Exception Handling

Leverage Handler.php for centralizing logic for common exceptions.

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

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

C. Retry Mechanism

Laravel's retry() helper can attempt an operation multiple times before failing.

use Illuminate\Support\Facades\Retry;

$response = retry(3, function () {
    return Http::get('https://example.com');
}, 100);

D. Third-Party Monitoring

Integrate tools like Sentry or Bugsnag for advanced error monitoring and reporting.

5. Testing Exception Scenarios

Write Unit Tests: Mock exceptions to ensure your try-catch blocks work as intended.

  public function testDeleteNonExistentRecord()
  {
      $this->expectException(ModelNotFoundException::class);

      $this->controller->delete(999); // Assuming 999 does not exist.
  }

Simulate Failures: Test database, file, or API failures in a controlled environment.

6. Example: Comprehensive Use of `try-catch`

public function store(Request $request)
{
    try {
        $validated = $request->validate([
            'name' => 'required|string|max:255',
            'email' => 'required|email|unique:users',
        ]);

        $user = User::create($validated);

        return response()->json(['message' => 'User created successfully', 'user' => $user], 201);

    } catch (ValidationException $e) {
        return response()->json(['error' => 'Validation failed', 'details' => $e->errors()], 422);

    } catch (QueryException $e) {
        \Log::error('Database error: ' . $e->getMessage());
        return response()->json(['error' => 'Database error occurred'], 500);

    } catch (\Exception $e) {
        \Log::error('Unexpected error: ' . $e->getMessage());
        return response()->json(['error' => 'An unexpected error occurred'], 500);
    }
}

Laravel Factory and Seeder Implementation

Anas Hussain — Tue, 17 Dec 2024 08:58:17 +0000

Definitions

What is a Laravel Factory?

A Laravel Factory is a feature that allows developers to generate fake data for testing or seeding purposes. It defines a default "state" for a model using the definition() method. Factories leverage Faker to create realistic and random data that mimic real-world input.

What is a Laravel Seeder?

A Laravel Seeder is used to populate the database with dummy data or default values. It is typically used to set up initial data for development, testing, or production environments. Seeders work hand-in-hand with factories to generate large amounts of structured data.

1. Create a Factory

To generate a factory for the Designations model, use the following Artisan command:

php artisan make:factory DesignationFactory --model=Designations

2. Create a Seeder

Generate a seeder for the Designations table:

php artisan make:seeder DesignationSeeder

3. Update the `Designations` Model

Ensure the following changes are added to your Designations model file:

File: app/Models/Designations.php

<?php

namespace App\Models;

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

class Designations extends Model
{
    use HasFactory;

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

4. Update the Seeder File

Modify the seeder file to use the factory for creating dummy records.

File: database/seeders/DesignationsSeeder.php

<?php

namespace Database\Seeders;

use Illuminate\Database\Seeder;
use App\Models\Designations;

class DesignationsSeeder extends Seeder
{
    /**
     * Run the database seeds.
     */
    public function run(): void
    {
        Designations::factory()
            ->count(3) // Number of records to create
            ->create();
    }
}

5. Update the Factory File

Define the attributes for the Designations model in the factory file.

File: database/factories/DesignationsFactory.php

<?php

namespace Database\Factories;

use App\Models\Designations;
use Illuminate\Database\Eloquent\Factories\Factory;

class DesignationsFactory extends Factory
{
    protected $model = Designations::class;

    /**
     * Define the model's default state.
     */
    public function definition(): array
    {
        return [
            'name' => fake()->name(),
            'description' => fake()->sentence(10),
        ];
    }
}

6. Run the Seeder

Run the seeder to populate the database with test data:

php artisan db:seed --class=DesignationsSeeder

Conclusion

By following these steps:

You have created a Factory for generating dummy data.
You have set up a Seeder to populate the database.
Your model is properly configured to use HasFactory.

This approach ensures a clean and structured way to seed test data into your Laravel application.

Laravel migrations

Anas Hussain — Tue, 17 Dec 2024 06:04:25 +0000

1. Migration Basics

Create a Migration

php artisan make:migration create_table_name_table

Example:

php artisan make:migration create_users_table

Run Migrations

Run all pending migrations:

php artisan migrate

Rollback Migrations

Rollback the most recent batch of migrations:

php artisan migrate:rollback

Rollback & Re-run Migrations

Rollback and re-run all migrations:

php artisan migrate:refresh

Reset Migrations

Rollback all migrations completely:

php artisan migrate:reset

Run Specific Migration

Run a single migration file:

php artisan migrate --path=/database/migrations/filename.php

Status of Migrations

Check migration status (applied or pending):

php artisan migrate:status

2. Table Operations

Create a Table

To create a table, use:

Schema::create('table_name', function (Blueprint $table) {
    $table->id();
    $table->string('name');
    $table->timestamps();
});

Modify an Existing Table

To modify an existing table, you need to create a new migration:

php artisan make:migration add_columns_to_table_name_table

3. Adding Columns

Add a New Column

Schema::table('table_name', function (Blueprint $table) {
    $table->string('new_column');
});

Add Multiple Columns

Schema::table('table_name', function (Blueprint $table) {
    $table->integer('age');
    $table->string('address')->nullable();
});

Add Column with Default Value

Schema::table('table_name', function (Blueprint $table) {
    $table->boolean('status')->default(1);
});

4. Dropping Columns

Drop a Single Column

Schema::table('table_name', function (Blueprint $table) {
    $table->dropColumn('column_name');
});

Drop Multiple Columns

Schema::table('table_name', function (Blueprint $table) {
    $table->dropColumn(['column1', 'column2']);
});

5. Rename Operations

Rename a Column

Schema::table('table_name', function (Blueprint $table) {
    $table->renameColumn('old_name', 'new_name');
});

Rename a Table

Schema::rename('old_table_name', 'new_table_name');

6. Altering Columns

Change Column Type

Install the doctrine/dbal package:

composer require doctrine/dbal

Then use:

Schema::table('table_name', function (Blueprint $table) {
    $table->string('column_name')->change();
});

Make Column Nullable

Schema::table('table_name', function (Blueprint $table) {
    $table->string('column_name')->nullable()->change();
});

7. Indexing

Add an Index

$table->index('column_name');

Add a Unique Index

$table->unique('column_name');

Add a Composite Index

$table->index(['column1', 'column2']);

Drop an Index

$table->dropIndex('index_name');

Drop a Unique Index

$table->dropUnique('table_name_column_name_unique');

8. Foreign Keys

Add Foreign Key

Schema::table('table_name', function (Blueprint $table) {
    $table->unsignedBigInteger('user_id');
    $table->foreign('user_id')->references('id')->on('users')->onDelete('cascade');
});

Drop Foreign Key

$table->dropForeign('table_name_user_id_foreign');

9. Timestamps and Soft Deletes

Add Timestamps

$table->timestamps();

Add Soft Deletes

$table->softDeletes();

Drop Soft Deletes

$table->dropSoftDeletes();

10. Miscellaneous

Add Remember Token

$table->rememberToken();

Add UUID as Primary Key

$table->uuid('id')->primary();

Check Table Existence

if (!Schema::hasTable('table_name')) {
    Schema::create('table_name', function (Blueprint $table) {
        $table->id();
    });
}

Check Column Existence

if (!Schema::hasColumn('table_name', 'column_name')) {
    Schema::table('table_name', function (Blueprint $table) {
        $table->string('column_name');
    });
}

11. Migration Rollbacks with Specific Steps

Rollback Last 'N' Migrations

Rollback a specific number of migrations:

php artisan migrate:rollback --step=2

Rollback and Re-run Specific Steps

php artisan migrate:refresh --step=2

12. Running Migrations in Production

To force migration in production without a prompt:

php artisan migrate --force

Practice Tips

Practice table creation with all column types (string, integer, boolean, json, text, etc.).
Simulate database changes using rollback, refresh, and reset.
Implement foreign key constraints with cascading deletes.
Work on adding soft deletes and testing data recovery.
Try renaming columns and tables using migration.

Laravel Data Encryption and Decryption

Anas Hussain — Wed, 11 Dec 2024 16:02:38 +0000

This guide explains how to implement encryption and decryption for sensitive data in Laravel models. By following these steps, you can secure data before storing it in the database and decrypt it when retrieving it.

Prerequisites

Laravel: Ensure you're using a Laravel project.
Encryption Key: Laravel automatically generates an APP_KEY in the .env file. This key is used by Laravel's encryption service.

Step 1: Setup Encryption in the Model

In the model, we will use Laravel's encrypt() and decrypt() functions to handle encryption and decryption automatically for specified fields.

Doctor Model

Create or update the Doctor model with encryption and decryption methods. We will encrypt fields such as first_name, last_name, email, and mobile before saving them in the database.

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Facades\Crypt;

class Doctor extends Model
{
    protected $fillable = [
        'first_name', 'last_name', 'email', 'mobile', 'hashed_email', 'password'
    ];

    // Automatically encrypt attributes when setting them
    public function setFirstNameAttribute($value)
    {
        $this->attributes['first_name'] = encrypt($value);
    }

    public function setLastNameAttribute($value)
    {
        $this->attributes['last_name'] = encrypt($value);
    }

    public function setEmailAttribute($value)
    {
        $this->attributes['email'] = encrypt($value);
    }

    public function setMobileAttribute($value)
    {
        $this->attributes['mobile'] = encrypt($value);
    }

    // Automatically decrypt attributes when getting them
    public function getFirstNameAttribute($value)
    {
        return decrypt($value);
    }

    public function getLastNameAttribute($value)
    {
        return decrypt($value);
    }

    public function getEmailAttribute($value)
    {
        return decrypt($value);
    }

    public function getMobileAttribute($value)
    {
        return decrypt($value);
    }
}

Explanation

Setter Methods: Use set{AttributeName}Attribute() to encrypt data before it is stored in the database.
Getter Methods: Use get{AttributeName}Attribute() to decrypt data when it is retrieved from the database.

Step 2: Controller for Data Storage and Retrieval

In the controller, you can handle validation and call the model’s encrypted attributes directly without additional encryption/decryption steps.

DoctorController

The DoctorController handles registration by validating input data, encrypting it via the model, and saving it in the database. When fetching the doctor data, it will automatically decrypt the sensitive fields.

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use App\Models\Doctor;
use Illuminate\Support\Facades\Hash;

class DoctorController extends Controller
{
    public function register(Request $request)
    {
        // Validate the incoming request
        $validatedData = $request->validate([
            'first_name' => 'required|string|max:255',
            'last_name' => 'required|string|max:255',
            'email' => 'required|string|email|max:255|unique:doctors,email',
            'mobile' => 'required|string|size:10|unique:doctors,mobile',
            'password' => 'required|string|min:8|confirmed',
        ]);

        // Hash the email to ensure uniqueness
        $hashedEmail = hash('sha256', $validatedData['email']);

        // Create a new doctor record (model will handle encryption)
        $doctor = Doctor::create([
            'first_name' => $validatedData['first_name'],
            'last_name' => $validatedData['last_name'],
            'email' => $validatedData['email'],
            'hashed_email' => $hashedEmail,
            'mobile' => $validatedData['mobile'],
            'password' => Hash::make($validatedData['password']),
        ]);

        return response()->json([
            'message' => 'Doctor registered successfully',
            'doctor' => $doctor
        ], 201);
    }

    public function show($id)
    {
        // Fetch the doctor record (model will decrypt the data automatically)
        $doctor = Doctor::findOrFail($id);

        return response()->json($doctor);
    }
}

Explanation

register Method: Validates the incoming request, creates a new doctor record, and automatically encrypts fields like first_name, last_name, email, and mobile due to the model's encryption methods.
show Method: Retrieves a doctor record by ID. The model's getter methods decrypt the sensitive fields automatically before returning the data.

Step 3: Database Configuration

Ensure that the doctors table columns for sensitive data are of a sufficient length to handle encrypted data (typically, TEXT or LONGTEXT).

Example migration setup:

Schema::create('doctors', function (Blueprint $table) {
    $table->id();
    $table->text('first_name');
    $table->text('last_name');
    $table->text('email');
    $table->string('hashed_email')->unique(); // SHA-256 hashed email
    $table->text('mobile');
    $table->string('password');
    $table->timestamps();
});

Note: Since encrypted values can be significantly longer than plaintext values, TEXT is preferred for encrypted fields.

Step 4: Handling Decryption Exceptions

For enhanced error handling, wrap decryption logic in try-catch blocks in the model’s getters:

public function getFirstNameAttribute($value)
{
    try {
        return decrypt($value);
    } catch (DecryptException $e) {
        return null; // Or handle the error as needed
    }
}

Additional Notes

Environment Security: Ensure the APP_KEY is stored securely in the .env file. This key is critical for encryption/decryption.
Data Backup: If data integrity is crucial, ensure you have a backup mechanism, as encrypted data cannot be recovered without the correct APP_KEY.

Summary

Model Encryption: Use setter methods to encrypt data before storing and getter methods to decrypt data upon retrieval.
Controller Logic: The controller can handle encrypted fields directly without additional encryption code.
Database Configuration: Use TEXT or LONGTEXT columns for encrypted fields.
Security Considerations: Secure your APP_KEY and use exception handling in getters for decryption errors.

By following this approach, you can easily implement secure encryption and decryption for sensitive data in your Laravel application. Let me know if you have any further questions!

DEV Community: Anas Hussain

NumPy on Ubuntu: From Zero to First Arrays

Why this post?

Table of Contents

Prerequisites

Install Python and pip

Create a Virtual Environment

Install NumPy and Jupyter

Launch Jupyter Notebook

Your First NumPy Operations

Shut Down & Deactivate

Common Pitfalls & Fixes

What’s Next

Text to speech

Laravel Application Setup with Docker: A Step-by-Step Guide

Prerequisites

Step 1: Install Docker

For Linux

For macOS and Windows

Step 2: Set Up the Laravel Project

Clone the Project Repository

Install Dependencies

Prepare the Environment

Update the Dockerfile and docker-compose.yml

Example Dockerfile

Example docker-compose.yml

Build and Start Docker Containers

Set Permissions

Migrate the Database

Step 3: Access the Application

Step 4: Reference

Step 5: Most Used Docker Commands

Basic Commands

Advanced Commands

Laravel Authentication Using Passport

Mastering Laravel Authentication with Passport: A Step-by-Step Guide

Introduction

Why Use Laravel Passport?

Prerequisites

Step 1: Install Laravel Passport

Install the Package

Publish and Migrate Passport Files

Step 2: Configure Laravel Passport

Install Encryption Keys and Clients

Optional: Create a Personal Access Client

Step 3: Update the Model

Step 4: Update Auth Configuration

Step 5: Register Passport Routes

Step 6: Build Authentication API Endpoints

Add Routes

Create the Authentication Controller

Step 7: Set Permissions for Encryption Keys

Step 8: Test the API

Best Practices

Conclusion

Laravel Zero Downtime Deployments with Envoy

Introduction

Advantages of Zero Downtime Deployment

Step 1: Install Laravel Envoy

Step 2: Set Up SSH Access to Your Server

Step 3: Create the Envoy Configuration File

Step 4: Deploy the Laravel Project

Step 5: Test the Deployment

Step 6: Add Cache Clearing and Maintenance Mode

Bonus: Rollback to Previous Release

Common Issues and Debugging Tips

References

Conclusion

Laravel factory and seeder

1. Creating a Factory

Step 1: Generate the Factory

Step 2: Define the Factory

2. Creating a Seeder

Step 1: Generate the Seeder

Step 2: Define the Seeder

3. Register the Seeder

Step 1: Add Seeder to DatabaseSeeder

4. Run the Seeder

5. Professional Practices

6. Example Usage

Update the `Dockerfile` and `docker-compose.yml`

Example `Dockerfile`

Example `docker-compose.yml`

2. Exception Handling in `bootstrap/app.php`

Configuring Exception Handling in `bootstrap/app.php`

Step 1: Update the `bootstrap/app.php` File

a) The `authorize()` Method

b) The `rules()` Method

c) The `messages()` Method

3. Best Practices for Using `try-catch`

6. Example: Comprehensive Use of `try-catch`

3. Update the `Designations` Model