Forem: Em leons

A Lightweight 5-Star Rating System for PHP

Em leons — Sat, 26 Jul 2025 17:05:47 +0000

Want to add 5-star ratings to your website or app without bloated dependencies or framework lock-in? Meet sim-rating — a simple, customizable PHP library for calculating and rendering 5-star ratings in multiple formats.

Why Choose sim-rating?

Works with any php Framework – Use it with plain PHP, Laravel, CodeIgniter, Symfony, or any PHP setup.
Lightweight – Just clean, efficient PHP.
Fully Customization – Adjust colors, styles, formats, and more.
Built-in Smart Logic – Auto-calculate totals, averages, and percentage distributions.

Getting Started

Installation

composer require emleons/sim-rating

Basic Example

require('vendor/autoload.php');
use Emleons\SimRating\Rating;

$ratings = [
    'one_star' => 10,
    'two_star' => 20,
    'three_star' => 30,
    'four_star' => 40,
    'five_star' => 50
];

$rating = new Rating($ratings);

echo $rating->render('html');  // Outputs HTML star rating
echo $rating->render('json');  // Outputs JSON

🎨 Customization Options

echo $rating->render('html', [
    'type' => 'bars',              // 'stars' or 'bars'
    'color' => '#4a90e2',          // Custom color
    'bar_height' => '25px',
    'show_summary' => true
]);

✨ Features at a Glance

1. Multiple Display Modes

Stars (default)
Bars (horizontal progress bars)
JSON (great for APIs)

2. 🧠 Built-In Rating Calculations

$rating->getAverage();       // 3.67
$rating->getTotal();         // 150
$rating->getDistribution();  // ['five_star' => 33.33, ...]

3. 🧩 Framework-Friendly

Laravel Blade

@php
    $rating = new \Emleons\SimRating\Rating($product->ratings);
@endphp

{!! $rating->render() !!}

CodeIgniter 4

// Controller
$rating = new \Emleons\SimRating\Rating($product['ratings']);
return view('product_view', ['rating' => $rating->render()]);

// View
<?= $rating ?>

⚙️ Advanced Usage

🛠️ Custom Template Support

echo $rating->render('html', [
    'template' => 'views/custom-rating-template.php'
]);

🌟 Enable Interactive Ratings

echo $rating->render('html', [
    'interactive' => true  // Adds clickable stars (requires JS)
]);

🔗 Useful Links

📦 Packagist: emleons/sim-rating
🐙 GitHub: github.com/emleonstz/sim-rating

🎁 Tip: Whether you’re building an e-commerce store, course platform, or review website, sim-rating helps you show user feedback with clean, minimal code.

Constructor Overloading in Java

Em leons — Thu, 15 Aug 2024 19:29:14 +0000

Constructors play a vital role in initializing a class. But did you know that in Java a class can have more than one constructor? This concept, known as constructor overloading, is a feature that allows you to create objects in different ways depending on the provided parameters. In this article, we’ll dive deep into constructor overloading, explore its benefits, and look at practical examples.

What is Constructor Overloading?

Constructor overloading in Java means having multiple constructors in the same class, each with a different parameter list. The constructors are differentiated by the number and types of their parameters. This allows you to create objects with varying initial states based on what data is available when the object is instantiated.

Why Use Constructor Overloading?

Constructor overloading is useful for several reasons:

Flexibility: It provides multiple ways to create objects with different initial values.
Convenience: Users of your class can choose which constructor to call based on the information they have.
Code Reusability: It allows for a default setup while still enabling customization.

Example of Constructor Overloading

Let’s consider a simple example of an Employee class to see how constructor overloading works in practice:

public class Employee {
    private String name;
    private int id;
    private double salary;

    // Constructor 1: No parameters
    public Employee() {
        this.name = "Unknown";
        this.id = 0;
        this.salary = 0.0;
    }

    // Constructor 2: One parameter (name)
    public Employee(String name) {
        this.name = name;
        this.id = 0;
        this.salary = 0.0;
    }

    // Constructor 3: Two parameters (name and id)
    public Employee(String name, int id) {
        this.name = name;
        this.id = id;
        this.salary = 0.0;
    }

    // Constructor 4: Three parameters (name, id, and salary)
    public Employee(String name, int id, double salary) {
        this.name = name;
        this.id = id;
        this.salary = salary;
    }

    public void displayInfo() {
        System.out.println("Name: " + name + ", ID: " + id + ", Salary: " + salary);
    }
}

How Does It Work?

In the Employee class above:

Constructor 1 is a no-argument constructor that sets default values for the name, id, and salary.
Constructor 2 allows you to set the name, with id and salary defaulting to 0.
Constructor 3 lets you set both name and id, while salary still defaults to 0.
Constructor 4 gives you the flexibility to set all three fields: name, id, and salary.

Example

Here’s an example on how to use these constructors in a Main class:

public class Main {
    public static void main(String[] args) {
        // Using the no-argument constructor
        Employee emp1 = new Employee();
        emp1.displayInfo(); // Output: Name: Unknown, ID: 0, Salary: 0.0

        // Using the constructor with one argument
        Employee emp2 = new Employee("Alice");
        emp2.displayInfo(); // Output: Name: Alice, ID: 0, Salary: 0.0

        // Using the constructor with two arguments
        Employee emp3 = new Employee("Bob", 123);
        emp3.displayInfo(); // Output: Name: Bob, ID: 123, Salary: 0.0

        // Using the constructor with three arguments
        Employee emp4 = new Employee("Charlie", 456, 50000.0);
        emp4.displayInfo(); // Output: Name: Charlie, ID: 456, Salary: 50000.0
    }
}

Constructor Chaining

Java also allows you to call one constructor from another within the same class using this(). This is known as constructor chaining and is useful for reusing code:

public Employee(String name) {
    this(name, 0, 0.0); // Calls the constructor with three parameters
}

In this example, the constructor with one parameter (name) calls the constructor with three parameters, providing default values for id and salary.

Remember

Overloading Rules: Constructors must differ in their parameter list (number, types, or both). They cannot differ only by return type (constructors do not have return types).
Default Constructor: If no constructors are defined, Java provides a default no-argument constructor. However, if you define any constructor, the default constructor is not provided unless you explicitly define it.

Advantages of Constructor Overloading

User Flexibility: Users of your class can initialize objects in multiple ways based on their needs.
Simplified Code: Helps avoid long parameter lists in a single constructor, improving code readability and maintainability.

Conclusion

Constructor overloading in Java is a feature that offers flexibility and convenience when creating classes with with multiple constructors. By providing multiple ways to instantiate a class.

How to Authenticate Users Codeigniter Shield

Em leons — Wed, 14 Aug 2024 21:08:32 +0000

Authentication is the keystone of any secure web application. In the world of PHP frameworks, CodeIgniter 4 has gained significant traction due to its lightweight and powerful features. Recently, CodeIgniter introduced Shield, a useful built authentication library that makes securing your application easier than ever. In this article, we'll explore how to set up user authentication using CodeIgniter 4 Shield, step by step.

What is CodeIgniter 4 Shield?

CodeIgniter 4 Shield is an authentication and authorization library specifically designed for CodeIgniter 4. It provides a comprehensive set of features that simplify the process of securing your web application. With Shield, you can implement user registration, login, password management, roles, permissions, and much more.

Getting Started:

Before diving into the code, let's ensure your development environment is set up correctly. You'll need a working CodeIgniter 4 installation. If you haven't already installed CodeIgniter 4, you can do so via Composer:

composer create-project codeigniter4/appstarter userAuth

Once your CodeIgniter 4 application is set up, you'll need to install the Shield package:

cd userAuth
cp env .env
nano .env //setup database

To install CI shield Run the following command:

composer require codeigniter4/shield

You can read more from the documentation here

After installing Shield, you'll need to set it up the configuration files and database migrations to customize settings accordingly Run the following command:

php spark shield:setup

Follow the command line steps to complete setup. Once shield setup completes it will generate necessary files,database tables and configurations ready for you to go.

if setup completed successfully to start a development serve Run the following command:

php spark serve

Now open you web browser visit you project always runs on port 8080

For login page open
http://localhost:8080/login

For registration page open
http://localhost:8080/register

Create a filter

php spark make:filter AuthFilter

inside AuthFilter.php

public function before(RequestInterface $request, $arguments = null)
    {
        if (auth()->loggedIn()) {
            $user = auth()->user();
            // Do something.
        }else{
            return redirect()->to('/login');
        }
    }

You can read more from the documentation here