In this blog post, we will explore a PHP script that utilizes the Google Custom Search API to search for images based on user-defined keywords. We’ll also cover how to create a WordPress post from the results. This application demonstrates how to integrate Google’s powerful search capabilities into your own applications, providing an easy way to retrieve and display images related to specific queries.

Code Breakdown

1. Setting Up the Environment

The code begins with defining two main functions: searchImages and createWordPressPost. The searchImages function handles image searches via Google’s Custom Search API, while the createWordPressPost function is responsible for publishing the search results on a WordPress site.

API Key and Custom Search Engine ID

To use the Google Custom Search API, you must have an API key and a Custom Search Engine (CSE) ID. These credentials are required to authenticate your requests:

$apiKey = 'YOUR_GOOGLE_API_KEY';
$searchEngineId = 'YOUR_CSE_ID';

2. The searchImages Function

The searchImages function takes a search query as input and constructs a URL for the API request. It then performs a cURL request to fetch image results:

function searchImages($query) {
    // Create the URL for the request
    $url = "https://www.googleapis.com/customsearch/v1?q=" . urlencode($query) . "&cx=$searchEngineId&key=$apiKey&searchType=image";

    // Initialize cURL session
    $curl = curl_init();

    // Set cURL options
    curl_setopt($curl, CURLOPT_URL, $url);
    curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($curl, CURLOPT_HEADER, false);

    // Execute cURL session and get the response
    $response = curl_exec($curl);

    // Close cURL session
    curl_close($curl);

    // Decode the JSON response
    return json_decode($response, true);
}

3. The createWordPressPost Function

This function takes the post title and content, prepares the data, and sends it to the WordPress REST API to create a new post:

function createWordPressPost($title, $content) {
    $wordpressSite = 'YOUR_WORDPRESS_SITE_URL';
    $username = 'YOUR_USERNAME';
    $password = 'YOUR_APPLICATION_PASSWORD';

    // Prepare the API URL
    $apiUrl = $wordpressSite . '/wp-json/wp/v2/posts';

    // Prepare the post data
    $postData = [
        'title'   => $title,
        'content' => $content,
        'status'  => 'publish'
    ];

    // Set up the request with basic authentication
    $curl = curl_init();
    curl_setopt($curl, CURLOPT_URL, $apiUrl);
    curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($curl, CURLOPT_POST, true);
    curl_setopt($curl, CURLOPT_POSTFIELDS, json_encode($postData));
    curl_setopt($curl, CURLOPT_HTTPHEADER, [
        'Content-Type: application/json',
        'Authorization: Basic ' . base64_encode($username . ':' . $password)
    ]);

    // Execute the request and capture response
    $response = curl_exec($curl);
    curl_close($curl);

    return json_decode($response, true);
}

4. Collecting Search Results

The script checks if a keyword is provided through a GET request. If so, it generates several queries based on that keyword:

if (isset($_GET['keyword'])) {
    $keyword = $_GET['keyword'];
    $queries = [
        "What is $keyword",
        "Why $keyword?",
        "How $keyword Works?",
        "$keyword Architecture?",
        "How to install and configure $keyword?",
        "Basic Tutorial of $keyword"
    ];

    $content = ""; // Initialize content variable for WordPress post

    // Collect search results
    foreach ($queries as $query) {
        $results = searchImages($query);
        if (!empty($results['items'])) {
            $imageUrl = $results['items'][0]['link'];
            $imageTitle = htmlspecialchars($results['items'][0]['title']);
            $content .= "<h3>$query</h3><img src='$imageUrl' alt='$imageTitle'><br>";
        } else {
            $content .= "<p>No results found for '$query'.</p>";
        }
    }

    // Create a WordPress post with the collected content
    $postTitle = "Image Search Results for '$keyword'";
    $response = createWordPressPost($postTitle, $content);

5. The HTML Form

The HTML section provides a simple interface for users to input their search keyword. The results are displayed below the form:

<form action="" method="get">
    <input type="text" name="keyword" placeholder="Enter a keyword e.g., Git">
    <button type="submit">Generate Queries</button>
</form>

<div class="result-container">
    <?php
    if (isset($queries)) {
        foreach ($queries as $query) {
            $results = searchImages($query);
            if (!empty($results['items'])) {
                echo "<div class='result-item'>";
                echo "<h3>" . htmlspecialchars($query) . "</h3>";
                echo "<img src='" . $results['items'][0]['link'] . "' alt='" . htmlspecialchars($results['items'][0]['title']) . "'>";
                echo "</div>";
            } else {
                echo "<p>No results found for '$query'.</p>";
            }
        }
    }
    ?>
</div>

Conclusion

This PHP script effectively utilizes the Google Custom Search API to fetch images based on user queries and post the results to a WordPress site. It demonstrates how to combine different web technologies to create a dynamic application.

To run this script, ensure that you have valid API credentials and a working WordPress installation. Customize the code as needed to fit your project requirements. Happy coding!

The post Creating a WordPress Post with Google Image Search Results in PHP appeared first on Artificial Intelligence.

To run the Laravel page and view the recent WordPress posts, you’ll need to follow these steps. This assumes you already have a Laravel project set up. If not, I’ll also guide you through setting it up.

Step 1: Ensure Laravel Is Installed

If you don’t have a Laravel project set up, you can create one using Composer:

composer create-project --prefer-dist laravel/laravel my-laravel-app

After that, navigate to the project folder:

cd my-laravel-app

Step 2: Create the Controller

Run the Artisan command to create the controller if you haven’t already done so:

php artisan make:controller BlogController

Then, open the newly created controller at app/Http/Controllers/BlogController.php and add the method to fetch the WordPress posts as described earlier:

<?php

namespace App\Http\Controllers;

use Illuminate\Support\Facades\Http;

class BlogController extends Controller
{
    public function showRecentPosts()
    {
        // Fetch the latest posts from the WordPress REST API
        $response = Http::get('https://your-wordpress-site.com/wp-json/wp/v2/posts');

        if ($response->successful()) {
            $posts = $response->json();
        } else {
            $posts = [];
        }

        return view('blog.recent-posts', compact('posts'));
    }
}

Step 3: Create the View

Next, create a Blade view to display the recent posts. In your project directory, go to resources/views/blog and create a file called recent-posts.blade.php. Add the following content:

@extends('layouts.app')

@section('content')
    <div class="container">
        <h1>Recent WordPress Posts</h1>
        @if(!empty($posts))
            @foreach($posts as $post)
                <div class="post">
                    <h2>{{ $post['title']['rendered'] }}</h2>
                    <div>{!! $post['excerpt']['rendered'] !!}</div>
                    <a href="{{ $post['link'] }}" target="_blank">Read more</a>
                </div>
                <hr>
            @endforeach
        @else
            <p>No posts available.</p>
        @endif
    </div>
@endsection

If you don’t have a layout already, you can create a basic one at resources/views/layouts/app.blade.php:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Laravel Blog</title>
    <link rel="stylesheet" href="{{ asset('css/app.css') }}">
</head>
<body>
    <nav>
        <a href="/">Home</a>
        <a href="/recent-posts">Recent Posts</a>
    </nav>

    <main>
        @yield('content')
    </main>

    <script src="{{ asset('js/app.js') }}"></script>
</body>
</html>

Step 4: Set Up Routing

In your routes/web.php file, add a route for the page:

use App\Http\Controllers\BlogController;

Route::get('/recent-posts', [BlogController::class, 'showRecentPosts']);

Step 5: Run the Laravel Development Server

Now you need to run the Laravel development server. Use this command to start the server:

php artisan serve

This will start the development server, typically at http://127.0.0.1:8000.

Step 6: Access the Page

Once the server is running, open your browser and visit the following URL to see your recent WordPress posts:

http://127.0.0.1:8000/recent-posts

If everything is set up correctly, this page should display the recent posts from your WordPress site using the REST API.

Troubleshooting

1. Permissions: Ensure that the WordPress REST API is enabled and accessible. You can check by visiting https://your-wordpress-site.com/wp-json/wp/v2/posts in your browser.
2. Dependencies: If the Http class isn’t available, you may need to add it to the service providers (if you are on a Laravel version that doesn’t include it by default).
3. CSS/JS assets: If you want to style the page, you can add CSS and JS files in the public/css and public/js folders respectively, and link them in the app.blade.php layout.

That’s how you can run this page and view recent WordPress posts in your Laravel application.

The post How to Display WordPress Posts in Laravel Using REST API appeared first on Artificial Intelligence.