Laravel E-Commerce Application Development – Products Section Part 1

This is part 14 of the Laravel E-Commerce Application Development series. In this part, we will add the models and migrations for Product.

Planning

In this post, we will look at how we can store the products in our database. It’s absolutely necessary to plan ahead before jumping into the products section.

Here are some features, which we would like to implement in our products.

• A product will belong to a Brand.
• A product will belong to many categories and a category will have many products.
• As we know most of the eCommerce websites display multiple images for a product. So we need to have a model for images, then we can define a product have many images features.
• A product also can have many attributes with different quantity and price.

Keeping all above in mind, we will proceed to create the necessary models and migration for Products section.

Product Model and Migration

First of all, we need a Product model. Head over to your command line terminal and run the below command to generate the model and migration for Product.

php artisan make:model Models\Product -m

Above command will generate a model in app/Models folder and a migration file in database/migrations folder.

Open the migration file and update with the below one.

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

class CreateProductsTable extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::create('products', function (Blueprint $table) {
            $table->bigIncrements('id');
            $table->unsignedInteger('brand_id')->index();
            $table->string('sku');
            $table->string('name');
            $table->string('slug');
            $table->text('description')->nullable();
            $table->unsignedInteger('quantity');
            $table->decimal('weight', 8, 2)->nullable();
            $table->decimal('price', 8, 2)->nullable();
            $table->decimal('sale_price', 8, 2)->nullable();
            $table->boolean('status')->default(1);
            $table->boolean('featured')->default(0);

            $table->foreign('brand_id')->references('id')->on('brands')->onDelete('cascade');

            $table->timestamps();
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::dropIfExists('products');
    }
}

As you can see, we have defined the different columns for our product each with a relevant data type. Pay special attention to the brand_id column with the foriegn key, using this column we can relate the Product model with Brand model.

Next, open the Product model calls from app/Models folder and update with the below one.

namespace App\Models;

use Illuminate\Support\Str;
use Illuminate\Database\Eloquent\Model;

class Product extends Model
{
    /**
     * @var string
     */
    protected $table = 'products';

    /**
     * @var array
     */
    protected $fillable = [
        'brand_id', 'sku', 'name', 'slug', 'description', 'quantity',
        'weight', 'price', 'sale_price', 'status', 'featured',
    ];

    /**
     * @var array
     */
    protected $casts = [
        'quantity'  =>  'integer',
        'brand_id'  =>  'integer',
        'status'    =>  'boolean',
        'featured'  =>  'boolean'
    ];

     /**
     * @param $value
     */
    public function setNameAttribute($value)
    {
        $this->attributes['name'] = $value;
        $this->attributes['slug'] = Str::slug($value);
    }


    /**
     * @return \Illuminate\Database\Eloquent\Relations\BelongsTo
     */
    public function brand()
    {
        return $this->belongsTo(Brand::class);
    }
}

In the Product model, we defined the table and fillable property. In the $casts property, we casted some field with the proper data types. Next, we defined the brand() method which return an instance of belongsTo class and establish the One To Many relationship between Product and Brand.

Now open the Brand model and add the below method in it.

/**
 * @return \Illuminate\Database\Eloquent\Relations\HasMany
 */
public function products()
{
    return $this->hasMany(Product::class);
}

In this method, we simply defined the One To Many relationship so a brand can have many products.

Product Images Model and Migration

In this section, we will add the model and migrations for product images. As a product can have multiple images, so we will host the images in a separate table. Open your terminal and hit the below command to generate the model and migrations.

php artisan make:model Models\ProductImage -m

Now, open the migration file generated for product images and update with the below one.

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

class CreateProductImagesTable extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::create('product_images', function (Blueprint $table) {
            $table->bigIncrements('id');
            $table->unsignedInteger('product_id')->index();
            $table->string('thumbnail')->nullable();
            $table->string('full')->nullable();

            $table->foreign('product_id')->references('id')->on('products')->onDelete('cascade');
            $table->timestamps();
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::dropIfExists('product_images');
    }
}

In the product_images table, we add the two fields to store images one for thumbnail and one full-size image. Also, we added the product_id column with the foreign key, which will establish the relationship between product and product images table.

Now open the ProductImage model and update with the below one.

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class ProductImage extends Model
{
    /**
     * @var string
     */
    protected $table = 'product_images';

    /**
     * @var array
     */
    protected $fillable = ['product_id', 'thumbnail', 'full'];

    /**
     * @var array
     */
    protected $casts = [
        'product_id'    =>  'integer',
    ];

    /**
     * @return \Illuminate\Database\Eloquent\Relations\BelongsTo
     */
    public function product()
    {
        return $this->belongsTo(Product::class);
    }
}

In this model, we added a product() method which will return a belongsTo relationship. Now, we will update the Product model and add the below method in it.

/**
 * @return \Illuminate\Database\Eloquent\Relations\HasMany
 */
public function images()
{
    return $this->hasMany(ProductImage::class);
}

The images() method will return a hasMany relationship, so we can have more than one images for a product.

Product Attributes Model and Migrations

Now, we will link the attributes to products. This section is a bit tricky, so please pay special attention.

So the plan is to create a new model with table named ProductAttribute which will have the product id to link it with product, then we will create a pivot table to link this product_attributes table with the attribute_values. There are many implementations of adding attributes for a product, but I found this one easy and will get the job done.

Open your terminal and run the below command.

php artisan make:model Models\ProductAttribute -m

Now open the ProductAttribute migration file from database/migrations folder and update with the below one.

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

class CreateProductAttributesTable extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::create('product_attributes', function (Blueprint $table) {
            $table->increments('id');
            $table->integer('quantity');
            $table->decimal('price')->nullable();
            $table->unsignedInteger('product_id');
            $table->foreign('product_id')->references('id')->on('products');
            $table->timestamps();
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::dropIfExists('product_attributes');
    }
}

In this table we added the quantity and price for each attribute value and then added the product_id with the foreign key.

Now open the ProductAttribute model and update with the below one.

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class ProductAttribute extends Model
{
    /**
     * @var string
     */
    protected $table = 'product_attributes';

    /**
     * @var array
     */
    protected $fillable = ['product_id', 'quantity', 'price'];

    /**
     * @return \Illuminate\Database\Eloquent\Relations\BelongsTo
     */
    public function product()
    {
        return $this->belongsTo(Product::class);
    }
}

In this we defined the product() method to relate this model instance to the Product model.

Next, in your Product model add the below method.

/**
 * @return \Illuminate\Database\Eloquent\Relations\HasMany
 */
public function attributes()
{
    return $this->hasMany(ProductAttribute::class);
}

Above method will return the attributes for a given product using hasMany relationship.

So far so good!

Now, we need to create a pivot table to link ProductAttribute with the AttributeValue.

The whole reason for taking this approach is to access the attribute values with different price and quantity for a given product.

So open your terminal, and run the below command.

php artisan make:migration create_attribute_value_product_attribute_table

Open newly created migration file and update with the below one.

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

class CreateAttributeValueProductAttributeTable extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::create('attribute_value_product_attribute', function (Blueprint $table) {
            $table->bigIncrements('id');
            $table->unsignedInteger('attribute_value_id');
            $table->foreign('attribute_value_id')->references('id')->on('attribute_values');
            $table->unsignedInteger('product_attribute_id');
            $table->foreign('product_attribute_id')->references('id')->on('product_attributes');
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::dropIfExists('attribute_value_product_attribute');
    }
}

In this migration we have defined two columns attribute_value_id and product_attribute_id along with the the foriegn keys on attribute_values and product_attributes respectively.

So now we can update the ProductAttribute model, open ProductAttribute model and add the below method in it.

/**
 * @return \Illuminate\Database\Eloquent\Relations\BelongsToMany
 */
public function attributesValues()
{
    return $this->belongsToMany(AttributeValue::class);
}

Here, we are defining the Many To Many relationships between the ProductAttribute and AttributeValue models.

Now open the AttributeValue model and add the below method in it.

/**
 * @return \Illuminate\Database\Eloquent\Relations\BelongsToMany
 */
public function productAttributes()
{
    return $this->belongsToMany(ProductAttribute::class);
}

That’s it for the product attributes. ?

Updating Category Model

One last thing left is to link the categories with the product. ?

Don’t worry it will be similar to what we did in the last section.

So open your terminal one last time ?, and run the below command.

php artisan make:migration create_product_categories_table

Now open this migration file and update with the below one.

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

class CreateProductCategoriesTable extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::create('product_categories', function (Blueprint $table) {
            $table->bigIncrements('id');
            $table->integer('category_id')->unsigned()->index();
            $table->foreign('category_id')->references('id')->on('categories');
            $table->integer('product_id')->unsigned()->index();
            $table->foreign('product_id')->references('id')->on('products');
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::dropIfExists('product_categories');
    }
}

Now, open the Category model and add the below method in it.

/**
 * @return \Illuminate\Database\Eloquent\Relations\BelongsToMany
 */
public function products()
{
    return $this->belongsToMany(Product::class, 'product_categories', 'category_id', 'product_id');
}

Next, open the Product model and add the below method.

/**
 * @return \Illuminate\Database\Eloquent\Relations\BelongsToMany
 */
public function categories()
{
    return $this->belongsToMany(Category::class, 'product_categories', 'product_id', 'category_id');
}

Now in our application, a product can have many categories and a category can have many products.

Migration Tables

Now, simply run the php artisan migrate command to create all tables, whenever you are fancy.

Great ??

Conclusion

That’s it for now, in the next post we will start creating the products section for our admin area.

Products section is one of the most important and will be a tricky one in term on attributes, so I have divided this section into two part.

If you have any question about this post, please leave a comment in the comment box below and I will try my best to answer your questions.