Wednesday, March 20, 2024

How to Import UTF-8 CSV Files in Excel 2024 – A Step-by-Step Guide


Have you encountered roadblocks when trying to import UTF-8 CSV files into Excel 2024? If you've attempted the double-click routine only to meet with frustration, you're not alone. But take heart—the journey to seamless importation is closer than you think. This streamlined guide is crafted to navigate you through the process effortlessly.


Starting Up

Start by opening Microsoft Excel 2024 and selecting a Blank Workbook. This clean slate will serve as the foundation for your data import journey.

Data Tab Navigation

Direct your attention to the "Data" tab situated in the ribbon at the top of Excel. This hub is where the magic begins!

Acquiring Data

Within the "Data" tab, you will find the "Get Data" button. Click on "From Text (Legacy)" to initiate the import of your CSV file. This step is crucial as it sets the stage for proper file handling.

File Selection

Next, navigate to the location where your Unicode CSV file is stored, select it, and then confirm your selection by clicking the "Get Data" button.

Text Import Wizardry

Upon selection, Excel will display a preview of the data. It might auto-select a file origin type, but here's a critical tip: ensure you alter the "File Origin" to "Unicode (UTF-8)" for accurate Unicode character processing.

Setting the Delimiter

Ascertain that the delimiter is correctly set to "comma" or another appropriate character that segregates your CSV values, then proceed to click "Finish".

Finalizing Import

You are presented with a choice to embed the data into an Existing or New Sheet. Choose according to your data organization preferences.


By following these methodical steps, you can ensure that your UTF-8 CSV files are imported into Excel 2024 without any character encoding issues, maintaining the integrity of your precious data.

This process may seem intricate at first glance, but with practice, it becomes second nature.

Please comment if you found it helpful!

Tuesday, August 22, 2023

Laravel 10 Local Development: A Docker Compose for SSL, Database, Mock API, and Email


In the modern development environment, creating a robust and flexible local development setup is crucial for success as a programmer. Laravel, a popular PHP framework, has evolved over the years to adapt to these demands. In this article, we will take a closer look at an advanced Dockerfile configuration that extends Laravel 10's out-of-the-box setup to include SSL, local testing databases, Mock API servers, and a mock email server.

The Complete File

version: '3'
            context: ./vendor/laravel/sail/runtimes/8.2
            dockerfile: Dockerfile
                WWWGROUP: '${WWWGROUP}'
        image: sail-8.2/app
        container_name: ${COMPOSE_PROJECT_NAME}-application
            - 'host.docker.internal:host-gateway'
            - '${VITE_PORT:-5173}:${VITE_PORT:-5173}'
            WWWUSER: '${WWWUSER}'
            LARAVEL_SAIL: 1
            XDEBUG_MODE: '${SAIL_XDEBUG_MODE:-off}'
            XDEBUG_CONFIG: '${SAIL_XDEBUG_CONFIG:-client_host=host.docker.internal}'
            - '.:/var/www/html'
            - mariadb
            - smtp
            - mockApiServer

        image: mariadb:10.6
        container_name: ${COMPOSE_PROJECT_NAME}-mariadb
            - '${FORWARD_DB_PORT:-3306}:3306'
            MYSQL_ROOT_HOST: '%'
            MYSQL_USER: '${DB_USERNAME}'
            - './docker/mariadb/storage/data:/var/lib/mysql'
            - './vendor/laravel/sail/database/mysql/'
            test: [ "CMD", "mysqladmin" ,"ping", "-p${DB_PASSWORD}" ]
            retries: 3
            timeout: 5s

            context: "./docker/caddy"
            dockerfile: Dockerfile
                WWWGROUP: "${WWWGROUP}"
        container_name: ${COMPOSE_PROJECT_NAME}-caddy
        restart: unless-stopped
            - "${APP_PORT:-80}:80"
            - "${APP_SSL_PORT:-443}:443"
            LARAVEL_SAIL: 1
            HOST_DOMAIN: laravel.test
            - "./docker/caddy/Caddyfile:/etc/caddy/Caddyfile"
            - ".:/srv:cache"
            - "./docker/caddy/storage/certificates:/data/caddy/certificates/local"
            - "./docker/caddy/storage/authorities:/data/caddy/pki/authorities/local"
            - "./docker/caddy/storage/data:/data:cache"
            - "./docker/caddy/storage/config:/config:cache"
            - laravel.test

        image: mailhog/mailhog
        container_name: ${COMPOSE_PROJECT_NAME}-email
            driver: none  # disable saving logs
            - "1025:1025" # smtp server
            - "8025:8025" # web ui

        # Mock API server to test against third-party services
        # without having to hit the real production server. One does need to
        # add any desired API configurations in the mockserver-initializer.json
        # file.
        container_name: ${COMPOSE_PROJECT_NAME}-mock-api-server
        image: mockserver/mockserver
            - "1080:1080"
            TZ: "America/New_York"
            MOCKSERVER_PROPERTY_FILE: /config/
            MOCKSERVER_INITIALIZATION_JSON_PATH: /config/mockserver-initializer.json
            - './docker/mockApiServer:/config'

The Servers

System Diagram


The caddy server is an open-source web server with automatic HTTPS. It is used to provide SSL to the Laravel application and handle reverse proxying.


  • WWWGROUP: Similar to the Laravel application server, this variable defines the group used by the web server.
  • Ports: Exposes the standard HTTP and HTTPS ports.
  • Environment: Contains settings related to domain handling.
  • Reverse Proxy: Redirects requests to the Laravel application, adding necessary headers for proper functioning.


This server is responsible for hosting the Laravel application. It handles web requests, communicates with the database and APIs, and sends notifications like email.


  • WWWGROUP: This variable defines the group ID for the web server process. If unset, the default group ID from the host system is used.
  • WWWUSER: This variable defines the user ID for the web server process. If it is not set, the default user ID from the host system is used. These variables are optional and can remain unset, allowing the system to use default values.
  • Ports: Maps the application's internal port to an external port on the host system.
  • Environment: Contains environment-specific settings like XDEBUG and IGNITION.
  • Volumes: Mounts the application code into the container's file system.


This server provides the MariaDB database system, a popular and robust open-source SQL database management system, essential for storing and managing data in your Laravel application.


  • MYSQL_ROOT_PASSWORD, MYSQL_DATABASE, etc.: These variables control the database access, defining the root password, user credentials, and even allowing for an empty password. This flexibility provides different levels of security based on your environment needs. Out of the box, Laravel uses environment variables with the DB_ prefix.
  • Ports: Allows communication with the database from the host system.
  • Volumes: Ensures data persistence across container restarts.
  • Healthcheck: Provides a mechanism to check if the database is running properly.


The SMTP server, implemented here using Mailhog, allows for the sending of test email messages. This aids in developing and testing email functionalities within the Laravel application without the risk of accidentally sending test messages outside the local environment to real people.


  • Ports: Exposes SMTP server and web UI for interaction and inspection.


The Mock API server allows for mimicking interactions with third-party applications, without the need to interact with real production servers. It helps in testing and developing features that rely on external APIs.


  • Ports: Maps the internal port to allow interactions from the host system.
  • Environment: Sets up specific properties like time zones and paths to configurations. For example, mockserver-initializer.json is where you configure mock responses that would normally go to third-party production REST APIs.


The variable 'COMPOSE_PROJECT_NAME' is used to customize the naming of Docker containers, networks, and volumes, providing a way to make the Docker compose file more portable and reusable. It affects the prefixes and network name, helping to avoid conflicts and facilitate organization.

The .env File

Located in the same folder as the docker-compose file, the .env file is a powerful way to manage environment-specific settings.




This generic Docker compose file for Laravel 10 projects not only provides a seamless local development environment but also makes it easily adaptable across various projects. By encapsulating complex setups like SSL, test databases, Mock API servers, and email handling, it offers a robust platform that can be tailored to specific needs without unnecessary complexity. Future articles may delve into each server's functionality, providing readers with even more insights into this powerful configuration.

Please let me know in the comments section to tell me about your experiences with using Laravel in Docker. What kinds of challenges have you faced? What problems and solutions have you found? Are there other Docker containers that might be useful for other developers to consider (like Redis)? Would you like additional articles focused on individual servers?

Saturday, August 12, 2023

Setting Defaults in Laravel Eloquent Models: 5 Powerful Techniques


When working with Laravel Eloquent Models, setting default values for various attributes can be an essential requirement. In this post, we'll explore five different ways to set default values in a Laravel 10 Eloquent Model, each with unique characteristics and use cases.

  1. Use of the $attributes Array
    The simplest and most straightforward way to set default values for your Eloquent model's attributes. Only accepts scalar defaults and applies only to the initial object.
  2. Using Accessors
    Allows considering other attributes of the Model and applies dynamically throughout the lifecycle of the Model. It enables manipulation of attribute values dynamically.
  3. Using Database Defaults
    Best for attributes that have little to do with data retrieved by the application, like timestamps and IDs. It may also be used as a last resort in some cases.
  4. Use of Protected static function boot()
    Allows using a method or service to set a default value at initialization. Useful when scalar defaults are not sufficient.
  5. Using CastsAttributes
    Casting allows converting attribute values and setting defaults through custom casting. Requires that the attribute already be set when retrieving and may require setting an initial value (typically null) in the $attributes array.

Example: Product Model

Let's create a Product model that utilizes all the mentioned techniques on different fields:

use Illuminate\Database\Eloquent\CastsAttributes;

class Product extends Model
    protected $attributes = [
        'status' => 'active',
        'metadata' => null, // Initial value for custom cast

    protected $casts = [
        'metadata' => MetadataCast::class, // Custom cast for metadata

    protected static function boot()

        static::creating(function ($model) {
            $model->slug = Str::slug($model->name);

    public function getPriceAttribute($value)
        // Apply a discount or format the price based on other attributes
        return $value * 0.9; // Example: 10% discount

    public function getStatusAttribute($value)
        return $value ?: 'active';

class MetadataCast implements CastsAttributes
    public function get($model, $key, $value, $attributes)
        return json_decode($value) ?: ['default_key' => 'default_value'];

    public function set($model, $key, $value, $attributes)
        return json_encode($value);

// Migration example for database defaults
Schema::create('products', function (Blueprint $table) {
    $table->timestamps(); // created_at will be set by default

In this example, different attributes of a product are handled using different techniques, demonstrating the flexibility and power of Laravel's Eloquent.


Setting default values in Laravel Eloquent Models can be achieved in various ways, each with its own strengths and use cases. From the simplest $attributes array to more complex boot methods and custom casting, Laravel provides a rich set of tools for managing default values. The provided example illustrates how these can be combined in a cohesive manner to create a robust and flexible model.

I hope this has been helpful in understanding the different techniques available. If you have any questions or need further clarification on any of the methods discussed, please feel free to leave a comment below. Additionally, if you have discovered or utilized other ways to set default values in Laravel that were not covered in this post, we encourage you to share them with the community. Your insights and contributions can help others in their development journey.

Monday, August 07, 2023

Dynamically Resizing Cross-Domain IFrames

In the age of embedded content and third-party integrations, iframes have become an essential tool for web developers. They allow us to embed content from one site into another seamlessly. However, one common challenge is resizing the iframe to fit its content, especially when dealing with cross-domain iframes, and framed content that should change the size of the page over time.

Note that to use this technique, both the parent and the third-party child web site must have code to communicate with each other. All modern browsers enforce this.

Step 1: Embed the Iframe

<iframe id="myIframe" src="" width="420" height="1024" style="width:100%;border:0;overflow:hidden;" scrolling="no" allowfullscreen="allowfullscreen"></iframe>

Note that the scroll bar is hidden in this iframe to prevent it flashing when the internal content changes size.

Step 2: Set Up the Parent Window

    window.addEventListener('message', function(event) {
        if (event.origin !== '') return;
        var iframe = document.getElementById('myIframe'); = + 'px';
    }, false);

Step 3: Implement the Iframe Content

    window.addEventListener("DOMContentLoaded", function () {
        setInterval(function () {
            var height = document.body.scrollHeight;
            window.parent.postMessage({height: height}, document.referrer);
        }, 250);

Note that this script posts an update every 1/4 second to handle dynamic page size changes in a responsive manner at a reasonable rate.


Dynamically resizing cross-domain iframes is a common challenge that can be effectively addressed using the postMessage method. By combining this method with some simple JavaScript code, we can create a responsive and user-friendly experience, allowing the iframe to adjust its height based on its content.

This approach ensures a seamless integration of third-party content and enhances the overall usability of the website. It demonstrates the flexibility and power of modern web development techniques, providing a robust solution for one of the more nuanced challenges in front-end development.

Thursday, August 03, 2023

Dynamically Registering Service Classes in Laravel 10


In the process of migrating a proprietary PHP application to the Laravel 10 framework, I faced an interesting challenge. The application I was working on had 44 service classes. In Laravel, service classes are typically registered manually in the AppServiceProvider.php file. However, the thought of manually registering all these services seemed daunting and inefficient. Plus, it would be a hassle to update the AppServiceProvider.php every time a service is added, renamed, or removed. Therefore, I decided to find a way to register these service classes dynamically. This post outlines the solution I came up with.

Problem Statement

When migrating a large PHP application into Laravel, manually registering a large number of service classes is not only tedious but also prone to errors. Moreover, it's not scalable: every time we add, rename, or remove a service, we need to manually update the AppServiceProvider.php file. We need a solution that allows us to dynamically register all service classes in the application and automatically adjust when changes are made.


The solution I came up with involves using Laravel's File::allFiles() method to get all PHP files in the service classes directory and then dynamically register these classes in the AppServiceProvider.php file. The service classes are registered using Laravel's service container, which allows Laravel to automatically resolve these classes when they're needed in other parts of the application.

Here is a code snippet used to find all the classes in any package. I happen to have it in a class called ClassUtil:

 * This method is used to recursively retrieve all the classes within a package that have been configured in the Composer autoloader.
 * @param string $package The package name
 * @return string[] The classes
public function getPackageClasses(string $package): array
    /* Get all PHP files in the package directory */
    try {
        $basePath = base_path($package);
        $files = File::allFiles($basePath);
    } catch (Exception) {
        /* Catches the case where the default Laravel "App" package resides in the "app" folder and the server is case-sensitive. */
        $basePath = base_path(lcfirst($package));
        $files = File::allFiles($basePath);

    $rootPath = str_replace(str_replace('/', DIRECTORY_SEPARATOR, $package), '', $basePath);

    $classes = [];
    foreach ($files as $file) {
        /* Convert the file path to a namespaced class name */
        $class = str_replace(
            ['/', '.php'],
            ['\\', ''],
            Str::after($file->getRealPath(), $rootPath)

        /* Check if the class exists and is not abstract */
        if (class_exists($class) && !(new ReflectionClass($class))->isAbstract()) {
            $classes[] = $class;

    return $classes;

And this is how I use it in AppServiceProvider.php:

 * Register any application services.
 * @return void
public function register(): void
    foreach ((new ClassUtil())->getPackageClasses('App/Services') as $class) {
        $this->app->singleton($class, function () use ($class) {
            return new $class();


This technique has several benefits:

  • Simplicity: It saves us the trouble of manually registering each service class.
  • Scalability: It allows us to easily add, rename, or remove services without having to manually update the AppServiceProvider.php file.
  • Flexibility: It provides a flexible way of managing service classes, especially in large applications.


Dynamically registering service classes in Laravel is a handy trick that can save you a lot of time and effort, especially when dealing with large applications. I hope this post helps you in your Laravel development journey. If you have any questions or comments, feel free to leave them below!

Thursday, June 15, 2023

Creating and Nesting SimpleXMLElement Objects in PHP


When working with XML data in PHP, the SimpleXMLElement class provides a convenient way to create and manipulate XML structures. One common requirement is to create a SimpleXMLElement and add it as a child to another SimpleXMLElement. In this blog post, we'll explore the correct solution to achieve this.

Creating the Parent and Child Elements

/* Create the parent SimpleXMLElement */
$parent = new SimpleXMLElement('<parent></parent>');

/* Create the child SimpleXMLElement */
$child = new SimpleXMLElement('<child></child>');

Adding Content to the Child Element

$child->addChild('name', 'John');
$child->addChild('age', 25);

Importing and Nesting the Child Element

Now comes the crucial part: importing and nesting the child element within the parent element. We'll use the dom_import_simplexml() function to convert the SimpleXMLElement objects to DOMNode objects. Here's how it's done:

$domChild = dom_import_simplexml($child);
$domParent = dom_import_simplexml($parent);
$domChild = $domParent->ownerDocument->importNode($domChild, true);

In the above code, we import the child element into the parent element's document using the importNode() method. The second argument true indicates that we want to import the entire subtree of the child node.

Printing the Final XML Structure

To see the final XML structure, we can call the asXML() method on the parent element:

echo $parent->asXML();

This will output the complete XML structure, including the parent and nested child elements.

The xmlAdopt() Method

To simplify the process of adopting a child element into a parent element, we can use a helper method called xmlAdopt():

 * Adopt a SimpleXMLElement into another SimpleXMLElement.
 * @param SimpleXMLElement $parent the parent element
 * @param SimpleXMLElement $child  the child element to add to the parent
private function xmlAdopt(SimpleXMLElement $parent, SimpleXMLElement $child): void
    $domChild = dom_import_simplexml($child);
    $domParent = dom_import_simplexml($parent);
    $domChild = $domParent->ownerDocument->importNode($domChild, true);

Using the xmlAdopt() Method:

$this->xmlAdopt($parent, $child);


Creating and nesting SimpleXMLElement objects in PHP requires careful handling

Monday, May 14, 2018

MySQL AES Encryption in Ruby

I was asked to find a way to encrypt strings in Ruby that would be compatible with MySQL's AES_ENCRYPT and AES_DECRYPT functions. I found several solutions online, but none of them worked the way I expected. After cobbling together several examples, I finally came up with a solution that proved to be compatible with the MySQL version. This was written for use with Ruby 2.3.5. This module can be used as follows: