In this guide, I’ll walk you through the exact process I followed to successfully set up my environment on Windows. By the end, you’ll be able to:

• Run your React Native project on an Android emulator
• Build your app locally
• Avoid common JDK, SDK, and NDK issues
• Launch your app smoothly using npx react-native run-android

This setup is ideal for long-term development and future-proofing your workflow.

Why Proper Environment Setup Is Important

React Native development for Android requires multiple tools working together:

• Node.js
• React Native CLI
• Java Development Kit (JDK)
• Android Studio
• Android SDK
• Android Emulator

If even one component is misconfigured, you may face:

• CMake build errors
• Device detection issues
• Gradle failures
• Emulator launch problems

So let’s set everything up properly from scratch.

Step 1: Install Node.js (LTS Recommended)

React Native depends on Node.js.

Recommended Method (Windows)

Use Chocolatey package manager.

Open Command Prompt as Administrator and run:

choco install -y nodejs-lts microsoft-openjdk17

Important Notes

• Use an LTS version of Node.
• Node 22.11.0 or newer is recommended.
• If you want multiple Node versions, use nvm-windows.

Verify installation:

node -v
npm -v

Step 2: Install Java Development Kit (JDK 17)

React Native works most reliably with JDK 17.

Even if you have a newer JDK installed, I strongly recommend using JDK 17 to avoid Gradle compatibility issues.

Verify:

java -version

It should show something like:

openjdk version "17.x.x"

Step 3: Install Android Studio

Download and install Android Studio.

During installation, make sure these are selected:

• Android SDK
• Android SDK Platform
• Android Virtual Device
• Performance (Intel HAXM if not using Hyper-V)

After installation completes, proceed to SDK configuration.

Step 4: Install Required Android SDK Components

Open Android Studio → More Actions → SDK Manager.

In SDK Platforms Tab

1. Enable “Show Package Details”.
2. Expand Android 15 (VanillaIceCream).
3. Select:
   • Android SDK Platform 35
   • Intel x86 Atom_64 System Image or Google APIs System Image

In SDK Tools Tab

1. Enable “Show Package Details”.
2. Select:
   • Android SDK Build-Tools 36.0.0
   • Android SDK Command-line Tools (latest)
   • NDK (Side by side)
   • CMake

Click Apply and install.

Step 5: Set ANDROID_HOME Environment Variable

React Native requires Android environment variables.

How to Set It (Windows)

1. Open Control Panel
2. Go to User Accounts → Environment Variables
3. Click New

Create:

Variable Name: ANDROID_HOME
Variable Value: %LOCALAPPDATA%\Android\Sdk

Open a new Command Prompt and verify:

Get-ChildItem -Path Env:\

Make sure ANDROID_HOME appears.

Step 6: Add platform-tools to PATH

Still in Environment Variables:

1. Edit the Path variable
2. Add:

%LOCALAPPDATA%\Android\Sdk\platform-tools

Verify:

adb --version
adb devices

Step 7: Create and Launch an Android Virtual Device (AVD)

Open Android Studio → AVD Manager.

1. Click Create Virtual Device
2. Select a phone model
3. Choose API Level 35 (VanillaIceCream)
4. Finish setup

Click the green ▶ button to launch the emulator.

Step 8: Verify Device Connection

Once emulator is running:

adb devices

You should see:

emulator-5554 device

If not, restart ADB:

adb kill-server
adb start-server
adb devices

Step 9: Create and Run React Native Project

Create project:

npx react-native init MyApp

Navigate into project:

cd MyApp

Run Android app:

npx react-native run-android

If multiple devices are connected:

npx react-native run-android --device emulator-5554

Important Compatibility Notes (Very Important)

During my setup, I faced the following real issues:

1. Gradle Using Wrong Java Version

Fix: Force JDK 17 in android/gradle.properties

2. CMake Error: std::format Not Found

Cause: Using NDK 26
Fix: Install and use NDK 27.1.12297006

Add inside android {} in build.gradle:

ndkVersion "27.1.12297006"

Then clean:

cd android
gradlew clean

This resolved C++ build errors completely.

Final Working Configuration Summary

For a stable React Native Android setup on Windows:

• Node: LTS (22+ recommended)
• Java: JDK 17
• Android SDK Platform: 35
• Build Tools: 36.0.0
• NDK: 27.1.12297006
• Emulator: API 35
• Correct ANDROID_HOME + PATH

Conclusion

Setting up React Native Android development correctly takes time — but once done properly, everything runs smoothly.

By following this guide:

• Emulator launches correctly
• ADB detects devices
• Gradle builds without errors
• Native C++ compilation works
• App runs smoothly using run-android

If you’re setting this up for the first time, expect about an hour. After that, development becomes fast and seamless.

This guide will help you avoid common mistakes and future build headaches.

The post Complete Guide to Setting Up React Native Android Development Environment on Windows (Step-by-Step) appeared first on Artificial Intelligence.

• Opens the emulator but does not launch the app
• Fails with configureCMakeDebug error
• Shows std::format not found error
• Or says “No Android device connected”

Then this complete guide will help you fix everything step by step.

This guide is based on a real-world troubleshooting session on Windows with React Native 0.84.

Problem 1: Gradle Using Wrong Java Version (JDK 25 Instead of JDK 17)

Symptoms

Running:

gradlew.bat -version

Showed:

Launcher JVM: 25.0.2
Daemon JVM: jdk-25

Even though java -version showed JDK 17.

This caused:

Execution failed for task ':app:configureCMakeDebug[arm64-v8a]'
WARNING: A restricted method in java.lang.System has been called

Why This Happens

Gradle was using JDK 25 internally, but React Native Android builds are stable with JDK 17.

Gradle launcher and daemon must both use Java 17.

Solution: Force Gradle to Use JDK 17

Step 1: Locate Your JDK 17 Folder

Example:

C:\Program Files\Microsoft\jdk-17.0.18.8-hotspot

Step 2: Add This to android/gradle.properties

Open:

android/gradle.properties

Add:

org.gradle.java.home=C:\\Program Files\\Microsoft\\jdk-17.0.18.8-hotspot

Use double backslashes.

Step 3: Stop Gradle and Clean

cd android
gradlew.bat --stop
rmdir /s /q .gradle
rmdir /s /q .cxx
rmdir /s /q app\.cxx
gradlew.bat clean

Step 4: Verify

gradlew.bat -version

Now both should show:

Launcher JVM: 17.x
Daemon JVM: 17.x

If not, temporarily force in CMD:

set "JAVA_HOME=C:\Program Files\Microsoft\jdk-17.0.18.8-hotspot"
set "PATH=%JAVA_HOME%\bin;%PATH%"

Problem 2: CMake Error – std::format Not Found (NDK Issue)

After fixing Java, build failed with:

error: no member named 'format' in namespace 'std'
return std::format("{}%", dimension.value);

This came from:

react-native-safe-area-context

And NDK path showed:

ndk\26.1.10909125

Why This Happens

React Native 0.84 uses C++20 features like std::format.

NDK 26 does not properly support this setup.

You must use NDK 27.1+.

Solution: Install and Force NDK 27.1

Step 1: Install NDK 27.1

In Android Studio:

• Settings
• Android SDK
• SDK Tools
• Enable “NDK (Side by side)”
• Select 27.1.12297006
• Apply

Step 2: Force Project to Use NDK 27.1

Open:

android/build.gradle

Inside android {} add:

ndkVersion "27.1.12297006"

Step 3: Clean Native Build

cd android
gradlew.bat --stop
rmdir /s /q .cxx
rmdir /s /q app\.cxx
rmdir /s /q .gradle
gradlew.bat clean

Step 4: Run Again

cd ..
npx react-native run-android

Now build succeeds.

Problem 3: Emulator Opens but CLI Says “No Android Device Connected”

Even though:

adb devices

Showed:

emulator-5554 device

Sometimes it showed blank.

Why This Happens

• ADB server mismatch
• Multiple adb.exe in PATH
• Emulator not cold booted

Fix Emulator Detection

Step 1: Restart Emulator

Cold boot from Android Studio Device Manager.

Step 2: Reset ADB

adb kill-server
taskkill /F /IM adb.exe
adb start-server
adb devices

Now emulator should show:

emulator-5554 device

Step 3: Run with Correct Flag

New React Native versions use:

npx react-native run-android --device emulator-5554

(Not --deviceId)

Step 4: Ensure Correct ADB in PATH

where adb

Make sure this path is first:

C:\Users\YourUser\AppData\Local\Android\Sdk\platform-tools\adb.exe

If not:

set "ANDROID_SDK_ROOT=%LOCALAPPDATA%\Android\Sdk"
set "PATH=%ANDROID_SDK_ROOT%\platform-tools;%PATH%"

Final Working Configuration Summary

For React Native 0.84 (Windows):

• Java: JDK 17
• Gradle JVM: 17
• NDK: 27.1.12297006
• CMake: Installed via SDK Tools
• Use: --device instead of --deviceId

Final Command That Worked

npx react-native run-android --device emulator-5554

Everything built smoothly.

Key Lessons Learned

1. Gradle launcher and daemon must both use Java 17.
2. NDK 26 is not compatible with React Native 0.84 C++20 requirements.
3. Always force ndkVersion in build.gradle.
4. Always clean .cxx when changing NDK.
5. If emulator shows but CLI doesn’t detect, reset ADB.

The post How to Fix React Native Android Build Errors (JDK 25, NDK 26, CMake & Emulator Issues) appeared first on Artificial Intelligence.

/opt/lampp/htdocs/hyderabadorbit.com/public/blog

After installation, your blog will be accessible at:

https://yourdomain.com/blog

Step 1 — Navigate to the Public Directory

Open your terminal and move to your project’s public folder:

cd /opt/lampp/htdocs/hyderabadorbit.com/public

Step 2 — Download the Latest WordPress Package

Download the latest WordPress version directly from the official source:

wget https://wordpress.org/latest.zip

Extract the downloaded file:

unzip latest.zip

Step 3 — Rename the WordPress Folder to blog

Rename the extracted folder so that WordPress runs under the /blog URL:

mv wordpress blog

Now your WordPress files will be located at:

public/blog

Step 4 — Set Proper Permissions

Since you are using XAMPP, set ownership and permissions for the web server:

sudo chown -R daemon:daemon blog
sudo chmod -R 755 blog

This ensures Apache can access and manage the files correctly.

Step 5 — Create a Database for WordPress

Open MySQL using XAMPP:

/opt/lampp/bin/mysql -u root -p

Create a new database and user:

CREATE DATABASE blog_db;
CREATE USER 'blog_user'@'localhost' IDENTIFIED BY 'StrongPassword';
GRANT ALL PRIVILEGES ON blog_db.* TO 'blog_user'@'localhost';
FLUSH PRIVILEGES;
EXIT;

Step 6 — Restart XAMPP Services

Restart XAMPP to apply changes:

sudo /opt/lampp/lampp restart

Step 7 — Complete WordPress Installation via Browser

Open your browser and go to:

https://yourdomain.com/blog

Enter the following database details:

• Database Name: blog_db
• Username: blog_user
• Password: StrongPassword
• Database Host: localhost

Click Install WordPress, and follow the on-screen instructions.

The post How to Install WordPress Inside a blog Folder on Linux (XAMPP Public Directory) appeared first on Artificial Intelligence.

This tutorial is ideal for developers who prefer using the htdocs folder structure instead of the traditional /var/www directory.

Prerequisites

Before starting, ensure you have:

• A Linux server with SSH access
• GitHub repository of your Laravel project
• Apache/XAMPP or LAMP stack installed
• PHP and Composer installed
• Database access (MySQL/MariaDB)
• Basic Linux command knowledge

Step 1: Connect to Your Linux Server

Login via SSH from your local machine:

ssh username@server_ip

Example:

ssh myeventadmin@your_server_ip

Step 2: Update Your Server

Always update packages before setup:

sudo apt update && sudo apt upgrade -y

Step 3: Install Required Packages

Install Apache, PHP, Git, Composer dependencies, and tools:

sudo apt install apache2 mysql-server unzip git curl -y

Install PHP extensions required by Laravel:

sudo apt install php php-cli php-mysql php-zip php-gd php-mbstring php-curl php-xml libapache2-mod-php -y

Check PHP version:

php -v

Step 4: Install Composer

cd ~
curl -sS https://getcomposer.org/installer | php
sudo mv composer.phar /usr/local/bin/composer

Verify installation:

composer -V

Step 5: Move to HTDOCS Directory

Depending on your server setup, the htdocs directory may be located at:

/opt/lampp/htdocs

or

/var/www/html

Navigate to htdocs:

cd /opt/lampp/htdocs

Step 6: Clone Laravel Project from GitHub

sudo git clone https://github.com/username/project.git

Move into project folder:

cd project

Step 7: Set Folder Permissions

sudo chown -R daemon:daemon /opt/lampp/htdocs/project
sudo chmod -R 775 storage
sudo chmod -R 775 bootstrap/cache

(If using Apache instead of XAMPP, replace daemon with www-data)

Step 8: Configure Environment File

Create the environment file:

cp .env.example .env
nano .env

Update important settings:

APP_NAME=Laravel
APP_ENV=production
APP_DEBUG=false
APP_URL=http://yourdomain.com

Add your database credentials as well.

Step 9: Install Laravel Dependencies

composer install

Step 10: Generate Application Key

php artisan key:generate

Step 11: Create Database and Run Migration

Login to MySQL:

sudo mysql

Create database:

CREATE DATABASE laravel_db;
EXIT;

Run migrations:

php artisan migrate

Step 12: Configure Apache to Use Public Folder

Edit Apache configuration:

sudo nano /opt/lampp/etc/extra/httpd-vhosts.conf

Add:

<VirtualHost *:80>
    ServerName yourdomain.com
    DocumentRoot "/opt/lampp/htdocs/project/public"

    <Directory "/opt/lampp/htdocs/project">
        AllowOverride All
        Require all granted
    </Directory>
</VirtualHost>

Restart Apache/XAMPP:

sudo /opt/lampp/lampp restart

Step 13: Test Laravel Application

Open browser:

http://your_server_ip/project/public

or

http://yourdomain.com

If everything is configured properly, your Laravel website will be live.

Important Production Tips

• Always set APP_DEBUG=false
• Never make .env publicly accessible
• Ensure correct folder permissions
• Use SSL (HTTPS) for live websites
• Regularly pull updates from GitHub

Conclusion

Deploying a Laravel project using the htdocs directory and GitHub cloning is a practical and efficient workflow for Linux servers running XAMPP or Apache environments. By following this step-by-step process — cloning the repository, configuring environment variables, setting permissions, and configuring Apache — you can successfully deploy your Laravel application in a production-ready environment.

This method is especially useful for developers who prefer traditional htdocs-based hosting environments while maintaining version control through GitHub.

The post How to Deploy a Laravel Project on a Linux Server Using HTDOCS and GitHub – Complete Step-by-Step Guide appeared first on Artificial Intelligence.

If you are using XAMPP PHP on a Linux server and encounter errors like:

• GMP NOT OK
• Unable to load dynamic library 'gmp'
• Call to undefined function gmp_init()

then this usually means the GMP extension is not installed, not just disabled.

Many developers assume that uncommenting a line in php.ini is enough—but in XAMPP, that is often not true.

This guide explains why GMP is missing, and shows the correct, production-safe way to compile, install, and enable the GMP extension for XAMPP PHP.

What Is the GMP Extension in PHP?

GMP (GNU Multiple Precision) is a PHP extension used for handling very large integers and high-precision arithmetic.

Common use cases include:

• Cryptography and security libraries
• JWT / OAuth / authentication systems
• Blockchain and hashing operations
• Keycloak integrations
• Large integer calculations

Example:

gmp_init("12345678901234567890");

The Real Problem (Why GMP Doesn’t Work in XAMPP)

When you run:

php -m | grep gmp

and get no output, or:

GMP NOT OK

Even after adding this to php.ini:

extension=gmp

❌ Why this happens

XAMPP PHP is a precompiled binary and often does not include gmp.so at all.

So:

• php.ini only loads extensions
• It does not create them
• If gmp.so does not exist, PHP cannot load it

Environment Used in This Guide

• OS: Linux (Ubuntu based)
• PHP: XAMPP PHP 8.2.12
• PHP binary:

/opt/lampp/bin/php

• php.ini location:

/opt/lampp/etc/php.ini

Step 1: Confirm You Are Using XAMPP PHP

which php
php -v

Expected output:

/opt/lampp/bin/php
PHP 8.2.12

Step 2: Check Whether GMP Is Loaded

/opt/lampp/bin/php -m | grep -i gmp

If nothing appears, GMP is not installed.

Step 3: Check the PHP Extension Directory

/opt/lampp/bin/php -i | grep extension_dir

Example output:

/opt/lampp/lib/php/extensions/no-debug-non-zts-20220829

Check if gmp.so exists:

ls -l /opt/lampp/lib/php/extensions/no-debug-non-zts-20220829 | grep gmp

If nothing is returned, GMP is missing.

Step 4: Install Required Build Dependencies

sudo apt update
sudo apt install -y build-essential autoconf automake libtool \
pkg-config libgmp-dev re2c bison wget

Step 5: Download PHP Source (Same Version as XAMPP)

⚠️ The PHP source version must exactly match your XAMPP PHP version.

cd /tmp
wget https://www.php.net/distributions/php-8.2.12.tar.gz
tar -xzf php-8.2.12.tar.gz

Verify GMP source exists:

ls /tmp/php-8.2.12/ext/gmp

You should see files like gmp.c, config.m4, etc.

Step 6: Compile GMP Extension for XAMPP PHP

cd /tmp/php-8.2.12/ext/gmp

/opt/lampp/bin/phpize
./configure --with-php-config=/opt/lampp/bin/php-config
make -j$(nproc)
sudo make install

This step creates the gmp.so file.

Step 7: Verify gmp.so Was Installed

EXT_DIR=$(/opt/lampp/bin/php -r 'echo ini_get("extension_dir");')
ls -l "$EXT_DIR" | grep gmp

Expected output:

gmp.so

Step 8: Enable GMP in php.ini (Linux)

Open the file:

sudo vi /opt/lampp/etc/php.ini

Important Notes

• Ignore lines like:

;extension=php_gmp.dll

These are Windows-only.

• Do not uncomment .dll lines on Linux.

Add this line:

extension=gmp.so

Save and exit:

Esc
:wq

Step 9: Restart XAMPP

sudo /opt/lampp/lampp restart

Step 10: Final Verification

/opt/lampp/bin/php -m | grep -i gmp

Expected output:

gmp

Final confirmation:

/opt/lampp/bin/php -r 'echo function_exists("gmp_init") ? "GMP OK\n" : "GMP NOT OK\n";'

Expected:

GMP OK

🎉 GMP is now fully installed and enabled in XAMPP PHP

Common Mistakes to Avoid

• Only uncommenting extension=gmp
• Using .dll extensions on Linux
• Installing php-gmp via apt for XAMPP
• PHP version mismatch during compilation
• Forgetting to restart XAMPP

Conclusion

Enabling GMP in XAMPP PHP on Linux requires more than editing php.ini.
When the extension is missing, compiling it for your exact PHP version is the correct and safe solution.

This method:

• Does not reinstall PHP
• Does not reinstall XAMPP
• Works reliably in production environments

The post How to Install and Enable GMP Extension in XAMPP PHP on Linux (Step-by-Step Guide) appeared first on Artificial Intelligence.

Laravel is a secure and powerful PHP framework, but many developers face confusion when they need to change the admin password, especially if the password is forgotten or the admin cannot log in.

In this blog post, you will learn multiple safe and practical ways to change the admin password in a Laravel project, applicable to both XAMPP (local server) and cPanel (live server) environments.

Where Is the Admin Password Stored in Laravel?

Laravel never stores passwords in plain text.
By default:

• Passwords are stored as bcrypt hashes
• Common tables used for admin accounts:
  • users
  • admins
  • admin_users

In many projects, the admin user exists in the users table with a column like:

• role = admin
• is_admin = 1

Method 1: Change Admin Password Using phpMyAdmin (Recommended)

This is the most reliable and commonly used method, especially when:

• You forgot the admin password
• Admin login is not working
• You are working on a live server (cPanel)

Step 1: Open phpMyAdmin

• XAMPP: http://localhost/phpmyadmin
• cPanel: Login to cPanel → Open phpMyAdmin

Step 2: Select Laravel Database

• Choose your Laravel project database
• Open the users or admins table

Step 3: Locate the Admin Account

• Find the admin record using email, username, or role

Step 4: Generate a New Password Hash

Open terminal or command prompt in your Laravel project directory:

php artisan tinker

Then run:

bcrypt('NewPassword@123')

This will generate an encrypted string starting with $2y$....
Copy this hashed value.

Step 5: Update Password in Database

• Click Edit on the admin record
• Paste the hashed value into the password column
• Save changes

✅ The new admin password is now: NewPassword@123

Method 2: Change Admin Password Using Laravel Tinker

This method is useful when:

• You have project access
• You prefer not to manually edit the database

Open Tinker

php artisan tinker

If Admin Is in the users Table

use App\Models\User;

$user = User::where('email', 'admin@example.com')->first();
$user->password = bcrypt('NewPassword@123');
$user->save();

If Admin Uses a Separate Model

use App\Models\Admin;

$admin = Admin::where('email', 'admin@example.com')->first();
$admin->password = bcrypt('NewPassword@123');
$admin->save();

✅ Password updated successfully.

Method 3: Reset Admin Password Using a Temporary Route

This method should be used only in emergencies.

Step 1: Add Temporary Route

Edit routes/web.php:

use App\Models\User;
use Illuminate\Support\Facades\Hash;

Route::get('/reset-admin-password', function () {
    $user = User::where('email', 'admin@example.com')->first();
    $user->password = Hash::make('NewPassword@123');
    $user->save();
    return 'Admin password changed successfully';
});

Step 2: Open the URL Once

yourdomain.com/reset-admin-password

Step 3: Remove the Route Immediately

⚠️ This step is critical for security reasons.

Common Mistakes to Avoid

• Saving passwords in plain text
• Using md5() or sha1() for hashing
• Forgetting to delete reset routes
• Trying to change passwords from the .env file

Laravel passwords must always be stored using bcrypt or Hash::make().

Which Method Should You Use?

Conclusion

Changing the admin password in a Laravel project is simple if you follow the correct and secure approach.
For beginners and production servers, phpMyAdmin with bcrypt hashing is the safest method.

Always follow Laravel security best practices to keep your application protected.

The post How to Change Admin Password in a Laravel Project appeared first on Artificial Intelligence.

Modern websites often need to display content from multiple platforms on a single homepage. A common example is showing WordPress blog posts or community discussions directly on a Laravel-based site without breaking layout or performance.

In this article, we’ll explain the best and most stable approach to fetch and display Flarum discussions on a Laravel website, using the same concept as WordPress blog fetch, but implemented correctly for production use.

This guide covers:

• Why backend proxy is the best approach
• How Flarum API works
• Step-by-step Laravel + JavaScript integration
• Clean UI rendering with fail-safe handling

Why Not Fetch Flarum Directly from Frontend?

Flarum provides a JSON:API endpoint, so technically you can fetch discussions directly using JavaScript. However, this approach causes multiple problems in real-world projects:

• ❌ CORS issues (very common)
• ❌ API rate limits exposed to users
• ❌ Authentication tokens exposed in frontend
• ❌ No caching → slow homepage
• ❌ API failure breaks UI

Because of this, direct frontend fetch is not recommended for production.

Best Practice: Laravel Backend Proxy (Recommended)

The best and safest approach is:

Laravel Backend → Fetch Flarum API → Convert to simple JSON → Frontend JS renders UI

Benefits:

• ✅ No CORS problems
• ✅ API tokens stay secure
• ✅ Easy caching (faster homepage)
• ✅ Clean error handling
• ✅ Same pattern as WordPress blog fetch

Step 1: Understand the Flarum API Endpoint

Flarum exposes discussions using JSON:API:

GET https://your-flarum-site.com/api/discussions

Common parameters:

• page[limit]=9 → number of discussions
• sort=-createdAt → latest discussions first
• include=user,tags → include author and tags

Example:

/api/discussions?page[limit]=9&sort=-createdAt&include=user,tags

The response is nested and complex, so we will simplify it in Laravel.

Step 2: Configure Flarum in Laravel

Add Flarum configuration in config/services.php:

'flarum' => [
    'base_url' => env('FLARUM_BASE_URL'),
    'api_token' => env('FLARUM_API_TOKEN'), // optional
],

Add values in .env:

FLARUM_BASE_URL=https://community.example.com
FLARUM_API_TOKEN=

If discussions are public, API token is not required.

Step 3: Create a Laravel Proxy Route

Create a route that your frontend will call instead of calling Flarum directly.

Route::get('/flarum/discussions', [FlarumController::class, 'discussions'])
    ->name('flarum.discussions');

Step 4: Fetch and Normalize Flarum Data (Controller)

Create a controller that:

• Calls Flarum API
• Extracts only required fields
• Returns clean JSON
• Caches the response

class FlarumController extends Controller
{
    public function discussions(Request $request)
    {
        $limit = min((int) $request->limit ?: 9, 12);

        return Cache::remember("flarum_discussions_$limit", now()->addMinutes(5), function () use ($limit) {

            $base = rtrim(config('services.flarum.base_url'), '/');

            $response = Http::acceptJson()
                ->get($base . '/api/discussions', [
                    'page' => ['limit' => $limit],
                    'sort' => '-createdAt',
                    'include' => 'user,tags',
                ]);

            if (!$response->ok()) {
                return ['success' => false, 'items' => []];
            }

            $json = $response->json();
            $included = collect($json['included'] ?? []);

            $users = $included->where('type', 'users')->keyBy('id');
            $tags  = $included->where('type', 'tags')->keyBy('id');

            $items = [];

            foreach ($json['data'] as $d) {
                $authorId = data_get($d, 'relationships.user.data.id');
                $author   = $users[$authorId]['attributes'] ?? [];

                $items[] = [
                    'title' => $d['attributes']['title'],
                    'link'  => $base.'/d/'.$d['attributes']['slug'],
                    'created_at' => $d['attributes']['createdAt'],
                    'reply_count' => $d['attributes']['replyCount'],
                    'author' => $author['displayName'] ?? $author['username'],
                ];
            }

            return ['success' => true, 'items' => $items];
        });
    }
}

Step 5: Create Blade Section for Discussions

Add a section similar to WordPress blog cards:

<div id="flarum-discussions" style="display:none;">
    <div id="flarum-loading">Loading discussions...</div>
    <div id="flarum-grid"></div>
</div>

Step 6: Fetch Discussions Using JavaScript

Now fetch discussions from your Laravel route, not from Flarum directly.

<script>
document.addEventListener("DOMContentLoaded", async () => {

  const section = document.getElementById("flarum-discussions");
  const loading = document.getElementById("flarum-loading");
  const grid    = document.getElementById("flarum-grid");

  section.style.display = "block";

  try {
    const res = await fetch("/flarum/discussions?limit=9");
    const data = await res.json();

    if (!data.success || !data.items.length) throw "No data";

    let html = "";
    data.items.forEach(d => {
      html += `
        <div class="discussion-card">
          <a href="${d.link}" target="_blank">
            <h5>${d.title}</h5>
            <p>By ${d.author} • ${d.reply_count} replies</p>
          </a>
        </div>
      `;
    });

    grid.innerHTML = html;
    loading.style.display = "none";

  } catch (e) {
    section.style.display = "none";
  }
});
</script>

Step 7: Fail-Safe Handling (Very Important)

If:

• Flarum is down
• API fails
• Network error occurs

👉 The entire section hides automatically, so your homepage never breaks.

Final Architecture Overview

Frontend JS
    ↓
Laravel Proxy Route
    ↓
Flarum JSON API
    ↓
Laravel Normalization + Cache
    ↓
Clean JSON to Frontend

Conclusion

If you want to show Flarum discussions on a Laravel website using the same concept as WordPress blog fetch, the Laravel backend proxy approach is the most professional and production-ready solution.

It ensures:

• Better performance
• Strong security
• Clean UI rendering
• No CORS headaches
• Scalable architecture

This pattern works perfectly for:

• Communities
• SaaS dashboards
• Blogs + forums combo
• Multi-platform content sites

The post How to Show Flarum Discussions on a Laravel Website appeared first on Artificial Intelligence.

Sending emails is a critical feature for most Laravel applications. Whether it’s account verification, password reset, or notifications, email delivery must work reliably.

However, many developers face the following error when configuring AWS SES with Laravel:

SMTP Error 535: Authentication Credentials Invalid

This article explains why this error occurs, what it actually means, and how to fix it permanently in Laravel.

Understanding the Error

The full error usually looks like this:

Failed to authenticate on SMTP server using authenticators LOGIN, PLAIN.
Expected response code 235 but got 535.
Authentication Credentials Invalid.

What does this mean?

• Laravel successfully connects to the SMTP server
• The SMTP server rejects the username or password
• Authentication fails before sending any email

This is not a Laravel bug.
This is almost always a configuration issue with AWS SES SMTP credentials.

Why This Error Happens (Most Common Reasons)

1. Using IAM Access Keys Instead of SMTP Credentials

AWS SES does not accept normal IAM Access Key & Secret Key directly for SMTP authentication.

Many developers mistakenly copy:

• AWS_ACCESS_KEY_ID
• AWS_SECRET_ACCESS_KEY

and paste them into:

MAIL_USERNAME
MAIL_PASSWORD

❌ This will always fail with a 535 error.

2. Wrong AWS SES Region

AWS SES is region-specific.

If your SES is created in:

• ap-south-1 → you must use
  email-smtp.ap-south-1.amazonaws.com

Using the wrong region host causes authentication failure.

3. Special Characters in SMTP Password

SES SMTP passwords often contain:

• +
• /
• =

If the password is not wrapped in quotes, Laravel may parse it incorrectly.

4. Laravel Config Cache Still Using Old Values

Laravel caches configuration aggressively.
Even after fixing .env, Laravel may still use old credentials.

Correct Way to Configure AWS SES SMTP in Laravel

Step 1: Generate AWS SES SMTP Credentials

Do not use IAM access keys.

1. Go to AWS Console
2. Open Simple Email Service (SES)
3. Navigate to SMTP Settings
4. Click Create SMTP Credentials
5. AWS will generate:
   • SMTP Username
   • SMTP Password

Save them securely.

Step 2: Update Laravel .env File

MAIL_MAILER=smtp
MAIL_HOST=email-smtp.ap-south-1.amazonaws.com
MAIL_PORT=587
MAIL_USERNAME=YOUR_SES_SMTP_USERNAME
MAIL_PASSWORD="YOUR_SES_SMTP_PASSWORD"
MAIL_ENCRYPTION=tls
MAIL_FROM_ADDRESS=contact@yourdomain.com
MAIL_FROM_NAME="Your Website Name"

Important Notes

• Always wrap MAIL_PASSWORD in double quotes
• Ensure MAIL_HOST matches your SES region
• No extra spaces before or after values

Step 3: Clear Laravel Cache (Very Important)

Run these commands on your server:

php artisan config:clear
php artisan cache:clear
php artisan config:cache
php artisan route:clear

If you are using queues:

php artisan queue:restart

Verifying Email or Domain in AWS SES

AWS SES requires verification.

You must verify either:

• The sender email address
  OR
• The entire domain

If not verified:

• Emails will fail later with different errors (not 535)
• In sandbox mode, you can send emails only to verified addresses

Common Mistakes to Avoid

• Using IAM keys instead of SMTP credentials
• Forgetting to clear Laravel config cache
• Using wrong SES region hostname
• Leaving APP_DEBUG=true in production
• Exposing SMTP credentials in public error pages

Production Security Best Practice

Always disable debug mode in production:

APP_ENV=production
APP_DEBUG=false

This prevents:

• Credential leaks
• Stack trace exposure
• Security risks

Final Checklist

Before testing again, confirm:

• SMTP credentials are generated from AWS SES
• Correct region SMTP host is used
• .env password is quoted
• Laravel cache is cleared
• Sender email/domain is verified in SES

Conclusion

The SMTP 535 Authentication Error in Laravel is not a framework issue.
It’s a credential mismatch caused by incorrect AWS SES configuration.

Once you:

• Use proper SES SMTP credentials
• Match the correct region
• Clear Laravel cache

the issue is resolved permanently.

The post Fixing SMTP 535 Authentication Error in Laravel with AWS SES (Step-by-Step Guide) appeared first on Artificial Intelligence.

Google Sign-In is one of the most trusted and widely used authentication methods today. Whether you are building a mobile app, web application, or backend system, integrating Google Login improves user experience, security, and trust.

In this guide, you’ll learn how to configure Google Cloud Console step by step to enable “Sign in with Google” (OAuth 2.0) correctly, without common mistakes.

What Is Google Sign-In (OAuth 2.0)?

Google Sign-In uses OAuth 2.0, a secure authorization framework that allows users to authenticate using their Google account without sharing passwords.

With Google OAuth:

• Users log in faster
• Developers avoid handling passwords
• Security and trust are handled by Google

Prerequisites Before You Start

Before setting up Google Console, make sure you have:

• A Google account
• Your app details (package name / domain / bundle ID)
• Backend callback URL (if applicable)
• Android SHA-1 keys (for mobile apps)

Step 1: Create or Select a Google Cloud Project

1. Visit Google Cloud Console
2. Click Select a project (top bar)
3. Choose New Project
4. Enter a project name (example: MyApp Google Login)
5. Click Create
6. Ensure the project is selected

Step 2: Configure OAuth Consent Screen (Mandatory)

The OAuth consent screen defines how your app appears to users during login.

1. Go to APIs & Services → OAuth consent screen
2. Select User Type
   • External → Public apps
   • Internal → Google Workspace only
3. Fill required details:
   • App name
   • User support email
   • Developer contact email
4. App domain (optional but recommended)
5. Add scopes:
   • openid
   • email
   • profile
6. Add Test users if app is in testing
7. Save and continue

Step 3: Enable Required APIs (Optional but Recommended)

1. Navigate to APIs & Services → Library
2. Search and enable:
   • Google Identity Services
   • People API (only if profile data is needed)
3. Click Enable

Step 4: Create OAuth Client ID (Core Configuration)

Go to APIs & Services → Credentials → Create Credentials → OAuth Client ID

A) Android App Configuration

1. Choose Application Type: Android
2. Enter:
   • App name
   • Package name (must match exactly)
   • SHA-1 fingerprint
3. Click Create

How to Generate SHA-1

• Debug SHA-1:
  • Android Studio → Gradle → signingReport
• Production SHA-1:
  • Google Play Console → App Integrity → App signing key

⚠️ Both debug and release SHA-1 must be added.

B) Web Application Configuration

1. Choose Application Type: Web Application
2. Add:
   • Authorized JavaScript origins
     Example: https://yourdomain.com
   • Authorized redirect URIs
     Example: https://yourdomain.com/auth/google/callback
3. Click Create
4. Copy:
   • Client ID
   • Client Secret

C) iOS Application Configuration

1. Choose Application Type: iOS
2. Enter:
   • Bundle ID
3. Create the credential

Step 5: Configure Redirect URIs Correctly

Redirect URIs must match exactly, including:

• HTTPS
• Trailing slashes
• Subdomains

Incorrect redirect URI causes:

• redirect_uri_mismatch error

Step 6: Publish OAuth Consent Screen

To allow public users:

1. Go to OAuth consent screen
2. Change status from Testing to In production
3. Basic scopes (email, profile) usually do not require verification

Step 7: Integrate Credentials into Your Application

Depending on your setup:

• Android / Flutter → Package name + SHA-1
• Web / Backend → Client ID & Secret
• Firebase Auth → Add SHA-1 + download google-services.json

Step 8: Common Issues & Fixes Checklist

✔ OAuth consent screen saved
✔ Correct Google Cloud project selected
✔ Correct package name / domain
✔ Debug & release SHA-1 added
✔ Test users added (if testing)
✔ Redirect URI exactly matches
✔ App published for production use

Best Practices for Google Sign-In

• Use minimal scopes
• Never expose Client Secret in frontend code
• Verify ID tokens on backend
• Keep OAuth credentials environment-specific
• Regularly audit credentials

Conclusion

Setting up Google Sign-In through Google Cloud Console is straightforward when done correctly. Most failures happen due to SHA-1 mismatch, incorrect redirect URIs, or missing consent screen configuration.

Follow this guide step by step, and your Google Login integration will work smoothly across Android, iOS, Web, and backend systems.

The post Step-by-Step Guide to Set Up Google Console API for “Sign in with Google” appeared first on Artificial Intelligence.

Running a Laravel application is common for dynamic web platforms, dashboards, and APIs. However, many businesses and developers also want to run a simple HTML website on the same server—often for landing pages, marketing content, or static informational pages.

The good news is that Laravel and a pure HTML website can run together smoothly on the same domain or server, if structured correctly.

In this blog, we’ll explain why this setup is useful, the best ways to implement it, and step-by-step methods you can follow safely in production.

Why Run an HTML Site Alongside Laravel?

There are several practical reasons developers choose this approach:

• Marketing or SEO pages are easier to manage in HTML
• Faster loading for static content
• Reduced server overhead for simple pages
• Clean separation between application logic and content
• Ability to update the website without touching Laravel code

This setup is especially useful when Laravel is already running, and you want to add a lightweight website without rebuilding everything inside Blade templates.

Understanding Laravel’s Public Folder (Very Important)

Laravel serves all public web traffic from the public directory.
This means:

• Any HTML, CSS, JS, or image file inside public can be accessed directly
• Laravel routes only handle requests not matching a physical file

This behavior allows us to safely place a static HTML site alongside Laravel.

Method 1: Run HTML Website Inside Laravel’s Public Folder (Recommended)

This is the simplest and safest method when Laravel is already live.

Folder Structure Example

laravel-project/
├── app/
├── routes/
├── resources/
├── public/
│   ├── index.php        (Laravel entry point)
│   ├── assets/
│   └── html-site/
│       ├── index.html
│       ├── about.html
│       ├── css/
│       ├── js/
│       └── images/

How It Works

• Laravel continues running normally
• Static HTML files are served directly
• No route conflict with Laravel
• No performance impact

Access URLs

https://yourdomain.com/html-site/
https://yourdomain.com/html-site/about.html

Important Notes

• Do not create Laravel routes for this folder
• Laravel automatically skips routing if a file exists
• Keep HTML assets fully static (no PHP files)

Method 2: HTML as Main Site, Laravel in a Subfolder

Use this method when:

• HTML website is the main homepage
• Laravel is used as an application or admin panel

Folder Structure

public_html/
├── index.html          (Main website)
├── css/
├── js/
├── images/
└── app/
    └── laravel/
        └── public/
            └── index.php

Access URLs

https://yourdomain.com/        → HTML site
https://yourdomain.com/app/    → Laravel app

When to Use This

• Marketing website is primary
• Laravel is secondary (dashboard, CRM, portal)
• Shared hosting or cPanel setup

Method 3: HTML on Main Domain, Laravel on Subdomain (Best for Production)

This is the most professional and scalable approach.

Example Setup

Benefits

• No routing conflicts
• Better SEO separation
• Easier scaling and maintenance
• Clean architecture

Recommended For

• Growing platforms
• SaaS products
• Business websites with dashboards
• Long-term projects

Common Mistakes to Avoid

1. Mixing Laravel Routes with HTML Files

Never define Laravel routes for static HTML folders.

2. Wrong Asset Paths

Use absolute paths in HTML files:

<link rel="stylesheet" href="/html-site/css/style.css">

3. Exposing Sensitive Files

Do not place:

• .env
• PHP scripts
• configuration files
  inside the HTML folder.

Security Best Practices

• Keep HTML folders static only
• Laravel .htaccess should remain untouched
• Do not allow uploads inside HTML directories
• Use correct file permissions

Which Method Should You Choose?

👉 If Laravel is already live, Method 1 is the fastest and safest solution.

Final Thoughts

Running an HTML website alongside a Laravel project is not only possible but also a best practice in many real-world scenarios. The key is understanding how Laravel serves files and keeping a clean folder structure.

Whether you’re adding landing pages, marketing content, or a separate static site, the right setup ensures:

• Better performance
• Cleaner codebase
• Easier maintenance
• No routing conflicts

Choose the method that fits your project size and future plans—and keep Laravel and HTML working together smoothly.

The post How to Run an HTML Website Alongside a Laravel Project on the Same Server appeared first on Artificial Intelligence.