Adding WordPress Custom Rest API Plugin

Sometimes you prefer to create a custom Rest API in PHP within the context of WordPress to return data in a structured format such as JSON which involves setting up custom routes. Here’s a step-by-step guide to creating & integrating a basic WordPress Custom REST API in a WordPress plugin.

Set up a WordPress Plugin

Go to ‘wp-content/plugins’ directory of your WordPress and create a PHP file (e.g., CustomApi.php) to serve as a main plugin file.

In this example, the plugin folder and PHP file names are the same. You can rename it.

You can follow simple 3 steps to create and activate a Custom Plugin in the WordPress Dashboard in a few minutes, check this link – How to Create Custom WordPress Plugin: 3 Easy Steps.

Define WP API Route:

In your plugin file, use the add_action function to hook into WordPress and register your custom API route. Here’s an example of how to add an API route:

function registe_api_routes() {
    register_rest_route('PublicAPIs/v1', '/GetTop10Items',
						array('methods' => 'GET', 'callback' => 'CallFun_GetTop10Items',)
						);
}

add_action('rest_api_init', 'registe_api_routes');

Create API Callback Function

Define the callback function you specified in the register_rest_route for your API route. This function will handle the request and return the data you want to show via the API.

In our example, whenever public API is called by an external source then the below code will be executed internally.

function CallFun_GetTop10Items() {
	// Your API logic here
	// Example:
	$args =  array('showposts' => 10, 'orderby' => 'post_date', 'order' => 'DESC','post_status' => 'publish');

	$query_result = query_posts($args);

	$postList = [];

	foreach ($query_result as $result) {
	  $postList[] = array( "post_title" => $result->post_title, "post_name" => $result->post_name);
	}

	return $postList;
	// or
	// return new WP_REST_Response($postList, 200);
}

Test Your API Endpoint

You can now access your API endpoint and check if it is working as accepted.

How to find WP API endpoints or URLs?

• Open the browser and open the Inspect element developer tool as well. (press f12 or right-click & click Inspect)
• Go to https://yourdomain.com/wp-json/ to get wp-json list.
• Once it is loaded, navigate and go to routes
• expand and go to the path (namespace/endpoint) that is defined in register_rest_route method, that is ‘PublicAPIs/v1/GetTop10Items‘
• Get the API (full URL) as shown in the below screenshot.
  example: https://yourdomain.com/wp-json/PublicAPIs/v1/GetTop10Items

Test WP Web API – Get Method()

Get API can be executed directly on the browser but for demo purposes, we will use the Postman tool to test our API.

The below screenshot demonstrates that a Get API request sends back a response as a JSON result via Postman tool.

Test API: https://yourdomain.com/wp-json/PublicAPIs/v1/GetTop10Items

Calling WordPress Custom Rest API from Javascript

You can use the fetch method in Javascript to call and get the response from the WordPress Custom Rest API, as demonstrated below.

<script>

document.addEventListener("DOMContentLoaded", LoadLatestPosts);

async function LoadLatestPosts() {

	const response = await fetch('/wp-json/PublicAPIs/v1/GetTop10Items');
	const data = await response.json();

	data.forEach(obj => {
		// your logic
	});

}

</script>

for more details check this link: https://developer.wordpress.org/rest-api/extending-the-rest-api/adding-custom-endpoints/

A custom plugin is an alternative method of storing functions for your website. WordPress is so popular because of its open-source content management system (CMS) and there are over millions of plugins widely available but we will see how to create plugin in WordPress with examples and adding custom codes instead of using a function.php file

Reason to avoid function.php file

You can also include additional code in the theme’s functions.php file but whenever there is a theme update or switching to a different theme in the future, you will lose these changes(additional codes). And every time you must back up your custom codes whenever there is a theme update.

To avoid such a problem, you can create your own plugin and use custom code in that. Benefit – The theme update won’t affect the plugin code.

Now, we will see how to create plugin in PHP (text file) and add it in WordPress.

How to Create a WordPress Plugin (In 3 Steps)

Recommendation – It is best practice to create a new Plugin in the local environment first and after successful testing deploy it in the live environment.

Let’s look at how to create a plugin for a website from scratch in 3 steps

Step 1: Create the Plugin File

Open a new Notepad or text file.

Provide basic information for a new plugin, mentioned below:

Copy & paste the below code into the notepad. Code should start with <?php

<?php
/*
Plugin Name: MyPlugin
Plugin URI: https://google.com/
Description: My custom functions
Version: 1
Author: Myself
*/

Save the file, example – MyPlugin.php.

Step 2: Install Custom Plugin into WordPress

1. Go to WordPress admin (https://www.yoursite.com/wp-admin)

2. go to – Plugin >> Add New

3. Click on ‘Upload Plugin‘

4. ‘Choose file‘ and upload the zip file (MyPlugin.zip)

5. Click on ‘Install Now‘

6. After successful Installation, click on ‘Activate Plugin‘

Click on Plugins, you can see the newly created custom Plugin with the description as shown in the below screenshot.

Step 3: Edit Plugin & Add Code

Next, go to Plugin >> Plugin File Editor

On the top-right, select the custom plugin ‘MyPlugin‘ from the dropdown and click the ‘Select‘ button.

Write your php code in the editor and click on ‘Update File‘

That’s it, test your code if it is working as expected.

Reference: WordPress

In this post, we will see how to integrate WordPressPCL Nuget Package to connect and work with the WordPress website using REST APIs in C# .Net application. WordPress software is written in PHP and it is difficult for other programming developers to adopt additional skills and make changes in the code. The good thing is, .Net developers can make use of the WordPressPCL library in C# which acts as an interface to allow external applications to access the data and functionality of the WordPress CMS via REST API calls.

Create Application Password for WordPress API

The first step is to create an Application Password which will be used in the code for authentication purposes.

• Login into WordPress admin portal (https://www.YourDomain.com/wp-admin).
• Go to User >> Profile page.
• Generate the password by providing an Application Name.

Implementation of WordPress API Code C#

Next, integrate the WordPressPCL library in the .Net application and write methods in a static class using C# code to call WordPress Rest APIs.

Integrate WordPressPCL Nuget Package

• Create a new .Net application
• Install WordPressPCL Nuget Package

or use the following command line in Console to install the package

WordPress API authentication C#

• Create a common static class and methods that can perform WordPress API requests (CRUD operations).

public static class WordPress
{
} 

• Add the following namespaces

using WordPressPCL;
using WordPressPCL.Models; 

• Use ‘WordPressClient‘ class to get authenticated and connect with the WordPress client.
  • Pass the default Rest API URL as a parameter in the constructor.
    e.g., https://YourDomain.com/wp-json
  • Pass your registered Application username & password for authentication.
    You can use either Basic or JWT Token (Bearer) for authentication

//Method 1) Basic Authentication
wpClient.Auth.UseBasicAuth("WpApiUserName", "JEs8 xxWpPasswordxx 98JW iKK3 98Jw");

//Or

//Method 2) JWT(Bearer) Authentication
wpClient.Auth.UseBearerAuth(JWTPlugin.JWTAuthByEnriqueChavez);
wpClient.Auth.RequestJWTokenAsync("username", "password");
var isValidToken = wpClient.Auth.IsValidJWTokenAsync;

CRUD Rest API C# Code for WordPress Post

Below is the full code for WP-Post which performs CRUD operation using WordPress Rest APIs

Create WP-Post C# Code

using WordPressPCL;
using WordPressPCL.Models;

namespace Data
{
    public static class WordPress
    {
        public static async Task CreateOrUpdatePost(DataObject dataObj)
        {
            // Get valid WordPress Client
            WordPressClient wpClient = new WordPressClient("https://YourDomain.com/wp-json/");

            //Basic Auth
            wpClient.Auth.UseBasicAuth("WpApiUserName", "JEs8 xxWpPasswordxx 98JW iKK3 98Jw");

            //Or, Bearer Auth using JWT tokens
            //wpClient.Auth.UseBearerAuth(JWTPlugin.JWTAuthByEnriqueChavez);
            //wpClient.Auth.RequestJWTokenAsync("username", "password");
            //var isValidToken = wpClient.Auth.IsValidJWTokenAsync;

            //Create and Set Post object
            var post = new Post
            {
                Title = new Title(dataObj.Title),
                Meta = new Description(dataObj.Description),
                Excerpt = new Excerpt(dataObj.Excerpt),
                Content = new Content(dataObj.Content),
                //slug should be in lower case with hypen(-) separator 
                Slug = dataObj.Slug
            };

            // Assign one or more Categories, if any
            if (dataObj.Categories.Count > 0)
            {
                post.Categories = dataObj.Categories;
            }

            // Assign one or more Tags, if any
            if (dataObj.Tags.Count > 0)
            {
                post.Tags = dataObj.Tags;
            }

            if (dataObj.PostId == 0)
            {
                // if you want to hide comment section
                post.CommentStatus = OpenStatus.Closed;
                // Set it to draft section if you want to review and then publish
                post.Status = Status.Draft;
                // Create and get new the post id
                dataObj.PostId = wpClient.Post.CreateAsync(post).Result.Id;

                // read Note section below - Why update the Post again?
                await wpClient.Posts.UpdateAsync(post);
            }
            else
            {
                // check the status of post (draft or publish) and then update
                if (IsPostDraftStatus(wpClient, dataObj.PostId))
                {
                    post.Status = Status.Draft;
                }

                await wpClient.Posts.UpdateAsync(post);
            }
        }

        private static bool IsPostDraftStatus(WordPressClient client, int postId)
        {
            var result = client.Posts.GetByIDAsync(postId, true, true).Result;

            if (result.Status == Status.Draft)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
    }
} 

Call CreateOrUpdatePost() static method from other class. The below code shows how to set the properties of a Post and generate content (from the database).

public async void PostTodaysContent()
{
	try
	{
		var dbContent = _context.NextPosts.Where(w => w.Name == "Today").FirstOrDefault();

		DataObject dataObj = new DataObject()
		{
			PostId = dbContent.PostId,
			Title = "Sample title",
			Description = "This is description",
			Content = GenerateContent(dbContent),
			Slug = dbContent.Slug // or "this-is-sample"
		};

		// Existing WP Category IDs
		dataObj.Categories = new() { 111, 112 };

		await WordPress.CreateOrUpdatePost(dataObj);

		if (dbContent.PostId == null || dbContent.PostId == 0)
		{
			dbContent.PostId = dataObj.PostId;
			_context.SaveChanges();
		}
	}
	catch (Exception ex)
	{

	}
} 

Suggestion:

If you are targeting standard Categories or Tags then better to create them manually in WP-Admin Portal and use its existing IDs in the code.
How to find Id? – Click on any Category or Tag and find the Id in the URL.

But you can generate them dynamically through code if that is the requirement, please see the Categories and Tags code section below.

Generate HTML Content – Sample

private static string GenerateContent(NextPosts dbContent)
{
	// sample content
	StringBuilder sb = new StringBuilder();
	sb.Append("<h2> " + dbContent.Header + "</h2>");
	sb.Append("<div>");
	sb.Append(dbContent.Column2 + "<br>");
	sb.Append("<table>");
	sb.Append("<tr><td>" + dbContent.Column3 + "</td></tr>");
	sb.Append("</table>");
	sb.Append("</div>");

	return sb.ToString();
} 

Get WP-Post C# Code

// get all
var getAllPosts = await wpClient.Posts.GetAllAsync();
// get by id
var getPostbyid = await wpClient.Posts.GetByIDAsync(postId);

// Get Posts Count
var postsCount = await wpClient.Posts.GetCountAsync(); 

Delete WP-Post C# Code

// delete Post by id
bool isDeleted = wpClient.Posts.DeleteAsync(postId).Result;

WordPress Category CRUD REST API C# Code

CRUD operation API calls (create, read, update and delete) for Category.

Category category = new Category
{
	Name = "Sales",
	Slug = "new-sales",
	// If it is a sub-category then mention Parent(existing) category Id
	Parent = 111
};

// create
var wpc = wpClient.Categories.CreateAsync(category).Result;
int categoryId = wpc.Id; // e.g. 10

// update category by id
Category category = new Category
{
	Name = "Rename Sales",
	Id = 10,
};
await wpClient.Categories.UpdateAsync(category);

// get all categories
var getAllCategories = await wpClient.Categories.GetAllAsync();

// get category by id
var getCategoryById = await wpClient.Categories.GetByIDAsync(categoryId);

// delete Category by id
bool isDeleted = wpClient.Categories.DeleteAsync(categoryId).Result; 

WordPress Tag CRUD REST API C# Code

Code for consuming the Tag REST-APIs

Tag tag = new Tag
{
	Name = "books",
	Slug = "new-books",
};

// create
var wptag = wpClient.Tags.CreateAsync(tag).Result;
int tagId = wptag.Id; // e.g. 20

// update tag by id
Tag tag= new Tag
{
	Name = "Rename books",
	Id = 20,
};
await wpClient.Tags.UpdateAsync(tag);

// get all tags
var getAllTags = await wpClient.Tags.GetAllAsync();

// get tag by id
var getTagById = await wpClient.Tags.GetByIDAsync(tagId);

// delete tag by id
bool isDeleted = wpClient.Tags.DeleteAsync(tagId).Result; 

var comm = await wpClient.Comments.GetAllAsync();
var commById = await wpClient.Comments.GetByIDAsync(id);
var commByPostId = await wpClient.Comments.GetCommentsForPostAsync(postId, true, false);