+977-9866804165/1-4782129

Please keep in mind there are several different ways of doing this, and you can take a look at the WordPress and Laravel post for a list of third party packages and resources that others have created to solve this same task. The primary options are to either hook into the WordPress database, pull from the API, or sync data from one system to the other.

Let’s go through how this all works.

WordPress API

WordPress doesn’t ship with an API; however, the community has built a plugin named WP Rest API that allows any blog to have a jSON API.

In my case, I’m doing read-only requests that do not require any authentication. That makes reading and fetching data easy and simplifies a lot of code.

Here is my basic class to fetch a list of posts:

class WpApi
{
    protected $url = 'http://site.com/wp-json/wp/v2/';

    public function importPosts($page = 1)
    {
        $posts = collect($this->getJson($this->url . 'posts/?_embed&filter[orderby]=modified&page=' . $page));
        foreach ($posts as $post) {
            $this->syncPost($post);
        }
    }

    protected function getJson($url)
    {
        $response = file_get_contents($url, false);
        return json_decode( $response );
    }
}

Now when you call WpAPI->importPosts() it will grab the first page of results. The query string is worth mentioning because it has a few special clauses. The first is _embed which will embed all the extra data like image embeds, categories, and tags. Next is a filter to order by last modified that way when you edit a post on WordPress it is then on the first page of results, meaning it’s resynced.

Next, we need the ability to sync the post with our database. Here is how I set it up:

protected function syncPost($data)
{
    $found = Post::where('wp_id', $data->id)->first();

    if (! $found) {
        return $this->createPost($data);
    }

    if ($found and $found->updated_at->format("Y-m-d H:i:s") < $this->carbonDate($data->modified)->format("Y-m-d H:i:s")) {
        return $this->updatePost($found, $data);
    }
}

protected function carbonDate($date)
{
    return Carbon::parse($date);
}

For this step, I added a wp_id field to my own Posts table that way I have a one to one between my local database and WordPress.

Next, I just check and see if it doesn’t exist, then create it. Otherwise, update it, if it’s been modified since it was originally synced.

The createPost and updatePost are typical Laravel Eloquent inserts or updates. Here is the code for create:

protected function createPost($data)
{
    $post = new Post();
    $post->id = $data->id;
    $post->wp_id = $data->id;
    $post->user_id = $this->getAuthor($data->_embedded->author);
    $post->title = $data->title->rendered;
    $post->slug = $data->slug;
    $post->featured_image = $this->featuredImage($data->_embedded);
    $post->featured = ($data->sticky) ? 1 : null;
    $post->excerpt = $data->excerpt->rendered;
    $post->content = $data->content->rendered;
    $post->format = $data->format;
    $post->status = 'publish';
    $post->publishes_at = $this->carbonDate($data->date);
    $post->created_at = $this->carbonDate($data->date);
    $post->updated_at = $this->carbonDate($data->modified);
    $post->category_id = $this->getCategory($data->_embedded->{"wp:term"});
    $post->save();
    $this->syncTags($post, $data->_embedded->{"wp:term"});
    return $post;
}

If you look carefully, there are a few special cases like the author, featured image, category, and tags. Those come from the _embed in the original query string and syncing that data is just a matter of doing the same thing as previous.

public function featuredImage($data)
{
    if (property_exists($data, "wp:featuredmedia")) {
        $data = head($data->{"wp:featuredmedia"});
        if (isset($data->source_url)) {
            return $data->source_url;
        }
    }
    return null;
}

public function getCategory($data)
{
    $category = collect($data)->collapse()->where('taxonomy', 'category')->first();
    $found = Category::where('wp_id', $category->id)->first();
    if ($found) {
        return $found->id;
    }
    $cat = new Category();
    $cat->id = $category->id;
    $cat->wp_id = $category->id;
    $cat->name = $category->name;
    $cat->slug = $category->slug;
    $cat->description = '';
    $cat->save();
    return $cat->id;
}

private function syncTags(Post $post, $tags)
{
    $tags = collect($tags)->collapse()->where('taxonomy', 'post_tag')->pluck('name')->toArray();
    if (count($tags) > 0) {
        $post->setTags($tags);
    }
}

For the category I am pulling out the first category the post is assigned to because I only want one post per category, then in syncTags, I’m utilizing the Tags package by Cartalyst.

Creating a Scheduled Command

The final step to complete the import is to build a scheduled task to automatically pull posts down. I created a command named Importer through Artisan:

php artisan make:console Importer

Then in the handle method:

$page = ($this->argument('page')) ? $this->argument('page') : 1;
$this->wpApi->importPosts($page);

Finally, in Console/Kernel set this to run every minute:

$schedule->command('import:wordpress')
    ->everyMinute();

Now every minute of every day it attempts to sync the data and either create, update, or ignore the posts.

Going Further

This is a basic outline in how I set this feature up, and it only scratches the surface on what all could be done. For example, I’m heavily caching all the DB queries within the site and during this sync process if something is updated then the related cache is cleared.

Related Posts