DEV Community: Kepson Diaz

How to create a scheduled Task in Laravel ?

Kepson Diaz — Thu, 29 Aug 2024 15:45:04 +0000

Hello everyone! Today, I’m going to walk you through the process of creating a scheduled task in Laravel. We’ll take the example of sending a daily marketing email to users.

Step 1: Create the Email Class

First, let’s create a new Mailable class using the following Artisan command:

php artisan make:mail DailyMarketingEmail --view

This command generates a new Mailable class in the App/Mail directory, along with a corresponding view file, daily-marketing-email.blade.php, inside the resources/views/mail/ directory. You can customize the content of the email within this view file.

Step 2: Create an Artisan Command

Next, we’ll create an Artisan command that will handle sending our DailyMarketingEmail. Run the following command:

php artisan make:command SendDailyMarketingEmail

This command will generate a new command class in the app/Console/Commands directory.

Step 3: Understand the Command Structure

After generating your command, you'll see two key properties in the generated class:

protected $signature: This defines the name and signature of your Artisan command.
protected $description: This provides a description of your command.
The handle method in this class is where you’ll define the logic of your command.

After everything is set up, you can list all your Artisan commands by running:

php artisan

You should see your command in the list:

Step 4: Implement the Command Logic

Now, let’s define the logic within the handle method to send the marketing emails:

<?php

namespace App\Console\Commands;

use App\Models\User;
use Illuminate\Console\Command;
use App\Mail\DailyMarketingMail;
use Illuminate\Support\Facades\Mail;

class SendDailyMarketingEmails extends Command
{
    /**
     * The name and signature of the console command.
     *
     * @var string
     */
    protected $signature = 'app:send-daily-marketing-emails';

    /**
     * The console command description.
     *
     * @var string
     */
    protected $description = 'Send a marketing email to all users';

    /**
     * Execute the console command.
     */
    public function handle()
    {
        $users = User::get(); 

        $users->each(function ($user) {
            Mail::to($user->email)->send(new DailyMarketingEmail);
        });

    }
}

In the handle method, we retrieve all users from the database and send each one the DailyMarketingEmail.

Step 5: Testing the Command

You can manually test your command by running:

php artisan app:send-daily-marketing-emails

Consider using tools like Mailtrap or MailHog to catch and view the sent emails during testing.

Step 6: Schedule the Command

Finally, to automate the sending of this email daily, we need to schedule the command in the schedule method of the Kernel.php file located in the app/Console/ directory:

<?php

namespace App\Console;

use Illuminate\Console\Scheduling\Schedule;
use Illuminate\Foundation\Console\Kernel as ConsoleKernel;

class Kernel extends ConsoleKernel
{
    /**
     * Define the application's command schedule.
     */
    protected function schedule(Schedule $schedule): void
    {
        $schedule->command('app:send-daily-marketing-emails')->dailyAt('08:30'); 
    }

    /**
     * Register the commands for the application.
     */
    protected function commands(): void
    {
        $this->load(__DIR__.'/Commands');

        require base_path('routes/console.php');
    }
}

Here, we use the dailyAt('08:30') method to schedule the command to run every day at 08:30 AM. You can adjust the time as needed.

Additional Suggestions:

Queueing Emails: For a large number of users, it's a good practice to queue the emails rather than sending them all at once. This can be done by implementing the ShouldQueue interface in the Mailable class.
Performance Considerations: For large user bases, consider optimizing database queries and the email sending process to ensure efficient performance.

How to create a scheduled Task in Laravel ?

Kepson Diaz — Thu, 29 Aug 2024 15:45:04 +0000

Hello everyone! Today, I’m going to walk you through the process of creating a scheduled task in Laravel. We’ll take the example of sending a daily marketing email to users.

Step 1: Create the Email Class

First, let’s create a new Mailable class using the following Artisan command:

php artisan make:mail DailyMarketingEmail --view

Step 2: Create an Artisan Command

Next, we’ll create an Artisan command that will handle sending our DailyMarketingEmail. Run the following command:

php artisan make:command SendDailyMarketingEmail

This command will generate a new command class in the app/Console/Commands directory.

Step 3: Understand the Command Structure

After generating your command, you'll see two key properties in the generated class:

After everything is set up, you can list all your Artisan commands by running:

php artisan

You should see your command in the list:

Step 4: Implement the Command Logic

Now, let’s define the logic within the handle method to send the marketing emails:

<?php

namespace App\Console\Commands;

use App\Models\User;
use Illuminate\Console\Command;
use App\Mail\DailyMarketingMail;
use Illuminate\Support\Facades\Mail;

class SendDailyMarketingEmails extends Command
{
    /**
     * The name and signature of the console command.
     *
     * @var string
     */
    protected $signature = 'app:send-daily-marketing-emails';

    /**
     * The console command description.
     *
     * @var string
     */
    protected $description = 'Send a marketing email to all users';

    /**
     * Execute the console command.
     */
    public function handle()
    {
        $users = User::get(); 

        $users->each(function ($user) {
            Mail::to($user->email)->send(new DailyMarketingEmail);
        });

    }
}

In the handle method, we retrieve all users from the database and send each one the DailyMarketingEmail.

Step 5: Testing the Command

You can manually test your command by running:

php artisan app:send-daily-marketing-emails

Consider using tools like Mailtrap or MailHog to catch and view the sent emails during testing.

Step 6: Schedule the Command

Finally, to automate the sending of this email daily, we need to schedule the command in the schedule method of the Kernel.php file located in the app/Console/ directory:

<?php

namespace App\Console;

use Illuminate\Console\Scheduling\Schedule;
use Illuminate\Foundation\Console\Kernel as ConsoleKernel;

class Kernel extends ConsoleKernel
{
    /**
     * Define the application's command schedule.
     */
    protected function schedule(Schedule $schedule): void
    {
        $schedule->command('app:send-daily-marketing-emails')->dailyAt('08:30'); 
    }

    /**
     * Register the commands for the application.
     */
    protected function commands(): void
    {
        $this->load(__DIR__.'/Commands');

        require base_path('routes/console.php');
    }
}

Here, we use the dailyAt('08:30') method to schedule the command to run every day at 08:30 AM. You can adjust the time as needed.

Additional Suggestions:

Queueing Emails: For a large number of users, it's a good practice to queue the emails rather than sending them all at once. This can be done by implementing the ShouldQueue interface in the Mailable class.
Performance Considerations: For large user bases, consider optimizing database queries and the email sending process to ensure efficient performance.

Easy Polymorphic Relationships in Laravel ! One To One Relationship ?

Kepson Diaz — Fri, 08 Mar 2024 14:46:41 +0000

Introduction :

Polymorphism in Laravel is a powerful feature that allows a model to belong to multiple other models. It enables a single association to be linked to various models, providing flexibility and reusability in database relationships.

One to One Relationship :

In a one-to-one polymorphic relationship, a model can belong to one and only one other model, but that model can have multiple types it can belong to.

For example, a Product and a Post may share a polymorphic relation to an Image model. Using a one-to-one polymorphic relation allows you to have a single table of unique images that may be associated with products and post.

To establish a one-to-one polymorphic relationship in Laravel, you can use the morphOne and morphTo methods.
For our example, the morphOne method is used in the child model: Image to define the relationship, while the morphTo method is used in the parent models: Product and Post to define the inverse relationship.

First, let's examine the table structure:

products
    id - integer
    name - string

posts
    id - integer
    name - string

images
    id - integer
    url - string
    imageable_id - integer
    imageable_type - string

Notice :
imageable_id column will contain the ID value of the products or posts, while the imageable_type column will contain the class name of the parent model.

The models structure will look like this:

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\MorphTo;

class Image extends Model
{
    /**
     * Get the parent imageable model (product or post).
     */
    public function imageable(): MorphTo
    {
        return $this->morphTo();
    }
}

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\MorphTo;

class Product extends Model
{
    /**
     * Get the product's image.
     */
    public function image(): MorphOne
    {
        return $this->morphOne(Image::class, 'imageable');
    }
}

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\MorphTo;

class Post extends Model
{
    /**
     * Get the post's image.
     */
    public function image(): MorphOne
    {
        return $this->morphOne(Image::class, 'imageable');
    }
}

Once your database table and models are defined, you may access the relationships via your models.
Example :

use App\Models\Image;

$image = Image::find(1);

$imageable = $image->imageable;

The imageable relation on the Image model will return either a Product or Post instance.

3 Syntax Ways to Define a BelongsTo Relationship Foreign Key in Laravel Migrations.

Kepson Diaz — Wed, 17 Jan 2024 18:10:29 +0000

In this article we will discover 3 syntax ways to define a belongto relationship foreign key in laravel migrations.

We have two tables Users and Posts, we gonna make a relation between them. User can create many Posts and Post can be create by on User.

1 - First syntax

<?php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

return new class extends Migration
{
    /**
     * Run the migrations.
     */
    public function up(): void
    {
        Schema::create('posts', function (Blueprint $table) {
            $table->id();
            $table->unsignedBigInteger('user_id');
            $table->foreign('user_id')->references('id')->on('users');
            $table->timestamps();
        });
    }
};

2 - Second Syntax

<?php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

return new class extends Migration
{
    /**
     * Run the migrations.
     */
    public function up(): void
    {
        Schema::create('posts', function (Blueprint $table) {
            $table->id();
            $table->foreignId('user_id')->constrained();
            $table->timestamps();
        });
    }

};

3 - Third syntax

<?php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

return new class extends Migration
{
    /**
     * Run the migrations.
     */
    public function up(): void
    {
        Schema::create('posts', function (Blueprint $table) {
            $table->id();
            $table->foreignIdFor(\App\Models\User::class)->constrained();
            $table->timestamps();
        });
    }

};

This 3 syntaxe do the same work. The second syntaxe is the most widely used by laravel developers, but the frist syntaxe can offer more flexibility for example if you want to change the name of the foreign key . The third syntaxe for his case is less verbose.

Is the end of this article. If you have any suggestions for improving this article, please let us know in the comments.

How to Send Verification Email after Registration in Laravel with Jetstream .

Kepson Diaz — Fri, 12 Jan 2024 04:02:49 +0000

In Laravel sending a verification email with Jetstream after registration is the easiest thing to set up.

To get started you need to install the Jetstream package.
You can follow all jetstream installation here : https://jetstream.laravel.com/installation.html

After the installation of JetStream to enable sending mail verification after user registration :

1- Enable Jetstream EmailVerification feature

you should enable email verification by uncommentting emailVerification feature on the fortify.php file.
in our image, this is the line : 137.

2 - Add MustVerifyEmail to Your User model

after enabling email verification you need to add MustVerifyEmail interface to the user's model file.
MustVerifyEmail is an interface that provide sendEmailVerificationNotification function and many others.

3 - Setup Mailtrap

For tesing email verification we gonna use Mailtrap.
Mailtrap is a service that provides a simulated SMTP server for testing email sending in development and staging environments.
First, register in the https://mailtrap.io to create a new account (It has a free version so don’t worry), and after the registration success, you can see the SMTP Setting for integrating your Mailtrap into our Laravel project.

Next, open your project's .env file and add the smtp settings provided by mailtrap.

4 - Test

Registration user test :
An verification email is sent to user test
Email Veirification

Is the end of this article. If you have any suggestions for improving this article, please let us know in the comments.

Fillable, Guarded in Laravel ! What’s the difference

Kepson Diaz — Tue, 26 Dec 2023 21:11:54 +0000

In Laravel, both $fillable and $guarded are attributes used in Eloquent models to control the mass assignment of attributes.
Mass assignment in Laravel refers to the ability to set multiple attributes of a model at once using an array of data.

Fillable :

$fillable is an array that specifies which attributes can be mass assigned. These are the attributes that are allowed to be set using the create or update methods.
Any attributes not included in the fillable array will be ignored during mass assignment.

class YourModele extends Model
{
        protected $fillable = [
        'name',
        'email',
        'password',
    ];
}

in this example attributs $name, $email, $password will be mass assigned.

If you wish to allow all attributes of your model to be mass-assigned, you can use the wildcard character * in the $fillable declaration. However, it's essential to understand the security implications of this approach.

class YourModele extends Model
{
    protected $fillable = ['*'];
}

Guarded :

$guarded is also an array but it works in the opposite way. It specifies which attributes are not allowed to be mass assigned. Any attributes not included in the guarded array will be considered safe for mass assignment.

class YourModele extends Model
{
        protected $guarded = [
        'name',
        'email',
        'password',
    ];
}

in this example attributs

$name, $email, $password

will not be mass assigned.

If you don't want all your model's attributes to be mass assigned, you can use the wildcard * in the $guarded declaration.

class YourModele extends Model
{
    protected $guarded = ['*'];
}

The main difference

The main difference between $fillable and $guarded is the approach they take to define the attributes that can be mass assigned. $fillable explicitly states the allowed attributes, while $guarded explicitly states the disallowed attributes.

why it's important to use `$fillable` or `$guarded`

It is important to use either $fillable or $guarded to protect against mass assignment vulnerabilities, which can lead to security risks. By specifying the attributes that can or cannot be mass assigned, you have more control over the data that is being assigned to your models.

DEV Community: Kepson Diaz

How to create a scheduled Task in Laravel ?

Step 1: Create the Email Class

Step 2: Create an Artisan Command

Step 3: Understand the Command Structure

Step 4: Implement the Command Logic

Step 5: Testing the Command

Step 6: Schedule the Command

Additional Suggestions:

How to create a scheduled Task in Laravel ?

Step 1: Create the Email Class

Step 2: Create an Artisan Command

Step 3: Understand the Command Structure

Step 4: Implement the Command Logic

Step 5: Testing the Command

Step 6: Schedule the Command

Additional Suggestions:

Easy Polymorphic Relationships in Laravel ! One To One Relationship ?

*Introduction : *

*One to One Relationship : *

3 Syntax Ways to Define a BelongsTo Relationship Foreign Key in Laravel Migrations.

How to Send Verification Email after Registration in Laravel with Jetstream .

Fillable, Guarded in Laravel ! What’s the difference

Fillable :

Guarded :

The main difference

why it's important to use $fillable or $guarded

Introduction :

One to One Relationship :

why it's important to use `$fillable` or `$guarded`