DEV Community: Ucscode

Automate HTML Tables Generation in PHP with this Modern Library

Ucscode — Sun, 02 Mar 2025 19:28:30 +0000

Imagine writing a single line of code that will generate a fully functional table like the one below:

Interestingly, this is not based on random data but one that fully aligns with your project. Yes, a simple line of code can create a modular and customizable table from your database information.

The Struggle With HTML Tables

If you've ever worked with HTML tables in PHP, you know how tedious they can be. Manually writing out <table>, <tr>, and <td> elements for dynamic content quickly becomes messy and unmanageable. Developers often resort to concatenating strings or using templating engines, but these approaches come with their own challenges:

Error-prone: A missing closing tag can break your entire layout.
Difficult to maintain: Making changes to table structure requires rewriting large chunks of code.
Limited flexibility: Applying different styles, attributes, or handling special cases can get complicated.
Reusability: Managing dynamic data across multiple tables can be cumbersome.

Tables are one of the most common elements in web development. Whether it's an E-commerce product listing, admin user management, or a helpdesk ticket system, generating tables is a repetitive task.

Introducing: The Ucscode Table Generator

Wouldn’t it be great if generating tables in PHP were as simple as working with arrays or objects? That’s exactly what Ucscode/table-generator offers—a structured, object-oriented approach to creating and managing HTML tables efficiently.

🚀 Basic Usage: Creating a Simple Table

Let’s start with a simple example. Suppose you want to generate a table displaying user data from an associative array:

$data = [
    [
        'id' => 1, 
        'name' => 'John Doe', 
        'email' => 'john@example.com'
    ],
    [
        'id' => 2,
        'name' => 'Jane Doe', 
        'email' => 'jane@example.com'
    ]
];

With Ucscode Table Generator, you can generate a table effortlessly:

use Ucscode\HtmlComponent\TableGenerator\Adapter\AssocArrayAdapter;
use Ucscode\HtmlComponent\TableGenerator\TableGenerator;

$adapter = new AssocArrayAdapter($data);
$tableGenerator = new TableGenerator($adapter);

echo $tableGenerator->render();

🖥️ Output:

<table>
    <tr>
        <th>ID</th>
        <th>Name</th>
        <th>Email</th>
    </tr>
    <tr>
        <td>1</td>
        <td>John Doe</td>
        <td>john@example.com</td>
    </tr>
    <tr>
        <td>2</td>
        <td>Jane Doe</td>
        <td>jane@example.com</td>
    </tr>
</table>

🔍 Breaking It Down

Adapters: Making Data Work

The AssocArrayAdapter is just one of many adapters. An adapter is responsible for accepting a specific data type and converting it into a format that the TableGenerator can process.

Working with an associative array? Use AssocArrayAdapter.
Fetching data from MySQL? Use MysqliResultAdapter.
Want to process API responses? You can create a custom adapter.

TableGenerator: Your Table Engine

The TableGenerator takes the adapter and processes the extracted data into an HTML table. This method keeps data separate from presentation logic, improving clarity and maintainability.

✅ Why This Approach Works

No messy HTML strings – The library handles all the markup.
Clearer structure – Data remains separate from presentation.
Easier maintenance – Updating the table structure is straightforward.

🔥 Advanced Features

Adapters for Different Data Sources

One powerful feature of this library is its ability to work with various data sources through Adapters. For instance, if your data comes from an API, you can create a CustomApiJsonAdapter to process the response effortlessly.

Customization: Enhancing Your Table

By default, the table is plain. But you can fully customize it with Middleware to modify columns, apply styles, or add interactive elements.

Middleware: The Power of Modification

Middleware allows you to transform table data dynamically without modifying the core logic.

📌 Example: Adding Checkboxes to Rows

Checkboxes are essential for bulk actions. Instead of manually adding <input> elements, use CheckboxMiddleware:

use Ucscode\HtmlComponent\HtmlTableGenerator\Middleware\CheckboxMiddleware;

$tableGenerator->addMiddleware(new CheckboxMiddleware());

This automatically inserts a checkbox into the first column of each row.

📌 Why Choose `Ucscode/table-generator`?

Lightweight – No unnecessary dependencies.
Flexible API – Works for both simple and complex use cases.
Extensible – Supports custom middlewares and adapters.
Beginner-Friendly – Quick setup with minimal learning curve.
Open Source – Free to use, modify, and contribute!

🚀 Get Started Today!

If you're tired of manually generating HTML tables in PHP, give ucscode/table-generator a try! It's an elegant solution for creating tables in a structured, maintainable way.

🔗 Check out the full documentation

🔗 Check out the repository on GitHub

Have feedback or feature suggestions? Drop a comment below! 👇

How To Handle Custom S/DQL Queries On Different Database Engine with DoctrineExpression

Ucscode — Sun, 27 Oct 2024 03:40:46 +0000

In the journey of building robust Symfony projects, there often comes a point where simple Entity Repository methods like findBy() are no longer sufficient. For me, that point arrived, and I reached for the power of custom DQL queries to handle more complex data retrieval needs. At the time, I was using MySQL as my default database. Everything worked perfectly until I containerized my project and decided to switch over to PostgreSQL for performance and feature flexibility.

But, oh no! My DQL queries immediately began throwing errors 😵‍💫. What went wrong? My custom DQL syntax was perfectly crafted for MySQL’s quirks and functions but was incompatible with PostgreSQL. The choice was now between two challenging paths:

Option 1: Revert back to MySQL to keep things safe.

But what if I wanted to share the project with a developer who preferred PostgreSQL?

Option 2: Rewrite my DQL to support PostgreSQL.

But, what if I needed to switch back to MySQL later? Or what if I used a tool that only supported MySQL?

Choosing between these wasn’t easy—both options could lock me into a single database environment, limiting flexibility in future tech choices. So, I decided to take a different approach and created a solution to dynamically handle database-specific queries in a clean, reusable way.

Introducing DoctrineExpression

DoctrineExpression is a PHP library designed to enable cross-platform, database-agnostic DQL and SQL queries in Symfony or any project that utilizes doctrine. With DoctrineExpression, you can define custom syntax for each database platform (MySQL, PostgreSQL, SQLite, etc.), and it will select the correct expression based on the current database driver. It works like this:

Define Multiple Expressions: Write different syntax for each database driver, specifying unique queries that match each platform’s functions and quirks.
Automatic Driver Detection: DoctrineExpression checks the Doctrine platform in use, then automatically applies the correct syntax for MySQL, PostgreSQL, or any other supported database.
Future-Proof Flexibility: By allowing you to switch databases easily, DoctrineExpression future-proofs your code, ensuring that you can support multiple databases without extensive rewrites.

Now, with DoctrineExpression, I have the flexibility to use either MySQL or PostgreSQL (or even SQLite), keeping my code clean and maintainable. I can switch platforms based on project requirements, team preferences, or performance considerations without worrying about refactoring every custom query.

How DoctrineExpression Solves the Problem

Let’s look at a simple example where we need to retrieve users who registered within the last 24 hours. This is often handled differently in MySQL and PostgreSQL.

Without DoctrineExpression

MySQL: Uses DATE_SUB(NOW(), INTERVAL 1 DAY) to find records within the last 24 hours.
PostgreSQL: Uses NOW() - INTERVAL '1 day' for the same query.

Here’s how you might write these separately without DoctrineExpression:

// MySQL Query
$mysqlQuery = $entityManager->createQuery(
    "SELECT u FROM App\Entity\User u WHERE u.registeredAt > DATE_SUB(NOW(), INTERVAL 1 DAY)"
);

If you were using PostgreSQL, you would write in this format:

// PostgreSQL Query
$postgresQuery = $entityManager->createQuery(
    "SELECT u FROM App\Entity\User u WHERE u.registeredAt > NOW() - INTERVAL '1 day'"
);

If you switch databases, you'll need to modify this code, which is inconvenient and error-prone.

With DoctrineExpression

With DoctrineExpression, you define both syntaxes and let the library handle the rest:

use Ucscode\DoctrineExpression\DoctrineExpression;
use Ucscode\DoctrineExpression\DriverEnum;

// Create an expression instance with an EntityManager argument
$expression = new DoctrineExpression($entityManager);

// Registration S/DQL for varying database
$expression
    ->defineQuery(DriverEnum::PDO_MYSQL, function($entityManager) {
        return $entityManager->createQuery(
            "SELECT u FROM App\Entity\User u WHERE u.registeredAt > DATE_SUB(NOW(), INTERVAL 1 DAY)"
        );
    })
    ->defineQuery(DriverEnum::PDO_PGSQL, function($entityManager) {
        return $entityManager->createQuery(
            "SELECT u FROM App\Entity\User u WHERE u.registeredAt > NOW() - INTERVAL '1 day'"
        );
    });

// Fet any of the defined query based on the active doctine driver being used
$query = $expression->getCompatibleResult();

Now, DoctrineExpression checks the database platform in use and dynamically inserts the correct syntax for the current environment. It doesn't matter anymore you’re using MySQL or PostgreSQL, it will select the correct expression, saving you from having to modify your queries every time you switch platforms and also removes the boilerplate of using if-else repeatedly

In Conclusion:

DoctrineExpression saves time and effort by allowing you to use different databases without rewriting your queries. It’s particularly useful in containerized or multi-environment projects where you need to use custom syntax but database preferences may change depending on deployment needs or team familiarity. Give it a try, and let me know how it works for you!

Check out DoctrineExpression on GitHub

Happy coding!

User Synthetics: A Modular Web Development Framework

Ucscode — Sat, 17 Jun 2023 01:35:44 +0000

Introduction:

In today's fast-paced digital world, delivering exceptional user experiences has become paramount. As web developers, we constantly seek innovative tools and frameworks that empower us to create dynamic, efficient, and user-centric applications. In this article, I am excited to introduce you to User Synthetics, a cutting-edge lightweight PHP framework that is set to revolutionize web development. Before we proceed, let's look into a simple code:

Sample Code:

To give you a taste of the power and simplicity of User Synthetics, let's take a look at a snippet of code that showcases its capabilities:

uss::focus("home", function() {
    // Render the homepage template
    $content = function() {
        echo '<h1>Welcome to User Synthetics</h1>';
        echo '<p class="text-primary">Create amazing &amp; responsive web applications with ease!</p>'
    };
    uss::view($content);
});

In the above example, we define a route for the "home" page and render the content in a fully featured environment containing bootstrap 5, bootbox, bs-icon and more. This is just a glimpse of the elegance and flexibility that User Synthetics offers.

Interesting Factors to Explore:

Simplified Development Workflow: User Synthetics provides a streamlined development workflow with features like template building, event management, and JavaScript interaction. This empowers developers to focus on creating unique functionalities and delivering exceptional user experiences.
Enhanced Performance and Efficiency: With optimized code structure and smart resource management, User Synthetics ensures lightning-fast application performance, resulting in reduced load times and improved user satisfaction.
Flexible Templating System: User Synthetics offers a powerful templating system that allows developers to create visually stunning and responsive user interfaces. It supports dynamic content rendering, reusable components, and easy integration with JavaScript frameworks, making front-end design a breeze.
Seamless Integration with Third-Party Services: User Synthetics seamlessly integrates with various third-party services, enabling developers to leverage powerful functionalities like user authentication, payment gateways, and social media APIs. This saves time and effort, allowing developers to focus on core application logic.
Robust Security Measures: User Synthetics prioritizes security with built-in measures such as nonce handling, request URI management, and protection against common vulnerabilities. This ensures that your applications are secure and protected against potential threats.

To explore more about User Synthetics and join the vibrant community, visit the official website: uss.ucscode.me. You can find comprehensive documentation, tutorials, live demo and code samples to get started.

User Synthetics is poised to transform the web development landscape by providing developers with a powerful and intuitive framework. With its simplified workflow, enhanced performance, flexible templating, seamless integrations, and robust security measures, User Synthetics opens up endless possibilities for creating extraordinary web applications.

Discover the world of User Synthetics and unlock your creative potential. Dive into the official documentation, explore the vibrant community, and start building exceptional web experiences today. Get ready to revolutionize the digital realm with User Synthetics!

For documentation on how to work with user synthetics, visit the documentation page.

Let's party

I invite you to join the conversation and share your thoughts on User Synthetics. Are you excited about the potential of this modern web development tool? Do you have any questions or ideas about how it can be utilized effectively? Your input is valuable in shaping the future of User Synthetics and its applications. Let's spark a dialogue and explore the possibilities together. Feel free to leave a comment and engage with the community. Together, we can uncover new insights, inspire innovation, and empower each other in the world of web development.