Forem: iQuipe Digital

Building a Simple Redis‑Style Cache Server in PHP with JSON Persistence

iQuipe Digital — Fri, 05 Dec 2025 20:20:20 +0000

Caching is one of the most powerful techniques for speeding up applications. While Redis is the industry standard for in‑memory caching, sometimes you want to learn by building your own or experiment with lightweight alternatives. In this post, I’ll show you how to create a Redis‑like cache server in PHP that stores data in a JSON file for persistence.

Why Build Your Own Cache?

Educational value: Understand how Redis works under the hood.
Lightweight projects: Use a simple cache without external dependencies.
Custom features: Extend with your own commands or APIs.

Step 1: Core Data Store

We’ll use a JSON file (cache.json) to persist key‑value pairs. On startup, the server loads this file into memory, and every SET/DEL operation writes back to disk.

<?php
$cacheFile = __DIR__ . "/cache.json";

// Load existing cache
if (file_exists($cacheFile)) {
    $store = json_decode(file_get_contents($cacheFile), true);
} else {
    $store = [];
}
$ttl = []; // track expiration times

Step 2: Cache Functions

Implement basic commands: SET, GET, and DEL.

function saveCache() {
    global $store, $cacheFile;
    file_put_contents($cacheFile, json_encode($store, JSON_PRETTY_PRINT));
}

function setKey($key, $value, $expire = null) {
    global $store, $ttl;
    $store[$key] = $value;
    if ($expire) {
        $ttl[$key] = time() + $expire;
    }
    saveCache();
}

function getKey($key) {
    global $store, $ttl;
    if (isset($ttl[$key]) && time() > $ttl[$key]) {
        unset($store[$key], $ttl[$key]);
        saveCache();
        return null;
    }
    return $store[$key] ?? null;
}

function delKey($key) {
    global $store, $ttl;
    unset($store[$key], $ttl[$key]);
    saveCache();
}

Step 3: TCP Server

Use PHP’s stream_socket_server to listen for client connections on port 6379 (same as Redis).

$server = stream_socket_server("tcp://127.0.0.1:6379", $errno, $errstr);

if (!$server) {
    die("Error: $errstr ($errno)\n");
}

echo "PHP JSON Cache Server running on 127.0.0.1:6379...\n";

while ($client = stream_socket_accept($server)) {
    $input = trim(fgets($client));
    $parts = explode(" ", $input);
    $cmd = strtoupper($parts[0]);

    switch ($cmd) {
        case "SET":
            setKey($parts[1], $parts[2], $parts[3] ?? null);
            fwrite($client, "+OK\n");
            break;
        case "GET":
            $val = getKey($parts[1]);
            fwrite($client, $val ? "$val\n" : "(nil)\n");
            break;
        case "DEL":
            delKey($parts[1]);
            fwrite($client, ":1\n");
            break;
        default:
            fwrite($client, "-ERR unknown command\n");
    }
    fclose($client);
}

Step 4: Testing

Run the server:

php cache_server.php

Connect with telnet:

telnet 127.0.0.1 6379
SET foo bar 10
+OK
GET foo
bar

Check cache.json:

{
    "foo": "bar"
}

Step 5: Deployment Example (Ubuntu)

Install PHP CLI:

   sudo apt update
   sudo apt install php-cli -y

Create directory:

   mkdir /opt/php-cache && cd /opt/php-cache

Add files: cache_server.php and cache.json.
Systemd service (/etc/systemd/system/php-cache.service):

   [Unit]
   Description=PHP JSON Cache Server
   After=network.target

   [Service]
   ExecStart=/usr/bin/php /opt/php-cache/cache_server.php
   Restart=always
   User=www-data
   WorkingDirectory=/opt/php-cache

   [Install]
   WantedBy=multi-user.target

Enable & start:

   sudo systemctl daemon-reload
   sudo systemctl enable php-cache
   sudo systemctl start php-cache

Enhancements

Add REST API endpoints for easier integration.
Implement more commands (EXISTS, INCR, KEYS).
Add automatic TTL cleanup.
Dockerize for portable deployment.

Conclusion

You now have a working Redis‑style cache server in PHP with JSON persistence. While it won’t match Redis in performance, it’s a fantastic way to learn about caching, persistence, and server design. From here, you can extend it into a microservice, wrap it with an API, or containerize it for cloud deployment.

Web Design Through the Lens of UI/UX, HCI, and CX

iQuipe Digital — Fri, 28 Nov 2025 09:41:11 +0000

Introduction

Web design has evolved far beyond aesthetics. Today, successful websites are built on a foundation of User Interface (UI) and User Experience (UX) principles, informed by Human-Computer Interaction (HCI) research, and aligned with Customer Experience (CX) strategies. Together, these disciplines ensure that digital products are not only usable, but also delightful and business-driven.

UI/UX Principles in Web Design

UI/UX focuses on how users interact with and perceive a website.

UI (User Interface): The visual layer — typography, color schemes, buttons, and layouts.
UX (User Experience): The holistic journey — ease of navigation, emotional satisfaction, and task completion.

Key Principles:

Consistency: Uniform design patterns across pages.
Clarity: Simple navigation and clear calls-to-action.
Feedback: Visual or auditory cues when users perform actions.
Accessibility: Inclusive design for diverse users (e.g., screen readers, color contrast).

💡 Example: A travel booking site with intuitive filters, clean typography, and instant confirmation messages enhances both UI and UX.

HCI Principles in Web Design

Human-Computer Interaction (HCI) provides the scientific backbone for usability. It draws from psychology, ergonomics, and computer science.

Core Principles:

Affordance: Elements should suggest their function (e.g., buttons look clickable).
Error Prevention & Recovery: Clear error messages and undo options.
Cognitive Load Reduction: Minimize unnecessary steps and information overload.
Learnability: Interfaces should be easy to grasp for first-time users.

💡 Example: An e-learning platform that uses progress indicators, auto-save features, and intuitive navigation reduces cognitive strain and supports learning.

CX Principles in Web Design

Customer Experience (CX) extends beyond usability to encompass the emotional and relational aspects of interacting with a brand.

Key Principles:

Personalization: Tailored content and recommendations.
Omnichannel Consistency: Seamless experience across web, mobile, and offline touchpoints.
Trust & Transparency: Clear privacy policies, secure payment gateways.
Emotional Engagement: Storytelling, visuals, and tone that resonate with users.

💡 Example: An e-commerce site that remembers past purchases, offers personalized deals, and provides responsive customer support builds loyalty and trust.

Integrating UI/UX, HCI, and CX

The real power lies in integration:

HCI ensures usability → users can interact effectively.
UI/UX ensures delight → users enjoy the interaction.
CX ensures loyalty → users feel valued and return.

Together, they create websites that are functional, engaging, and business-aligned.

Conclusion

Modern web design is no longer just about “looking good.” It’s about scientific usability (HCI), design-driven experience (UI/UX), and customer-centric strategy (CX). By weaving these principles together, designers can craft digital experiences that are not only efficient but also memorable — turning casual visitors into loyal advocates.

Using a TOML Parser in PHP: A Practical Guide

iQuipe Digital — Tue, 25 Nov 2025 21:52:14 +0000

Configuration files are the backbone of modern applications. They let us separate environment-specific settings from our code, making projects easier to maintain and deploy. While JSON and YAML are popular, TOML (Tom’s Obvious, Minimal Language) is gaining traction for its simplicity and readability.

In this article, we’ll explore how to use a TOML parser in PHP to load configuration files into your applications.

🔎 What is TOML?

TOML is a minimal configuration format designed to be easy to read and write. It’s widely used in projects like Rust (Cargo.toml) and Python (pyproject.toml).

Here’s a quick example:

title = "My Netlify App"
port = 8080
debug = true

[database]
server = "localhost"
user = "admin"
password = "secret"

languages = ["php", "javascript", "python"]

🛠 Installing a TOML Parser for PHP

PHP doesn’t natively support TOML, but we can use the excellent yosymfony/toml library.

Install it via Composer:

composer require yosymfony/toml

💻 Parsing TOML in PHP

Once installed, you can parse TOML files into PHP arrays:

<?php
require 'vendor/autoload.php';

use Yosymfony\Toml\Toml;

try {
    // Parse TOML file
    $config = Toml::parseFile('config.toml');

    // Access values
    echo "App Title: " . $config['title'] . PHP_EOL;
    echo "Port: " . $config['port'] . PHP_EOL;

    // Access nested table
    echo "Database Server: " . $config['database']['server'] . PHP_EOL;
    echo "Database User: " . $config['database']['user'] . PHP_EOL;
} catch (Exception $e) {
    echo "Error parsing TOML: " . $e->getMessage();
}

✅ Sample Output

App Title: My Netlify App
Port: 8080
Database Server: localhost
Database User: admin

🎯 Why Use TOML in PHP Projects?

Readable: Easier for humans to scan than JSON or YAML.
Strict typing: Strings, integers, floats, booleans, arrays, and dates are clearly defined.
Cross-language support: TOML parsers exist for many languages, making it great for polyglot projects.
Perfect for configs: Use it for database settings, API keys, or environment flags.

🚀 Next Steps

You can wrap this logic into a ConfigLoader class that automatically loads .toml files and exposes values like get('database.server'). This makes your code cleaner and reusable across projects.

✨ Conclusion

TOML brings clarity and simplicity to configuration management. With the yosymfony/toml parser, PHP developers can easily integrate TOML into their workflows — whether for student projects, production apps, or cloud deployments.

Using DigitalOcean Spaces to Store MySQL Cache Files in PHP

iQuipe Digital — Fri, 21 Nov 2025 21:12:16 +0000

Using DigitalOcean Spaces to Store MySQL Cache Files in PHP

iQuipe Digital — Fri, 21 Nov 2025 20:35:54 +0000

Caching database queries is one of the most effective ways to improve application performance. While tools like Redis and Memcached are the gold standard for real-time caching, sometimes you want a simple, file-based approach — and maybe even store those cached files in the cloud for durability and scalability.

In this article, I’ll show you how to:

Implement a file-based cache for MySQL queries in PHP
Upload those cached JSON files to DigitalOcean Spaces
Serve cached data efficiently to clients

Step 1: Local File-Based Cache in PHP

We start with a simple caching mechanism that saves query results into a JSON file:

<?php
$cacheFile = "cache/users.json";
$cacheTime = 300; // 5 minutes

if (file_exists($cacheFile) && (time() - filemtime($cacheFile)) < $cacheTime) {
    $data = json_decode(file_get_contents($cacheFile), true);
} else {
    $mysqli = new mysqli("localhost", "user", "pass", "dbname");
    $res = $mysqli->query("SELECT * FROM users");
    $data = $res->fetch_all(MYSQLI_ASSOC);

    file_put_contents($cacheFile, json_encode($data));
}

header("Content-Type: application/json");
echo json_encode($data);
?>

This ensures that repeated requests within 5 minutes don’t hit the database — they just read from the cached file.

Step 2: Add DigitalOcean Spaces

DigitalOcean Spaces is an object storage service (similar to AWS S3). We’ll use the AWS SDK for PHP to upload our cached JSON file to Spaces.

Install AWS SDK

composer require aws/aws-sdk-php

Configure Spaces

You’ll need:

Space name (bucket name)
Region (e.g., nyc3)
Endpoint (e.g., https://nyc3.digitaloceanspaces.com)
Access key & secret key

Updated Server Code

<?php
require 'vendor/autoload.php';

use Aws\S3\S3Client;
use Aws\Exception\AwsException;

// Spaces config
$spaceName = "my-space";
$region = "nyc3";
$endpoint = "https://$region.digitaloceanspaces.com";
$accessKey = "YOUR_ACCESS_KEY";
$secretKey = "YOUR_SECRET_KEY";

// Create S3 client
$s3 = new S3Client([
    'version' => 'latest',
    'region'  => $region,
    'endpoint' => $endpoint,
    'credentials' => [
        'key'    => $accessKey,
        'secret' => $secretKey,
    ],
]);

// Cache logic
$cacheFile = "cache/users.json";
$cacheTime = 300;

if (file_exists($cacheFile) && (time() - filemtime($cacheFile)) < $cacheTime) {
    $data = json_decode(file_get_contents($cacheFile), true);
} else {
    $mysqli = new mysqli("localhost", "user", "pass", "dbname");
    $res = $mysqli->query("SELECT * FROM users");
    $data = $res->fetch_all(MYSQLI_ASSOC);

    // Save locally
    file_put_contents($cacheFile, json_encode($data));

    // Upload to Spaces
    try {
        $s3->putObject([
            'Bucket' => $spaceName,
            'Key'    => "users.json",
            'Body'   => json_encode($data),
            'ACL'    => 'public-read',
            'ContentType' => 'application/json'
        ]);
    } catch (AwsException $e) {
        error_log("Spaces upload failed: " . $e->getMessage());
    }
}

header("Content-Type: application/json");
echo json_encode($data);
?>

Step 3: Client Side Consumption

Clients can now fetch cached data either from:

Your PHP endpoint (server.php)
Directly from Spaces CDN (https://my-space.nyc3.digitaloceanspaces.com/users.json)

Example (JavaScript Client)

<script>
fetch("https://my-space.nyc3.digitaloceanspaces.com/users.json")
  .then(res => res.json())
  .then(data => {
    data.forEach(user => {
      console.log(`ID: ${user.id}, Name: ${user.name}`);
    });
  });
</script>

Benefits of This Approach

Performance: Reduce database load with cached query results.
Durability: Cached files are safely stored in Spaces.
Scalability: Multiple clients can fetch directly from Spaces CDN.
Flexibility: Use local cache for speed, Spaces for persistence.

Conclusion

While Redis or Memcached are better for real-time caching, combining file-based caching with DigitalOcean Spaces gives you a simple, scalable solution for storing and serving cached query results. It’s perfect for scenarios where durability and CDN delivery matter more than microsecond response times.

An ADHD-Friendly Task & Focus Timer Built in PHP.

iQuipe Digital — Thu, 13 Nov 2025 22:26:03 +0000

Introduction

Managing attention and productivity can be difficult, especially for people with ADHD. Long to‑do lists often feel overwhelming, and big tasks can be discouraging. To solve this, I built a PHP web application that breaks work into micro‑steps, adds a Pomodoro‑style focus timer, and tracks progress visually.

This project demonstrates how simple code can create meaningful tools that support better daily routines.

🎯 Core Features

Micro-step task management: Break tasks into tiny, actionable steps.
Pomodoro-style focus timer: 25‑minute focus sessions with 5‑minute breaks.
Visual progress tracking: Progress bars show completed steps at a glance.
Lightweight persistence: Uses a JSON file (data.json) instead of a database.

🛠️ The Code

Here’s the heart of the application — a single index.php file that handles tasks, steps, and the timer:

<?php
// Simple ADHD-friendly Task + Focus Timer app (no framework, JSON storage)
// Save as index.php, create data.json with [] and run via PHP's built-in server: php -S localhost:8000

$dataFile = __DIR__ . '/data.json';
if (!file_exists($dataFile)) file_put_contents($dataFile, json_encode([]));

function readData() {
    global $dataFile;
    $json = file_get_contents($dataFile);
    $data = json_decode($json, true);
    return is_array($data) ? $data : [];
}

function writeData($data) {
    global $dataFile;
    file_put_contents($dataFile, json_encode($data, JSON_PRETTY_PRINT));
}

// Handle actions
$action = $_POST['action'] ?? $_GET['action'] ?? null;
$data = readData();

if ($action === 'add_task') {
    $title = trim($_POST['title'] ?? '');
    if ($title !== '') {
        $data[] = [
            'id' => uniqid('t_', true),
            'title' => $title,
            'steps' => [],
            'done' => false,
            'createdAt' => time()
        ];
        writeData($data);
    }
    header('Location: ./'); exit;
}

if ($action === 'add_step') {
    $taskId = $_POST['taskId'] ?? '';
    $stepText = trim($_POST['step'] ?? '');
    foreach ($data as &$task) {
        if ($task['id'] === $taskId && $stepText !== '') {
            $task['steps'][] = [
                'id' => uniqid('s_', true),
                'text' => $stepText,
                'done' => false
            ];
        }
    }
    unset($task);
    writeData($data);
    header('Location: ./'); exit;
}

if ($action === 'toggle_step') {
    $taskId = $_POST['taskId'] ?? '';
    $stepId = $_POST['stepId'] ?? '';
    foreach ($data as &$task) {
        if ($task['id'] === $taskId) {
            foreach ($task['steps'] as &$step) {
                if ($step['id'] === $stepId) {
                    $step['done'] = !$step['done'];
                    break;
                }
            }
            unset($step);
        }
    }
    unset($task);
    writeData($data);
    header('Location: ./'); exit;
}

if ($action === 'toggle_task') {
    $taskId = $_POST['taskId'] ?? '';
    foreach ($data as &$task) {
        if ($task['id'] === $taskId) {
            $task['done'] = !$task['done'];
            break;
        }
    }
    unset($task);
    writeData($data);
    header('Location: ./'); exit;
}

if ($action === 'delete_task') {
    $taskId = $_POST['taskId'] ?? '';
    $data = array_values(array_filter($data, fn($t) => $t['id'] !== $taskId));
    writeData($data);
    header('Location: ./'); exit;
}

// Helper
function progress($task) {
    $total = count($task['steps']);
    if ($total === 0) return 0;
    $done = count(array_filter($task['steps'], fn($s) => $s['done']));
    return round(($done / $total) * 100);
}
?>
<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>ADHD-friendly Task + Focus Timer</title>
<meta name="viewport" content="width=device-width, initial-scale=1">
<style>
    :root { --bg:#0f172a; --card:#111827; --text:#e5e7eb; --accent:#22c55e; --muted:#94a3b8; --danger:#ef4444; }
    body { background:var(--bg); color:var(--text); font-family:system-ui,-apple-system,Segoe UI,Roboto; margin:0; }
    .container { max-width:900px; margin:24px auto; padding:0 16px; }
    .grid { display:grid; grid-template-columns: 1fr 320px; gap:16px; }
    .card { background:var(--card); border-radius:12px; padding:16px; box-shadow:0 10px 25px rgba(0,0,0,0.25); }
    h1,h2 { margin:0 0 12px; }
    .row { display:flex; gap:8px; }
    input[type="text"] { width:100%; padding:10px; border-radius:8px; border:1px solid #334155; background:#0b1220; color:var(--text); }
    button { padding:10px 12px; border:none; border-radius:8px; cursor:pointer; background:#1f2937; color:var(--text); }
    button.primary { background:var(--accent); color:#062a12; font-weight:600; }
    button.danger { background:var(--danger); }
    .task { border:1px solid #334155; border-radius:10px; padding:12px; margin-bottom:10px; }
    .progress { height:8px; background:#1f2937; border-radius:999px; overflow:hidden; margin:8px 0; }
    .bar { height:100%; background:var(--accent); width:0%; transition:width .25s ease; }
    .steps { margin-top:8px; }
    .step { display:flex; align-items:center; gap:8px; padding:6px 0; }
    .muted { color:var(--muted); font-size:12px; }
    .pill { font-size:12px; padding:6px 8px; border:1px dashed #334155; border-radius:999px; display:inline-block; color:var(--muted); }
    .timer { text-align:center; }
    .big { font-size:52px; font-weight:700; letter-spacing:1px; margin:10px 0; }
    .center { display:flex; justify-content:center; gap:8px; }
    .success { color:var(--accent); }
</style>
</head>
<body>
<div class="container">
    <h1>ADHD-friendly Task + Focus Timer</h1>
    <p class="muted">Break work into tiny steps, timebox with short focus sessions, and celebrate quick wins.</p>
    <div class="grid">
        <div class="card">
            <h2>Tasks</h2>
            <form method="post" class="row" style="margin-bottom:12px;">
                <input type="hidden" name="action" value="add_task">
                <input type="text" name="title" placeholder="Add a task (keep it small)" required>
                <button class="primary" type="submit">Add</button>
            </form>

            <?php if (empty($data)): ?>
                <p class="muted">No tasks yet. Start with something you can finish in under 25 minutes.</p>
            <?php endif; ?>

            <?php foreach ($data as $task): ?>
                <div class="task">
                    <div class="row" style="justify-content:space-between;">
                        <div>
                            <strong><?php echo htmlspecialchars($task['title']); ?></strong>
                            <?php if ($task['done']): ?>
                                <span class="pill success">Done</span>
                            <?php endif; ?>
                        </div>
                        <div class="row">
                            <form method="post">
                                <input type="hidden" name="action" value="toggle_task">
                                <input type="hidden" name="taskId" value="<?php echo $task['id']; ?>">
                                <button type="submit"><?php echo $task['done'] ? 'Mark Undone' : 'Mark Done'; ?></button>
                            </form>
                            <form method="post">
                                <input type="hidden" name="action" value="delete_task">
                                <input type="hidden" name="taskId" value="<?php echo $task['id']; ?>">
                                <button class="danger" type="submit">Delete</button>
                            </form>
                        </div>
                    </div>

                    <div class="progress">
                        <div class="bar" style="width: <?php echo progress($task); ?>%;"></div>
                    </div>
                    <span class="muted"><?php echo progress($task); ?>% micro-steps complete</span>

                    <div class="steps">
                        <?php foreach ($task['steps'] as $step): ?>
                            <div class="step">
                                <form method="post">
                                    <input type="hidden" name="action" value="toggle_step">
                                    <input type="hidden" name="taskId" value="<?php echo $task['id']; ?>">
                                    <input type="hidden" name="stepId" value="<?php echo $step['id']; ?>">
                                    <button type="submit"><?php echo $step['done'] ? '✅' : '⬜'; ?></button>
                                </form>
                                <span><?php echo htmlspecialchars($step['text']); ?></span>
                            </div>
                        <?php endforeach; ?>

                        <form method="post" class="row">
                            <input type="hidden" name="action" value="add_step">
                            <input type="hidden" name="taskId" value="<?php echo $task['id']; ?>">
                            <input type="text" name="step" placeholder="Add a tiny step (2–5 min)" required>
                            <button type="submit">Add step</button>
                        </form>
                    </div>
                </div>
            <?php endforeach; ?>
        </div>

        <div class="card timer">
            <h2>Focus timer</h2>
            <div id="mode" class="pill">Focus: 25:00</div>
            <div class="big" id="clock">25:00</div>
            <div class="center">
                <button class="primary" onclick="startTimer()">Start</button>
                <button onclick="resetTimer()">Reset</button>
            </div>
            <p class="muted" id="tip">Tip: Close extra tabs. Put phone away. Pick the smallest next step.</p>
        </div>
    </div>
</div>
<script>
let mode = 'focus'; // 'focus' or 'break'
let remaining = 25*60; // seconds
let timerId = null;

function render() {
    const m = Math.floor(remaining / 60).toString().padStart(2,'0');
    const s = (remaining % 60).toString().padStart(2,'0');
    document.getElementById('clock').textContent = `${m}:${s}`;
    document.getElementById('mode').textContent = (mode === 'focus')
        ? `Focus: ${m}:${s}` : `Break: ${m}:${s}`;
    document.getElementById('tip').textContent = (mode === 'focus')
        ? 'Tip: Pick one tiny step and do only that.'
        : 'Tip: Stand, stretch, sip water. Eyes off screens.';
}

function startTimer() {
    if (timerId) return;
    timerId = setInterval(() => {
        remaining--;
        if (remaining <= 0) {
            new Audio('data:audio/wav;base64,UklGRiQAAABXQVZFZm10IBAAAAABAAEAESsAACJWAAACABAAZGF0YQAAAAA=').play();
            if (mode === 'focus') {
                mode = 'break'; remaining = 5*60;
            } else {
                mode = 'focus'; remaining = 25*60;
            }
        }
        render();
    }, 1000);
}

function resetTimer() {
    clearInterval(timerId); timerId = null;
    mode = 'focus'; remaining = 25*60; render();
}
render();
</script>
</body>
</html>

?>

The script uses:

readData() and writeData() to manage JSON storage.
POST actions (add_task, add_step, toggle_step, etc.) to update tasks.
JavaScript for the timer logic, switching between focus and break modes.

📊 Workflow Example

Add a task: “Prepare project report.”
Break it into micro‑steps: Draft outline → Write intro → Add charts → Review.
Start the 25‑minute timer and focus only on the first step.
Check off completed steps and watch the progress bar grow.
Take a 5‑minute break when the timer signals.

🚀 Why This Matters

For people with ADHD—or anyone struggling with productivity—this app provides:

Structure without rigidity: Tasks can be broken down endlessly.
Encouragement through feedback: Progress bars and checkmarks make achievements visible.
Simplicity: No database or complex setup, just run php -S localhost:8000.

💡 Future Enhancements

Add sound alerts for timer completion.
Sync tasks with Google Calendar.
Provide weekly statistics dashboards.
Enable multi-user support with authentication.

Conclusion

This PHP script application is more than just code — it’s a supportive tool for managing attention and productivity. By combining micro‑step task management with a Pomodoro‑style timer, it helps users stay focused, reduce overwhelm, and celebrate progress.

For developers, it’s also a great portfolio project: practical, lightweight, and impactful.

How to Build a MySQL Web CLI

iQuipe Digital — Wed, 24 Sep 2025 03:30:26 +0000

Creating a MySQL web CLI can be a powerful way to manage your database from any web browser. Using a combination of PHP, HTML, CSS, and JavaScript, you can build a secure, lightweight, and user-friendly interface that mimics a traditional terminal. This article will guide you through the process, using the provided code to explain each component and how they work together.

The Core Concept

The fundamental principle behind this web CLI is a client-server architecture. The browser acts as the client, handling the user interface and input. It sends commands to the server, which is a PHP script. The PHP script, in turn, connects to the MySQL database, executes the command, and sends the result back to the browser for display.

Step 1: Setting up the Project

You'll need a web server with PHP and a MySQL database. A local development environment like XAMPP, WAMP, or MAMP is ideal.

Start by creating a project folder (e.g., mysqlwebcli) in your web server's root directory. Inside this folder, you will place all the necessary files.

The project relies on the phpdotenv library to handle secure database credentials. Navigate to your project directory in the terminal and install it using Composer:

composer require vlucas/phpdotenv

This command creates a vendor directory and an autoload.php file, which your PHP scripts will use to access the library.

Next, create a .env file in the root directory and add your database credentials. This file keeps your sensitive information separate from your code.

.env

DB_SERVERNAME="localhost"
DB_USERNAME="your_username"
DB_PASSWORD="your_password"
DB_NAME="your_database"

Step 2: Building the Interface (HTML & CSS)

The HTML file, index.html, provides the structure for the CLI. It includes a command output area and an input section, styled to look like a terminal.

index.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Shell-style MySQL CLI</title>
    <link rel="stylesheet" href="style.css">
</head>
<body>
    <div class="dos-container">
        <div class="cli-output" id="output">
            <pre>$ Welcome to the MySQL CLI.</pre>
            <pre>$ Type 'help' to see all available commands.</pre>
        </div>
        <div class="cli-input-container">
            <pre id="cli-prompt">$</pre>
            <input type="text" id="command-input" autofocus>
        </div>
    </div>

    <input type="file" id="sql-file-input" accept=".sql" style="display: none;">

    <div id="modal" class="modal">
        <div class="modal-content">
            <span class="close-btn" id="close-modal">&times;</span>
            <pre id="modal-content"></pre>
            <p style="color:red; text-align:center; font-size:12px;">For security, this file is read-only. Edit on the server directly.</p>
        </div>
    </div>

    <script src="script.js"></script>
</body>
</html>

The style.css file transforms this structure into a sleek, dark-themed command-line interface. It uses monospaced fonts, vibrant green text, and a flexbox layout to create a full-screen, responsive design.

style.css

html, body {
    height: 100%;
    margin: 0;
    padding: 0;
    overflow: hidden; /* Prevents unwanted scrollbars on the main page */
}

body {
    background-color: #000;
    color: #00ff00; /* Classic green text on black */
    font-family: 'Consolas', 'Courier New', Courier, monospace;
    display: flex;
    justify-content: center;
    align-items: center;
}

.dos-container {
    width: 95%; /* Fits the browser window */
    height: 95%; /* Fits the browser window */
    border: none; /* No border for a cleaner look */
    padding: 10px;
    box-shadow: none; /* No box shadow */
    background-color: #000;
    display: flex;
    flex-direction: column;
}

.cli-output {
    flex-grow: 1; /* Makes this section fill all available vertical space */
    overflow-y: auto;
    white-space: pre-wrap;
    word-wrap: break-word;
    margin-bottom: 5px;
    padding-right: 15px;
    border: none; /* No border for the output area */
    scrollbar-color: #00ff00 #000;
    scrollbar-width: thin;
}

.cli-output pre {
    margin: 0;
    padding-left: 2px;
}

.cli-input-container {
    display: flex;
    align-items: center;
    gap: 5px;
    padding-top: 5px;
}

.cli-input-container pre {
    margin: 0;
    color: #00ff00;
    font-weight: bold;
}

#command-input {
    flex-grow: 1;
    background-color: transparent;
    border: none;
    color: #00ff00;
    font-family: 'Consolas', 'Courier New', Courier, monospace;
    font-size: 1em;
    outline: none;
    padding: 0;
    caret-color: #00ff00; /* Blinking green cursor */
}

/* Custom scrollbar for WebKit browsers */
.cli-output::-webkit-scrollbar {
    width: 10px;
}

.cli-output::-webkit-scrollbar-track {
    background: #000;
}

.cli-output::-webkit-scrollbar-thumb {
    background-color: #00ff00;
    border-radius: 5px;
    border: 2px solid #000;
}

pre {
    font-weight: bold;
}

/* --- Modal Styles --- */

/* The Modal (background) */
.modal {
  display: none; /* Hidden by default */
  position: fixed; /* Stay in place */
  z-index: 1; /* Sit on top of everything */
  left: 0;
  top: 0;
  width: 100%; /* Full width */
  height: 100%; /* Full height */
  overflow: auto; /* Enable scroll if needed */
  background-color: rgba(0,0,0,0.8); /* Black with opacity */
}

/* Modal Content */
.modal-content {
  background-color: #000;
  border: 2px solid #00ff00;
  margin: 15% auto; /* 15% from the top and centered */
  padding: 20px;
  width: 80%; /* Could be more or less, depending on screen size */
  max-width: 600px;
  color: #00ff00;
  font-family: 'Consolas', 'Courier New', Courier, monospace;
  position: relative;
}

.modal-content pre {
  white-space: pre-wrap;
  word-wrap: break-word;
  max-height: 400px;
  overflow-y: auto;
  border: none; /* Make the pre tag inside the modal also borderless */
}

/* The Close Button */
.close-btn {
  color: #00ff00;
  position: absolute;
  top: 10px;
  right: 20px;
  font-size: 28px;
  font-weight: bold;
  transition: all 0.2s ease-in-out;
}

.close-btn:hover,
.close-btn:focus {
  color: red;
  text-decoration: none;
  cursor: pointer;
}

p {
    margin: 0;
}

Step 3: Client-Side Logic (JavaScript)

The script.js file is the brain of the front end. It handles user input, manages the application's state, and communicates with the server.

Prompt Management: The script uses currentPrompt and currentDB variables to dynamically update the prompt ($, $msql>, or mysql>db>) as the user navigates through sessions and databases.
Command Parsing: It listens for user commands and uses regular expressions to match different input formats like start [db_name], q <- [query], or json<-q<- [query].
API Calls: Based on the command, it makes a fetch request to the appropriate PHP endpoint (execute.php, execute_json.php, etc.), sending the command and the current database name in the request body.
Special Commands: Commands like help and sysconfig are handled directly in the browser to reduce server load. The sysconfig command fetches the .env file content and displays it in a read-only modal for security.
File Uploads: When the upload sql command is entered, the script programmatically triggers a click on a hidden file input. Once a file is selected, it uses the FormData API to send the file to upload_sql.php.
Error Handling: The script provides user-friendly error messages if a command is not found or a server request fails.

script.js

document.addEventListener('DOMContentLoaded', () => {
    const commandInput = document.getElementById('command-input');
    const outputDiv = document.getElementById('output');
    const promptElement = document.getElementById('cli-prompt');
    const modal = document.getElementById('modal');
    const modalContent = document.getElementById('modal-content');
    const closeModalBtn = document.getElementById('close-modal');
    const sqlFileInput = document.getElementById('sql-file-input');

    let currentPrompt = '$';
    let currentDB = '';

    commandInput.focus();

    const updatePrompt = () => {
        if (currentDB) {
            promptElement.textContent = `mysql>${currentDB}>`;
        } else if (currentPrompt === '$msql>') {
            promptElement.textContent = `$msql>`;
        } else {
            promptElement.textContent = `$`;
        }
    };

    const helpGuide = `
Available Commands:

- help | h | hlp    : Show this help guide.
- mysql             : Start a MySQL session.
- exit              : Exit the current MySQL session.
- sysconfig         : View the contents of the .env file. (Read-only)

--- MySQL Session Commands ---

- start [db_name]   : Select a database to work with.
- close | close mydb : Close the current database connection.
- drop [db_name] | del [db_name] : Permanently delete a database.
- drop [tbl_name] | delete [tbl_name] : Permanently delete a table.
- list mydb | ls mydb : List all databases and their sizes.
- list table | ls table : List all tables in the current database.
- q <- [SQL query]  : Execute an SQL query and display results in a table.
- json<-q<- [SQL query]: Execute an SQL query and display results in JSON format.
- upload sql        : Upload and execute a .sql file.
- bkp [db_name] | backup [db_name] : Create and download a backup of a database.

Note: Commands are case-insensitive.

--- For Support and Feedback ---
- Visit: https://iquipedigital.com
- Email: support@iquipedigital.com
- GitHub: https://github.com/iquipe/mysqlwebcli
- License: MIT License
`;

    const executeCommand = async () => {
        const fullCommand = commandInput.value.trim();
        if (fullCommand === '') {
            return;
        }

        outputDiv.innerHTML += `\n<pre>${promptElement.textContent} ${fullCommand}</pre>`;

        const lowerCaseCommand = fullCommand.toLowerCase();
        let commandToSend = '';
        let endpoint = 'execute.php';
        let isBackupCommand = false;

        const startRegex = /^start\s+(\S+)$/i;
        const backupRegex = /^(bkp|backup)\s+(\S+)$/i;
        const jsonQueryRegex = /^json<-q<-\s*(.+)$/i;
        const sqlQueryRegex = /^q\s*<-\s*(.+)$/i;
        const dropDbRegex = /^(drop|delete|del)\s+(database|db)?\s*(\S+)$/i;
        const dropTableRegex = /^(drop|delete)\s+(\S+)$/i;

        const startMatch = lowerCaseCommand.match(startRegex);
        const backupMatch = lowerCaseCommand.match(backupRegex);
        const jsonMatch = fullCommand.match(jsonQueryRegex);
        const sqlMatch = fullCommand.match(sqlQueryRegex);
        const dropDbMatch = lowerCaseCommand.match(dropDbRegex);
        const dropTableMatch = lowerCaseCommand.match(dropTableRegex);

        if (lowerCaseCommand === 'help' || lowerCaseCommand === 'h' || lowerCaseCommand === 'hlp') {
            outputDiv.innerHTML += `<pre>${helpGuide}</pre>`;
        } else if (lowerCaseCommand === 'sysconfig') {
            try {
                const response = await fetch('get_env.php');
                const envContent = await response.text();
                modalContent.textContent = envContent;
                modal.style.display = 'block';
            } catch (error) {
                outputDiv.innerHTML += `<pre style="color: red;">Error: Could not retrieve .env file content.</pre>`;
            }
        } else if (backupMatch) {
            const dbName = backupMatch[2];
            endpoint = 'backup.php';
            commandToSend = dbName;
            isBackupCommand = true;
            outputDiv.innerHTML += `<pre>Starting backup of database '${dbName}'...</pre>`;
        } else if (lowerCaseCommand === 'mysql') {
            currentPrompt = '$msql>';
            outputDiv.innerHTML += `<pre>MySQL session started. Type 'start [database name]' to select a database.</pre>`;
        } else if (startMatch) {
            const dbName = startMatch[1];
            currentDB = dbName;
            currentPrompt = '$msql>';
            outputDiv.innerHTML += `<pre>Database changed to '${dbName}'.</pre>`;
        } else if (lowerCaseCommand === 'exit') {
            currentPrompt = '$';
            currentDB = '';
            outputDiv.innerHTML += `<pre>MySQL session terminated.</pre>`;
        } else if (lowerCaseCommand === 'close' || lowerCaseCommand === 'close mydb') {
            if (currentDB) {
                outputDiv.innerHTML += `<pre>Closed database '${currentDB}'.</pre>`;
                currentDB = '';
            } else {
                outputDiv.innerHTML += `<pre>No database is currently open.</pre>`;
            }
        } else if (lowerCaseCommand === 'list mydb' || lowerCaseCommand === 'ls mydb') {
            commandToSend = 'SPECIAL_COMMAND_LIST_DB';
        } else if (lowerCaseCommand.match(/^(list|ls)\s+(table|tbl)$/)) {
            if (currentDB) {
                commandToSend = 'SPECIAL_COMMAND_LIST_TABLES';
            } else {
                outputDiv.innerHTML += `<pre style="color: red;">No database selected. Use 'start [database name]' first.</pre>`;
            }
        } else if (lowerCaseCommand === 'upload sql') {
            sqlFileInput.click();
            outputDiv.innerHTML += `<pre>Please select a .sql file to upload...</pre>`;
        } else if (dropDbMatch) {
            const dbName = dropDbMatch[3];
            if (confirm(`WARNING: This will permanently delete the database '${dbName}'. Are you sure?`)) {
                endpoint = 'execute.php';
                commandToSend = `DROP DATABASE \`${dbName}\``;
                outputDiv.innerHTML += `<pre>Dropping database '${dbName}'...</pre>`;
                if (currentDB === dbName) {
                    currentDB = '';
                }
            } else {
                outputDiv.innerHTML += `<pre>Deletion canceled.</pre>`;
            }
        } else if (dropTableMatch && currentPrompt.startsWith('$msql>') && currentDB) {
            const tableName = dropTableMatch[2];
            if (confirm(`WARNING: This will permanently delete the table '${tableName}' from database '${currentDB}'. Are you sure?`)) {
                endpoint = 'execute.php';
                commandToSend = `DROP TABLE \`${tableName}\``;
                outputDiv.innerHTML += `<pre>Dropping table '${tableName}'...</pre>`;
            } else {
                outputDiv.innerHTML += `<pre>Deletion canceled.</pre>`;
            }
        } else if (currentPrompt.startsWith('$msql>') && jsonMatch) {
            commandToSend = jsonMatch[1].trim();
            endpoint = 'execute_json.php';
        } else if (currentPrompt.startsWith('$msql>') && sqlMatch) {
            commandToSend = sqlMatch[1].trim();
            endpoint = 'execute.php';
        } else {
            outputDiv.innerHTML += `<pre style="color: red;">Command not found. Type 'help' to see available commands.</pre>`;
        }

        updatePrompt();

        if (commandToSend) {
            try {
                const response = await fetch(endpoint, {
                    method: 'POST',
                    headers: {
                        'Content-Type': 'application/x-www-form-urlencoded',
                    },
                    body: `command=${encodeURIComponent(commandToSend)}&db=${encodeURIComponent(currentDB)}`
                });

                if (isBackupCommand) {
                    const blob = await response.blob();
                    const url = window.URL.createObjectURL(blob);
                    const a = document.createElement('a');
                    a.style.display = 'none';
                    a.href = url;
                    a.download = `backup_${commandToSend}.sql`;
                    document.body.appendChild(a);
                    a.click();
                    window.URL.revokeObjectURL(url);
                    outputDiv.innerHTML += `<pre>Backup file downloaded.</pre>`;
                } else if (endpoint === 'execute_json.php') {
                    const result = await response.json();
                    outputDiv.innerHTML += `<pre>${JSON.stringify(result, null, 2)}</pre>`;
                } else {
                    const result = await response.text();
                    outputDiv.innerHTML += `<pre>${result}</pre>`;
                }
            } catch (error) {
                outputDiv.innerHTML += `<pre style="color: red;">Error: Could not connect to the server or invalid response.</pre>`;
            }
        }

        commandInput.value = '';
        outputDiv.scrollTop = outputDiv.scrollHeight;
    };

    commandInput.addEventListener('keydown', (e) => {
        if (e.key === 'Enter') {
            e.preventDefault();
            executeCommand();
        }
    });

    sqlFileInput.addEventListener('change', async (event) => {
        const file = event.target.files[0];
        if (!file) {
            outputDiv.innerHTML += `<pre style="color: red;">No file selected.</pre>`;
            return;
        }

        const formData = new FormData();
        formData.append('sql_file', file);
        formData.append('db', currentDB);

        outputDiv.innerHTML += `<pre>Uploading and executing '${file.name}'...</pre>`;
        outputDiv.scrollTop = outputDiv.scrollHeight;

        try {
            const response = await fetch('upload_sql.php', {
                method: 'POST',
                body: formData,
            });

            const result = await response.text();
            outputDiv.innerHTML += `<pre>${result}</pre>`;
        } catch (error) {
            outputDiv.innerHTML += `<pre style="color: red;">Error during file upload and execution.</pre>`;
        }

        sqlFileInput.value = '';
        commandInput.focus();
        outputDiv.scrollTop = outputDiv.scrollHeight;
    });

    if (closeModalBtn) {
        closeModalBtn.onclick = () => {
            modal.style.display = 'none';
            commandInput.focus();
        };
        window.onclick = (event) => {
            if (event.target === modal) {
                modal.style.display = 'none';
                commandInput.focus();
            }
        };
    }
});

Step 3: Server-Side Logic (PHP)

download GitHub: https://github.com/iquipe/mysqlwebcli

The Browser is the New Terminal: A First Look at Iquipe Digital’s Revolutionary Web CLI

iQuipe Digital — Sun, 31 Aug 2025 13:24:04 +0000

In today's fast-paced development landscape, the need for immediate, secure access to server resources is paramount. Traditional methods often require setting up SSH clients, managing credentials, and navigating complex terminal environments. Iquipe Digital recognized this friction point and engineered a solution that combines the power of a command-line interface with the universal accessibility of a web browser. The result is SolarWind Web CLI—a tool that empowers developers to work smarter, not harder.

Core Features: More Than Just a Terminal

SolarWind Web CLI is packed with features designed for efficiency and ease of use. At its core, it provides a direct line to your server's PHP engine.

Direct Function Execution: Instantly run native or custom PHP functions. Need to hash a string or perform a quick calculation? It's as simple as typing a command.
- $> add <- 4 5
- Returns: 9
- $> hashstring <- mysecretpassword
Interactive and Contextual Commands: The CLI is designed for dynamic interaction. Pass arguments to commands for personalized outputs, perfect for greeting users or running functions with specific parameters.
- $> sayhello <- guest
- Returns: Hello, guest!

Integrated Database Mode: One of the standout features is the seamless integration with SQLite. With a simple command, developers can initiate a database session and perform real-time data operations without ever leaving the browser.
- $db> start <- db_test.sqlite
- Database session started with 'db_test.sqlite'.
- $db>db_test.sqlite> q <- select * from products

Intelligent Error Feedback: To streamline debugging and shorten the learning curve, the CLI provides clear, concise feedback for syntax errors, helping developers identify and fix issues rapidly.

A Practical Use Case: On-the-Fly Database Management

Imagine an administrator for a media streaming service needing to quickly verify the contents of a playlist. Instead of a lengthy SSH login process, they can use the SolarWind Web CLI.

By starting a database session with $db> start <- media_library.sqlite, they can immediately query the playlist_list table. A command like $db>media_library.sqlite> q <- select * from playlist_list would instantly return structured data, such as:

PlaylistDetailsToken	Jazz Musise	Smooth jazz vibes
`db8a-9d51-9a5d-33e9-f085-4e7a-90f9`	Ghana Track	Local favorites
`146f-1d35-d43f-43b8-982b-79cc-ba45`

This demonstrates the tool's immense power for lightweight database administration, content management, and rapid prototyping.

Our Commitment: Open Source and Security

Iquipe Digital firmly believes in the power of open-source technology. That is why SolarWind Web CLI is released under the GPL v3 License. This ensures that the tool remains transparent, community-driven, and perpetually free for developers to use, modify, and distribute. This license choice underscores our commitment to building secure, compliant, and auditable software that the development community can trust.

Why SolarWind Web CLI Matters

This tool is more than a convenience; it is a versatile solution for a wide range of applications:

Remote Server Management: Provides a secure and straightforward way to manage servers from any location without a dedicated terminal client.
Lightweight SaaS Admin Panels: Serves as a powerful, low-overhead backend interface for administrators of SaaS applications.
Educational Platforms: Offers a safe, sandboxed environment for students and new developers to learn PHP, SQL, and command-line principles.
Internal Corporate Tools: Enables teams in regulated environments to perform quick, audited actions on internal systems.

Final Thoughts: Innovation by Iquipe Digital

SolarWind Web CLI is a testament to Iquipe Digital's dedication to developer empowerment, innovation, and accessibility. By bringing the robust capabilities of the command line to the simplicity of a web browser, we are providing a tool that streamlines workflows, enhances productivity, and lowers the barrier to entry for server-side development. We are proud to offer SolarWind Web CLI to the global developer community and look forward to seeing the incredible applications it will power.

About Iquipe Digital:
Iquipe Digital is a forward-thinking technology company specializing in the development of innovative digital tools and platforms. Our mission is to create secure, efficient, and user-centric software that solves real-world challenges for developers and businesses alike.

Query JSON Data Like a Database

iQuipe Digital — Thu, 17 Jul 2025 05:40:31 +0000

Introducing JSONSQL

In the world of modern web development and APIs, JSON (JavaScript Object Notation) has become the dominant data format for structured data exchange. But working with JSON—especially nested or complex structures—can be time-consuming and cumbersome without the right tools. That’s why we’re excited to introduce JSONSQL — a powerful online utility developed by Iquipe Digital that lets you query JSON data using SQL syntax.

What Is JSONSQL?

JSONSQL is an intelligent web-based tool that allows developers, data analysts, and students to perform SQL-like queries directly on JSON data. Whether you're working with API responses, configuration files, or dynamic datasets, JSONSQL bridges the gap between traditional relational querying and flexible JSON formats.

It’s as simple as:

Paste your JSON data
Write an SQL-like query
Get instant results

Why Use JSONSQL?

Here’s why this tool stands out:

✅ SQL Familiarity

Most developers already know SQL. JSONSQL lets you apply familiar SQL commands (like SELECT, WHERE, ORDER BY, LIMIT) to JSON documents without needing to convert the data to a relational database.

✅ Save Time

Tired of writing complex loops or using external libraries just to filter or group JSON data? JSONSQL does it instantly — right in your browser.

✅ API & Web Debugging

Dealing with third-party APIs? JSONSQL is perfect for inspecting and querying API responses quickly.

✅ Learn & Prototype

It’s a great learning tool for students and beginner developers to understand how data can be structured, queried, and manipulated.

Features at a Glance

🔍 Live JSON Querying: Paste JSON and query in real time.
🧠 Smart Parser: Automatically detects nested structures and flattens them for easier querying.
📤 Export Results: Easily copy or download query results.
🌐 Fully Browser-Based: No installation required.
⚡ Fast and Lightweight: Built for performance, with no bloat.

Sample Use Case

Suppose you have this JSON:

[
  {"id": 1, "name": "Alice", "age": 24},
  {"id": 2, "name": "Bob", "age": 30},
  {"id": 3, "name": "Carol", "age": 22}
]

With JSONSQL, you can write a query like:

SELECT name FROM data WHERE age > 23 ORDER BY age DESC

$results1 = $db->where('users', 'age', '>', 23);

And get:

[
  {"name": "Bob"},
  {"name": "Alice"}
]

Simple, clean, and powerful.

Who Should Use JSONSQL?

🌍 Web Developers working with RESTful APIs
📊 Data Analysts needing quick JSON insights
🧪 QA Engineers testing API responses
🧑‍🎓 Students learning JSON, data querying, and structure
⚙️ Backend Engineers prototyping logic before implementation

Access JSONSQL Now

Start using it today — no login required:
👉 https://doc.iquipedigital.com/jsonsql/

Whether you’re a seasoned developer or just starting out, JSONSQL will save you hours of parsing, filtering, and restructuring data manually.

🔗 About Iquipe Digital

Iquipe Digital is dedicated to building smart, user-focused tools that simplify the way we interact with technology. From cloud solutions to data tools, our goal is to empower the next generation of African developers with modern, lightweight, and powerful platforms.

Retrieving System MAC Address Across OS Platforms

iQuipe Digital — Sat, 24 May 2025 22:08:52 +0000

Hey Devs! 👋

Ever needed to programmatically fetch the MAC (Media Access Control) address of the server your PHP script is running on? It can be handy for various tasks like licensing, device identification, or network-specific configurations.

Today, we'll break down a PHP function that does just that, catering to both Windows and Linux/Unix/Mac environments.

The Code 💻

Here's the PHP function we'll be dissecting:

<?php
function getMacAddress() {
    if (strtoupper(substr(PHP_OS, 0, 3)) === 'WIN') {
        // For Windows
        ob_start();
        system('getmac');
        $output = ob_get_contents();
        ob_clean();

        if (preg_match('/([0-9A-F]{2}[:-]){5}([0-9A-F]{2})/i', $output, $matches)) {
            return $matches[0];
        }
        return false;
    } else {
        // For Linux/Unix/Mac
        $command = "ifconfig -a | grep -Po 'HWaddr \K.*$'"; // \K keeps what's after it
        $mac = trim(exec($command));
        if (empty($mac)) {
            // Alternative method for newer Linux systems or if ifconfig is not available
            $command = "ip link | grep -Po 'ether \K.*$'";
            $mac = trim(exec($command));
        }
        return !empty($mac) ? $mac : false;
    }
}

// Get and display MAC address
try {
    $macAddress = getMacAddress();
    if ($macAddress) {
        echo "System MAC Address: " . $macAddress;
    } else {
        echo "Could not retrieve MAC address.";
    }
} catch (Exception $e) {
    echo "Error getting MAC address: " . $e->getMessage();
}
?>

How It Works 🧐

Let's break down the getMacAddress() function step-by-step.

1. Operating System Detection

if (strtoupper(substr(PHP_OS, 0, 3)) === 'WIN') {
    // Windows-specific logic
} else {
    // Linux/Unix/Mac specific logic
}

The first thing the function does is check the operating system. PHP_OS is a predefined constant in PHP that holds the name of the OS PHP was built on. We take the first three characters, convert them to uppercase, and check if it's 'WIN' for Windows.

2. Windows MAC Address Retrieval

// For Windows
ob_start();
system('getmac');
$output = ob_get_contents();
ob_clean();

if (preg_match('/([0-9A-F]{2}[:-]){5}([0-9A-F]{2})/i', $output, $matches)) {
    return $matches[0];
}
return false;

If the OS is Windows:

ob_start(): Output buffering is turned on. This means any output from commands like system() will be captured instead of being directly sent to the browser/console.
system('getmac'): The getmac command is executed. This is a standard Windows command-line utility to display MAC addresses.
$output = ob_get_contents(): The captured output from getmac is stored in the $output variable.
ob_clean(): The output buffer is cleaned and turned off.
preg_match('/([0-9A-F]{2}[:-]){5}([0-9A-F]{2})/i', $output, $matches): A regular expression is used to find the MAC address pattern (e.g., 00-1A-2B-3C-4D-5E or 00:1A:2B:3C:4D:5E) within the output.
- ([0-9A-F]{2}[:-]){5}: Matches five groups of two hexadecimal characters followed by a colon or a hyphen.
- ([0-9A-F]{2}): Matches the last group of two hexadecimal characters.
- /i: Makes the match case-insensitive.
If a match is found, $matches[0] (which contains the full matched MAC address) is returned. Otherwise, false is returned.

3. Linux/Unix/Mac MAC Address Retrieval

// For Linux/Unix/Mac
$command = "ifconfig -a | grep -Po 'HWaddr \K.*$'";
$mac = trim(exec($command));
if (empty($mac)) {
    // Alternative method
    $command = "ip link | grep -Po 'ether \K.*$'";
    $mac = trim(exec($command));
}
return !empty($mac) ? $mac : false;

If the OS is not Windows (implicitly Linux, Unix, or macOS):

$command = "ifconfig -a | grep -Po 'HWaddr \K.*$'";:
- ifconfig -a: This command is commonly used on Unix-like systems to display network interface configuration. The -a flag ensures all interfaces are listed, even if they are down.
- | grep -Po 'HWaddr \K.*$': The output of ifconfig -a is piped to grep.
  - -P: Interprets the pattern as a Perl-compatible regular expression (PCRE).
  - -o: Prints only the matched (non-empty) parts of a matching line.
  - 'HWaddr \K.*$': This regex looks for the string "HWaddr " (hardware address). The \K is a nifty feature that tells grep to discard everything matched up to that point and only output what comes after. .*$ matches the rest of the line, which should be the MAC address.
$mac = trim(exec($command)): The command is executed using exec(), which returns the last line of the command's output. trim() removes any leading/trailing whitespace.
Fallback Method:
```
if (empty($mac)) {
    $command = "ip link | grep -Po 'ether \K.*$'";
    $mac = trim(exec($command));
}
```
ifconfig is being deprecated on some newer Linux distributions in favor of the ip command. If the first command fails to retrieve a MAC address (i.e., $mac is empty), this block tries an alternative:
- ip link: This command is part of the iproute2 suite and is used to display and manipulate network devices and routing.
- | grep -Po 'ether \K.*$': Similar to before, this grep command extracts the MAC address. On systems using ip link, MAC addresses are typically preceded by the keyword "ether ".
return !empty($mac) ? $mac : false;: If a MAC address was successfully retrieved (i.e., $mac is not empty), it's returned. Otherwise, false is returned.

4. Usage and Error Handling

// Get and display MAC address
try {
    $macAddress = getMacAddress();
    if ($macAddress) {
        echo "System MAC Address: " . $macAddress;
    } else {
        echo "Could not retrieve MAC address.";
    }
} catch (Exception $e) {
    echo "Error getting MAC address: " . $e->getMessage();
}

This part demonstrates how to use the getMacAddress() function:

It's wrapped in a try-catch block to handle any potential exceptions that might occur during the execution of system commands (though system() and exec() in PHP typically raise warnings/errors that might not be caught as exceptions unless error handling is configured to do so).
It calls getMacAddress() and stores the result.
It then checks if a MAC address was returned and prints it or an appropriate message.

Important Considerations ⚠️

Permissions: The PHP script needs sufficient permissions to execute system commands like getmac, ifconfig, or ip link. This can be a concern in shared hosting environments or secured server setups (safe_mode or disable_functions in php.ini could prevent system() or exec() from running).
Multiple Interfaces: Servers can have multiple network interfaces (e.g., Ethernet, Wi-Fi, virtual adapters). This script, particularly the Linux/Unix part, might return the MAC address of the first interface it successfully parses that matches the pattern. If you need a specific interface's MAC, the commands would need to be more targeted (e.g., ifconfig eth0 or ip link show eth0). The current Windows getmac command often lists multiple MACs; the regex picks the first valid one it finds in the output.
Security: Allowing PHP to execute arbitrary system commands can be a security risk if not handled carefully. Ensure that any user input that might influence the commands is thoroughly sanitized (though in this specific script, the commands are hardcoded).
Environment Differences: The exact output of ifconfig and ip link can vary slightly between different Linux distributions or Unix-like systems. The provided grep patterns are fairly common but might need adjustments in some edge cases.
Virtualization/Containers: In virtualized environments or containers (like Docker), the MAC address retrieved might be the one assigned to the virtual interface within the container, not necessarily the physical host's MAC address.

Conclusion

This PHP snippet provides a practical way to retrieve a system's MAC address across different operating systems. While it covers common scenarios, remember the considerations above, especially regarding permissions and the presence of multiple network interfaces.

Happy coding! 🚀

Your Guide to Simple JSON Data Management with PHP

iQuipe Digital — Fri, 09 May 2025 10:30:02 +0000

Ever found yourself needing a simple way to store and manage data without the fuss of setting up a full-blown database? Maybe you're building a small API, a personal project, or just want a quick solution for data persistence. If that sounds familiar, you're in the right place!

This article will walk you through a handy PHP script, the JsonCRUD class, which lets you perform basic Create, Read, Update, and Delete (CRUD) operations directly on a JSON file. It's lightweight, easy to understand, and can be a real lifesaver for certain scenarios.

Meet the Hero: The JsonCRUD Class

Let's take a look at the code that will simplify your data management:

<?php
class JsonCRUD {
    private $file;

    public function __construct($filename) {
        $this->file = $filename;
        if (!file_exists($this->file)) {
            file_put_contents($this->file, json_encode([]));
        }
    }

    private function readData() {
        $json = file_get_contents($this->file);
        return json_decode($json, true) ?: [];
    }

    private function writeData($data) {
        file_put_contents($this->file, json_encode($data, JSON_PRETTY_PRINT));
    }

    public function create($item) {
        $data = $this->readData();
        $item['id'] = uniqid();
        $data[] = $item;
        $this->writeData($data);
        return $item;
    }

    public function read($id = null) {
        $data = $this->readData();
        if ($id === null) return $data;
        foreach ($data as $item) {
            if ($item['id'] === $id) return $item;
        }
        return null;
    }

    public function update($id, $newData) {
        $data = $this->readData();
        foreach ($data as &$item) {
            if ($item['id'] === $id) {
                $item = array_merge($item, $newData);
                $this->writeData($data);
                return $item;
            }
        }
        return null;
    }

    public function delete($id) {
        $data = $this->readData();
        foreach ($data as $i => $item) {
            if ($item['id'] === $id) {
                array_splice($data, $i, 1);
                $this->writeData($data);
                return true;
            }
        }
        return false;
    }

    public function search($key, $value) {
        $data = $this->readData();
        $results = [];
        foreach ($data as $item) {
            if (isset($item[$key]) && stripos($item[$key], $value) !== false) {
                $results[] = $item;
            }
        }
        return $results;
    }
}
?>

Breaking Down the Magic: How to Use It

Let's walk through how to implement and use each part of this JsonCRUD class in your PHP projects.

1. Include the Class:

First, save the code above in a PHP file (e.g., JsonCRUD.php). Then, in your script where you want to use it, include the file:

<?php
require_once 'JsonCRUD.php';
?>

2. Instantiate the Class:

To start using the class, you need to create an instance of it, providing the name of the JSON file you want to work with:

<?php
$dataManager = new JsonCRUD('my_data.json');
?>

If my_data.json doesn't exist, the class will automatically create it for you with an empty JSON array ([]).

3. Creating Data (create)

To add a new item to your JSON file, use the create() method. It takes an associative array representing the data you want to store:

<?php
$newItem = $dataManager->create(['name' => 'Alice', 'age' => 30, 'city' => 'New York']);
print_r($newItem);
// Output might look like: Array ( [name] => Alice [age] => 30 [city] => New York [id] => 645a8e6d9e2f1 )
?>

Notice that the create() method automatically adds a unique id to your item. This is helpful for identifying and manipulating specific data entries later.

4. Reading Data (read)

You have two ways to read data using the read() method:

Read all data: Call the method without any arguments to retrieve all items from the JSON file:
```
<?php
$allData = $dataManager->read();
print_r($allData);
?>
```

Read a specific item: Provide the id of the item you want to retrieve:

<?php
$specificItem = $dataManager->read('645a8e6d9e2f1'); // Replace with an actual ID
print_r($specificItem);
// Output might look like: Array ( [name] => Alice [age] => 30 [city] => New York [id] => 645a8e6d9e2f1 )
?>

5. Updating Data (update)

To modify an existing item, use the update() method. It requires the id of the item you want to update and an associative array containing the new data:

<?php
$updatedItem = $dataManager->update('645a8e6d9e2f1', ['age' => 31, 'occupation' => 'Engineer']);
print_r($updatedItem);
// Output might look like: Array ( [name] => Alice [age] => 31 [city] => New York [id] => 645a8e6d9e2f1 [occupation] => Engineer )
?>

6. Deleting Data (delete)

To remove an item, simply call the delete() method with the id of the item you want to delete:

<?php
$deletionResult = $dataManager->delete('645a8e6d9e2f1');
if ($deletionResult) {
    echo "Item deleted successfully!";
} else {
    echo "Item not found.";
}
?>

7. Searching Data (search)

The search() method allows you to find items based on a specific key and a search value. It performs a case-insensitive search:

<?php
$searchResults = $dataManager->search('city', 'york');
print_r($searchResults);
// Output might look like: Array ( [0] => Array ( [name] => Alice [age] => 31 [city] => New York [id] => 645a8e6d9e2f1 [occupation] => Engineer ) )
?>

Use Cases: Where This Script Shines

This JsonCRUD class is particularly useful for:

Small APIs: For simple data endpoints where a full database might be overkill.
Configuration files: Managing application settings in an organized way.
Basic data logging: Storing simple events or records.
Personal projects: Where ease of setup is a priority.
Prototyping: Quickly mocking up data storage for testing purposes.

Benefits and Limitations

Benefits:

Simplicity: Easy to understand and implement.
Lightweight: No database setup or external dependencies required.
Portability: The entire dataset is contained within a single file.
Human-readable data: JSON format is easy to inspect and edit manually if needed.

Limitations:

Not suitable for high-traffic applications: File-based operations can become slow with a large number of concurrent requests.
Limited query capabilities: The built-in search is basic. For complex queries, you might need to load all data and process it in PHP.
No built-in data integrity or security features: You'll need to implement these yourself if required.

Final Thoughts

The JsonCRUD class provides a straightforward and efficient way to manage data in simple PHP applications using JSON files. While it might not be the solution for every project, it's a valuable tool to have in your development toolkit for those times when simplicity and speed of implementation are key.

Have you ever used JSON files for data storage? What are your favorite techniques for simple data management in PHP? Share your thoughts and experiences in the comments below!

Streamline File Synchronization with FTP-Sync: A Guide for VS Code Users

iQuipe Digital — Tue, 29 Apr 2025 07:45:26 +0000

The FTP-Sync extension for Visual Studio Code is a powerful tool that allows developers to seamlessly sync their project files with an FTP server. Whether you're a web developer managing remote files or working on collaborative projects, this extension simplifies the process, saving you time and effort. In this article, we'll walk you through installing, configuring, and utilizing FTP-Sync effectively.

Why FTP-Sync?

FTP-Sync enables you to:

Sync files automatically with uploadOnSave.
Customize configurations for various projects.
Use advanced features like SFTP protocol and SSH keys.
Exclude or include specific files based on patterns.

Step-by-Step Installation Guide

Install FTP-Sync Extension
- Open Visual Studio Code.
- Navigate to the Extensions tab by pressing Ctrl+Shift+X.
- Search for "FTP-Sync" in the marketplace.
- Click Install to add the extension.
Initialize Configuration
- Open the command palette (Ctrl+Shift+P) and type Ftp-sync: Init.
- Select Ftp-sync: Init to create a configuration file in your .vscode folder. This file is typically named ftp-sync.json.

Configuring FTP-Sync

Inside the ftp-sync.json file, you'll find various parameters to set up. Here's how to configure the key options:

remotePath: Define the directory on your server to sync files to (e.g., ./public_html).
host: Enter the hostname of your FTP server (e.g., ftp.example.com).
username and password: Provide your FTP account credentials.
protocol: Specify ftp or sftp.
uploadOnSave: Set to true if you want files uploaded automatically upon saving.
passive: Configure passive mode; the default is false.

Here’s an example configuration:

{
  "remotePath": "/public_html",
  "host": "ftp.example.com",
  "username": "yourUsername",
  "password": "yourPassword",
  "port": 21,
  "protocol": "ftp",
  "uploadOnSave": true,
  "passive": false,
  "debug": false
}

Using FTP-Sync

With the configuration in place, you can:

Upload a Single File: Right-click on the file in VS Code and select Ftp-sync: Upload File.
Sync Entire Workspace: Use the command palette to choose Ftp-sync: Sync Local to Remote.
Download Files: Similarly, select Ftp-sync: Sync Remote to Local to pull files from the server.

FTP-Sync provides debugging output for troubleshooting issues and supports file exclusion patterns via the ignore parameter, helping you manage files more efficiently.

Conclusion

The FTP-Sync extension is a simple yet versatile tool for developers who frequently work with remote servers. By following this step-by-step guide, you'll be equipped to integrate it seamlessly into your workflow and unlock its full potential.