Forem: AJ

What is Type Casting in laravel

AJ — Mon, 30 Sep 2024 15:35:44 +0000

You can specify the data types for certain model attributes in Laravel by using type casting. It makes sure that Laravel automatically casts the attribute values to the designated types when you retrieve data from the database.

Laravel Type Casting

AJ — Fri, 27 Sep 2024 15:29:40 +0000

You can specify the data types for certain model attributes in Laravel by using type casting. It makes sure that Laravel automatically casts the attribute values to the designated types when you retrieve data from the database.

You Can Check Here For multiple types of Attribute Casting

By default, Laravel provides several cast types that you can use:

Integer: The attribute will be cast to an integer.
Real: The attribute will be cast to a float.
Float: The attribute will be cast to a float.
Double: The attribute will be cast to a double.
String: The attribute will be cast to a string.
Boolean: The attribute will be cast to a boolean.
Object: The attribute will be cast to a PHP object.
Array: The attribute will be cast to a PHP array.
Collection: The attribute will be cast to a Laravel collection.
Date: The attribute will be cast to a date (Y-m-d) format.
DateTime: The attribute will be cast to a DateTime instance.
Timestamp: The attribute will be cast to a Unix timestamp (integer).

<?php
    namespace App\Models;

    use Illuminate\Database\Eloquent\Model;

    class User extends Model
    {
        /**
         * The attributes that should be cast.
         *
         * @var array
         */
        protected $casts = [
            'is_admin' => 'boolean',
            'age' => 'integer',
            'data' => 'array',
            'created_at' => 'datetime',
        ];
    }

In this illustration, the created_at value will be converted to a DateTime instance, the age attribute to an integer, the data attribute to an array, and the is_admin attribute to a boolean.

Therefore, you can keep JSON tags data in a user table, but when you fetch the users, you can immediately transform them into a PHP array, which eliminates the need to create a tags table.

When working with attributes in your Laravel models, type casting makes it easier to deal with the desired data type without having to convert it every time you access or change an attribute’s value.

if you love the content and want to support more awesome articles, consider buying me a coffee! ☕️🥳 Your support means the world to me and helps keep the knowledge flowing. You can do that right here: 👉 Buy Me a Coffee

How to Create a Chrome Extension Using JavaScript: A Beginner’s Guide

AJ — Thu, 26 Sep 2024 03:12:19 +0000

Imagine having the power to add new features or modify any website to suit your needs, directly in your browser. What if you could instantly block ads, modify the look of a page, or even integrate superhero-themed functionality? In this guide, I’ll walk you through creating your first Chrome extension using JavaScript — no superpowers required! Whether you’re a beginner or a seasoned developer, you will find that Chrome extensions are a fun way to flex your JS skills.

Here’s an outline for the article:

Introduction
What is Chrome Extensions?
What You Will Need
Setting up the Chrome Extension
Creating the Manifest File
Writing the Background Script
Creating the Popup HTML and Popup js Script
Implementing the Content Script
Testing the Extension 10.Real-World Example: My First Chrome Extension
Conclusion

Introduction

Are you prepared to enhance your online browsing experience? We will walk you through the process of building a Chrome extension that always opens your browser with a friendly welcome message. This course will assist you in understanding the fundamentals of developing Chrome extensions using JavaScript, regardless of your level of experience as a developer.

What is a Chrome Extension?

Let’s start with the fundamentals before digging into the code. Chrome extensions are little apps that improve your browser’s capabilities. These extensions, which are made with common web technologies like HTML, CSS, and JavaScript, let users personalize their browsing in unexpected ways.

What You Will Need:

A basic understanding of JavaScript
Google Chrome installed on your computer
A text editor (like VSCode)
Let’s dive in!

Setting up the Chrome Extension

To get started, create a new folder on your computer. This folder will hold all the files related to the Chrome extension. Let’s call it chrome-extension. Inside this folder, you will need two important files:

manifest.json (the brain of your extension)
background.js (the script that runs in the background).

// Here’s how to structure it:

chrome-extension/
    ├── manifest.json
    └── background.js
    └── popup.html
    └── popup.js
    └── contentScript.js

Creating the manifest.json File

The manifest file is the heart of any Chrome extension. It defines the extension’s properties, permissions, and behavior. Let’s create a manifest.json file in our project root:

{
    "manifest_version": 3,
    "name": "Random Background Color",
    "version": "1.0",
    "description": "A Chrome extension that changes the background color of a webpage to a random color",
    "permissions": ["activeTab"],
    "action": {
      "default_popup": "popup.html"
    },
    "content_scripts": [
      {
        "matches": ["<all_urls>"],
        "js": ["contentScript.js"]
      }
    ]
  }

If you want to know more about the manifest then you can check this Manifest Format

manifest_version: 3: This specifies that we are using version 3 of the manifest. Always ensure we are using the latest version.
name: The name of your extension. This will appear in the Chrome extension manager.
version: This is your extension’s version. Keep this updated as you add more features.
description: A short description of what your extension does.
permissions: Grants permission to access and modify the currently active tab in the browser.
action: Specifies the popup window (popup.html) that opens when the extension icon is clicked in the browser toolbar.
content_scripts: Injects contentScript.js into every webpage visited ( allows it on all sites). The script likely changes the webpage’s background color.

Writing the background Script

The background script is responsible for handling events like opening tabs or listening for changes in browser state. Let’s create a basic background.js script.

chrome.runtime.onInstalled.addListener(() => {
  console.log("Extension installed!");
});

chrome.action.onClicked.addListener((tab) => {
  console.log("Extension icon clicked");
});

Now breakdown the background.js

onInstalled: This event is triggered when the extension is installed or updated.
onClicked: This event is fired when the user clicks on the extension’s icon.

Creating the Popup HTML and Popup js Script

The popup is the small window that appears when the user clicks on your extension’s icon. Create a popup.html file like this:

// popup.html

<!DOCTYPE html>
<html>
  <head>
    <title>Random Background Color</title>
    <style>
      body {
        width: 200px;
        height: 100px;
        font-family: Arial, sans-serif;
        text-align: center;
      }
    </style>
  </head>
  <body>
    <h1>Random Background Color</h1>
    <button id="change-color">Change Color</button>
    <script src="popup.js"></script>
  </body>
</html>

Inpopup.js, add a script to handle the button click:

document.addEventListener("DOMContentLoaded", function () {
    const changeColorButton = document.getElementById("change-color");
    changeColorButton.addEventListener("click", function () {
      chrome.tabs.query({ active: true, currentWindow: true }, function (tabs) {
        chrome.tabs.sendMessage(tabs[0].id, { action: "change-color" });
      });
    });
  });

This script listens for the page’s DOMContentLoaded event, meaning it waits until the HTML document is fully loaded and parsed before running. Once the page is ready:

It selects the button with the ID change-color.
It adds a click event listener to this button.
When the button is clicked, the script uses chrome.tabs.query to find the currently active tab in the browser window.
After identifying the active tab, it sends a message to the content script of that tab with an action, change-color using chrome.tabs.sendMessage.

Content Script

A content script allows your extension to interact with web pages. Create a content.js file to manipulate or extract data from the web page.

function getRandomColor() {
    const letters = "0123456789ABCDEF";
    let color = "#";
    for (let i = 0; i < 6; i++) {
      color += letters[Math.floor(Math.random() * 16)];
    }
    return color;
  }

  chrome.runtime.onMessage.addListener(function (request, sender, sendResponse) {
    if (request.action === "change-color") {
      const color = getRandomColor();
      document.body.style.backgroundColor = color;
     sendResponse({ status: "Background changed!" });
    }
  });

Here’s how it works step by step:

chrome.runtime.onMessage.addListener(): This is a function that listens for messages sent from other parts of the Chrome extension, such as background scripts or popup scripts.
Callback Parameters:
request: The message sent by another part of the extension. It contains data, like what action to perform.
sender: Information about who sent the message.
sendResponse: A function to send a response back to the message sender.
Message Handling: Inside the callback, it checks if the request.action is change-color.
Action: If the action is change-color, it changes the background color of the web page's body to random color.
Response: After changing the background color, it sends a response back to the sender with the message { status: "Background changed!" }.

Testing the Extension

Open Chrome and go to chrome://extensions/.
Enable Developer Mode (toggle in the top right corner).
Click Load Unpacked and select your extension’s folder.
Your extension should now appear in the list! Click the icon in the browser toolbar to test the popup and scripts.

Add More Features

This is just the start! You can enhance your extension by adding new features like:

To learn more about storage, permissions, and options page for Chrome extensions, you can refer to the following documentation:

Storage: Use chrome.storage to save user preferences. chrome.storage API
Permissions: Request access to additional Chrome features (like bookmarks, and history). Permission API
Options Page: Add an options page to allow users to configure the extension. Options Page
For more details, visit the Chrome Extensions documentation.

Real-World Example: My First Chrome Extension

When I created my first Chrome extension, I was eager to make my browsing experience more personalized. The idea of a browser welcoming me whenever I opened it felt like adding a touch of personality to my digital routine. It was the simplest idea, but the satisfaction of seeing it work was huge. For developers just getting started, these small wins are what keep us pushing forward.

Conclusion: Make It Yours.

Chrome extensions are powerful tools that can enhance your browser experience. This tutorial is just the beginning — once you’re comfortable with the basics, you can extend this project further by adding custom buttons, integrating APIs, or even storing user preferences.

Laravel Local Scopes

AJ — Tue, 24 Sep 2024 13:50:44 +0000

1. Introduction to Laravel Scopes

Laravel Scope is one of the best features of Laravel, it is a querying method in which we can create a scope in a model or a new class. It is a powerful tool to help you write reusable and maintainable code.

How To Integrate Scopes.

$activeUser = Post::where('active', true)->get();

But I want to get Active User, Again and Again, So right now I need to write this query again and again and it will show duplication and not a standard way. So Here is the Solution in Scope.

class User extends Model
{    
    public function scopeActive($query)
    {
        return $query->where('active', 1);
    }
}

In This picture.

User is a model class that encapsulates the model data.
It has a method called scopeActive.
ScopeActive adds a filter to the database Query and ensures that only active users are returned from a database.
It is recommended that the scope method name be started with a lowercase letter.
Now we can use this function to filter out data related to the user in a controller.

$activeUser = User::active()->get();

How To Use Dynamic Scopes.
If we want to use Scope Dynamically, we need to pass the parameter for this scope.

class User extends Model
{
  public function scopeActive($query,$value)
    {
        return $query->where('active', $value);                
        //there is another way also to call this 
        //return $query->whereActive($value);    
    }
}

Now we can use dynamic Scope just like this.

$activeUser = User::active(true)->get();

How To Use Scopes with Relations.

A scope can also be defined in the relation model.

class User extends Model
{
  public function scopePosts($query,$value)
    {
        return $query->with('posts');                
    }
}

We can then use this scope to retrieve all posts for a specific user:

$user = User::find(1);

$posts = $user->posts()->get();

How To Use Scopes with Joins.

We can use Scope with joins also.. For example, if you have a model called Order that belongs to a User, and you want to retrieve all orders for a user that have a total greater than $100, you can use a scope that joins the Order model and applies a where clause to the resulting query:

public function scopeTotalGreaterThan($query, $amount) {

    return $query->join('orders', 'users.id', '=', 'orders.user_id')

    ->where('orders.total', '>', $amount);

}

You can then use this scope to retrieve all users with orders that have a total greater than $100:

$users = User::totalGreaterThan(100)->get();

Best Practices for Implementing Laravel Scopes

6 Best Practices for Implementing Laravel Scopes
Implementing Laravel scopes requires attention to detail and best practices to ensure that the code runs smoothly and effectively. Here are six best practices for implementing Laravel scopes in your projects:

Choose the Right Scope Name - The scope name should reflect the exact behavior of the query. A descriptive and concise name makes it easier to understand the purpose of the scope.
Use Scopes Sparingly - Too many scopes can make your code hard to maintain. Consider using scopes only when you expect to reuse the code repeatedly.
Keep it Atomic - Each scope should contain only one specific query constraint. This helps to maintain the clarity and readability of your code.
Use Query Builder Constraints - Laravel scopes can use all the query builder constraints available in Laravel. This includes where clauses, joins, and limits.
Use Local Scopes - Local scopes are defined inside a model and can be used within the model for filtering or querying. This helps to maintain clean and concise code.
Test Your Scopes - Testing is important to ensure that your code works as expected. Create unit tests to verify that the scope is filtering the query correctly. By following these practices, you can implement Laravel scopes effectively and efficiently in your projects. Laravel scopes are a powerful tool that can help you achieve consistent, secure, and reusable database queries in your Laravel applications.

Thanks
And if you love the content and want to support more awesome articles, consider buying me a coffee! ☕️🥳 Your support means the world to me and helps keep the knowledge flowing. You can do that right here: 👉 Buy Me a Coffee

Global Scope in Laravel (StepWise).

AJ — Mon, 23 Sep 2024 15:49:36 +0000

Global Scopes are a vital concept in Laravel, enabling the reuse of Eloquent conditions throughout your application. By implementing Global Scopes, you can apply specific conditions to queries across all models, promoting code reuse and consistency. In contrast, Local Scopes are limited to a single model. In this tutorial, we will focus on creating and utilizing Global Scopes in Laravel.

In This Step, we will create a Global Class inside a app/Scopes/ActiveScope

<?php

namespace app\Scopes;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Scope;

class ActiveScope implements Scope
{
    public function apply(Builder $builder, Model $model)
    {
        // Define your global condition here
        $builder->where('is_active', '=', '1');

        //or we can write
        $builder->whereIsActive('1');

    }
}

Now Define ActiveScope in the User Model. We Should override a given model’s boot method and use the addGlobalScope method:

<?php

namespace App;

use App\Scopes\AgeScope;
use Illuminate\Database\Eloquent\Model;
use App\Scopes\ActiveScope;

class User extends Model
{
    /**
     * The "booting" method of the model.
     *
     * @return void
     */
    protected static function boot()
    {
        parent::boot();

        static::addGlobalScope(new ActiveScope);
    }
}

After adding the ActiveScope in model, User::all() will generate the following SQL.

select * from `users` where `is_active` = '1'

There may be scenarios where you want to fetch all data without applying the global scope. In Laravel, you can bypass a global scope and fetch all data by using the withoutGlobalScope method.

User::withoutGlobalScope(ActiveScope::class)->get();

If you want to remove multiple or all of the global scopes applied to a model, you can use the withoutGlobalScopes method in Laravel. This method allows you to bypass all global scopes or specify the ones you want to remove. Here's an example:

// Remove all of the global scopes...
User::withoutGlobalScopes()->get();

// Remove some of the global scopes...
User::withoutGlobalScopes([
    ActiveScope::class, AgeScope::class
])->get();

And if you love the content and want to support more awesome articles, consider buying me a coffee! ☕️🥳 Your support means the world to me and helps keep the knowledge flowing. You can do that right here: 👉 Buy Me a Coffee