API plugin. WordPress REST API - what is it for and what is it? Definition of the term "Settings API"

Facebook

The Complete Guide to Configuring the WordPress API, Part 1: Introduction

Now is the time to become a professional WordPress developer. Whether it's custom development or the creation of themes and plugins, today there is a demand for everything related to this topic.

WordPress has a well written API documentation for developers regardless of their level of training. But this does not negate the need to accumulate practical experience in the field of development for this CMS.

As with most things in web development, just because something works doesn't mean it's done exactly right. So we, as developers and artisans of sorts, are challenged to make sure that what we do is done correctly.

Lots of theme and plugin source code shows that developers continue to do what works, but it is not done in the most efficient way. This is especially true for theme options, menu pages, validation mechanisms, and the like.

And we want to stop this.

In this series of articles, we're going to take a deep dive into the heart of the WordPress Settings API. We will understand what the problem is and why it is important, and we will also learn how to use this API correctly.

Our main goal is to learn how to competently configure the Settings API (Settings API) regardless of your level of training. By the end of the series, you will gain a deep, holistic understanding and practical examples of how to properly use this API in practice.

To successfully complete all stages, we need to start from absolute zero. Before writing any code and analyzing examples, we need to get acquainted with the Settings API - find out what it is and what it is intended for.

Definition of the term "Settings API"

At its core, the Settings API is a set of functions provided by WordPress that simplifies the process of creating menus, settings pages, and storing, validating, and retrieving user input.

Sounds simple, doesn't it?

In this series of articles we will study each aspect in detail. And we can build on this simple definition in our further work.

Why should you use the Settings API?

Now that we've established what the Settings API is, let's look at why we're going to use it instead of our own custom routines for processing user input, serialization (the process of turning a data structure into a sequence of bits), and validation.

Interacting with WordPress Core

The Settings API was developed by the creators of the WordPress platform to make it easier to create extensions. Therefore, it is only logical to use the functions provided by this API.

Of course, you can bypass the Settings API and brute-force implement your own functionality without anyone stopping you, but this requires unnecessary work and risks not following the recommendations of the WordPress core team, which can ultimately lead to errors in the control panel.

Using a tool made by developers for developers ensures that we interact with the kernel in the right way.

Free Standard Features

Using the Settings API is not only a guarantee that development will be carried out in the right way. It also ensures that the user interface will follow the traditions of the platform, and the data will be processed by mechanisms similar to those used in WordPress itself. Plus, it can save a lot of time.

When you start creating your interfaces using the same principles as those used in WordPress and use the Settings API in your work, your products will end up tightly integrated with the CMS.

This means that when users interact with your creations, they will feel at ease - everything will be clear to them. They will feel like they are modifying a system add-on created by the WordPress developers.

In truth, using native WordPress styles is not directly related to the Settings API and is a slightly different topic, but the Settings API aspect of creating menu pages does require the use of native WordPress styles.

Isn't there any point in sticking to one style?

More secure, more sustainable

By taking advantage of WordPress's built-in features, you can be sure that saving, retrieving, and validating will go smoothly. The Settings API provides many functions that are safe to use for the kernel.

After all, the Settings API is subject to the same rules and principles as the WordPress API. Also, when updating the CMS, the Settings API functions will also become obsolete. You will need some time to update your project BEFORE incompatibilities affect its performance.

What's next?

Now, you should have a basic understanding of what the Settings API is and why you should use it when creating themes and plugins.

By Yandex.
It"s a web service, so you don"t need to add that.

Server owners need a special key to enable this plugin.
Login to the Yandex website and then obtain this key , then put it in the API's config.
Please note that the free key supports "only" 10,000,000 characters every month, but you can create how many keys you want.

These are the available languages:

SpoilerTarget">Spoiler

AZERBAIJAN
ALBANIAN
ENGLISH
ARABIC
AFRIKAANS
BASQUE
BELARUSIAN
BULGARIAN
BOSNIAN
WELSH
HUNGARIAN
VIETNAMESE
HAITIAN
GALICIAN
DUTCH
GREEK
GEORGIAN
DANISH
INDONESIAN
IRISH
ITALIAN
ICELANDIC
SPANISH
KANNADA
CHINESE
KOREAN
LATIN
LITHUANIAN
MACEDONIAN
MONGOLIAN
GERMAN
NEPALI
NORWEGIAN
PERSIAN
POLISH
PORTUGUESE
ROMANIAN
RUSSIAN
SERBIAN
SLOVAKIAN
SLOVENIAN
SUNDANESE
TURKISH
UZBEK
UKRAINIAN
FINNISH
FRENCH
HINDI
CROATIAN
CZECH
SWEDISH
SCOTTISH
ESTONIAN
JAPANESE

When you join the server, your language is the server language.
To change it, just type /lang(permission: translator.lang) and select your language from the menu.

If you don't know how to add dependencies, read here.

Developer
Be sure you are using Java >= 8.
Add the JAR to your build path. Then set the "Manual Manifest" setting and create your MANIFEST.MF to the project. Write:

Main-Class: your.package.Class
Class-Path: ..\lib\Translator.jar

Server owners
Be sure you are using Java >= 8.
Create a folder named lib in the main server root, and put here the JAR.
Also, you need to put it in your plugins folder.

//Sending a message translated automatically to the player language
p.sendMessage("§a" + Translator.translate("Hello!", p));

//Sending a message translated manually
p.sendMessage("§a" + Translator.translate("Hello!", Language.ENGLISH, Language.ITALIAN));

//Getting the server language
Language serverLang = Translator.getServerLanguge();

//Getting player's language
Language playerLang = Translator.getPlayerLanguage(p);

If you reload the API while a plugin that uses it is enabled, it will crash. To fix manually, unload the plugin, reload the API and load the plugin
Color codes are not supported. To use them see the examples above
Little lag (the API needs to translate the original text and receive JSON)

If you have any problem, write a post in the discussion or contact me via private messages. I will not reply to bug reports on the reviews section.

Currently there are not plugins that are using this API. If you are using it, tell me it and I will add it here

Recent Reviews

Version: 1.0
Grande frate! Ho letto Powered by Gamehosting, quindi penso tu sia italiano? se si: sai perché da questo errore all" avvio?
P.s (ho letto impossibile trovare il percorso specificato, ma la cartella ci sta)
: java.io.IOException: Impossible trovare il percorso specificato
: at java.io.WinNTFileSystem.createFileExclusively(Native Method)
: at java.io.File.createNewFile(Unknown Source)
: at eu.iamgio.translator.UsersFileLoader.loadRegisterFile(UsersFileLoader.java:21)
: at eu.iamgio.translator.Translator.onEnable(Translator.java:35)
: at org.bukkit.plugin.java.JavaPlugin.setEnabled(JavaPlugin.java:321)
: at org.bukkit.plugin.java.JavaPluginLoader.enablePlugin(JavaPluginLoader.java:340)
: at org.bukkit.plugin.SimplePluginManager.enablePlugin(SimplePluginManager.java:405)
: at org.bukkit.craftbukkit.v1_8_R3.CraftServer.loadPlugin(CraftServer.java:357)
: at org.bukkit.craftbukkit.v1_8_R3.CraftServer.enablePlugins(CraftServer.java:317)
: at net.minecraft.server.v1_8_R3.MinecraftServer.s(MinecraftServer.java:414)
: at net.minecraft.server.v1_8_R3.MinecraftServer.k(MinecraftServer.java:378)
: at net.minecraft.server.v1_8_R3.MinecraftServer.a(MinecraftServer.java:333)
: at net.minecraft.server.v1_8_R3.DedicatedServer.init(DedicatedServer.java:263)
: at net.minecraft.server.v1_8_R3.MinecraftServer.run(MinecraftServer.java:525)
: at java.lang.Thread.run(Unknown Source)

The plugin is a dynamically loaded library (DLL). After installing the program, all plugins included in the distribution are placed in the directory c:\Program Files (x86)\Common Files\Soft Gold\Inventory 14\Plugins\... The *.abl extension is required to automatically load the plugin from the specified directory when the application starts. The plugin can also be loaded from any other location on the disk by specifying the search path in the settings.

Initializing the plugin API

(Delphi VCL Extensions)

(Plugin interface for ABViewer/Inventory)

{************************************************************}

unit sgPluginItem;

interface

implementation

XMLDocRef: IXMLDocument = nil;

ClientRef: IXMLNode = nil;

P: Pointer = nil;

PluginsHostWnd: HWND = 0;

PluginsHostWndName: string = "";

XMLAtomString: string = "";

procedure InitializeDoc;

begin

// getting the unique name of the window class with parameters

PluginsHostWndName:= Format("TsgPluginsHost:%.8X:%.8X", );

// finding the window itself

PluginsHostWnd:= FindWindow(PChar(PluginsHostWndName), nil);

If PluginsHostWnd<>0 then

Begin

// getting the atom string to get the xml document parameter

XMLAtomString:= Format("XMLOfs%.8X%.8X",

XMLDocRef:= IXMLDocument(GetProp(PluginsHostWnd, PChar(XMLAtomString)));

If Assigned(XMLDocRef) then

Begin

// adding an element to the list

ClientRef:= XMLDocRef.DocumentElement.ChildNodes.ChildNodes.AddChild(sClient);

// initializing the address of the Invoke function

ClientRef.ChildValues["Invoke"] := IntToId(Integer(@Invoke)); // hexadecimal $XXXXXXXX

End;

end;

initialization

CoInitialize(P);

InitializeDoc;

Setting up and running the demo version of the plugin

The demo version of the plugin is configured automatically when installing the program and is connected immediately after launching Inventory. The package includes the source code of the component (project name sgPlugin.dpk) and a demo version of the plugin (project name plug1.dpr).

The procedure for launching the plugin from debug mode:

▪ Open C:\Users\USER_NAME\Documents\Inventory 14\Plugins\Source\Delphi\Demos\Plug1\plug1.dpr

▪ Set in project options:

Search Path : "..\..\Components\PlugItem";

Output derectory , for example: “c:\Program Files\Common Files\Soft Gold\Inventory 14\Plugins”;

Host application , to the newly installed application, for example: “c:\Program Files\Soft Gold\Inventory 14\Inventory 14.exe”.

▪ Launch for execution.

To use the component in designtime you need to open, rebuild and install C:\Users\USER_NAME\Documents\Inventory 14\Plugins\Source\Delphi\Components\PlugItem\sgPlugin.dpk. After installing the component, the TsgPluginItem component will appear in the Delphi component palette, on the Soft Gold tab, which can be used in designtime, i.e. place on the form.

Today we're going to talk about the WordPress REST API (some call it the JSON REST API), an upcoming addition to WordPress core that is now available as a plugin and originally appeared in version 4.1. Now we are waiting for two-stage integration in versions 4.4 and 4.5. While the developers are very excited about this new feature, the average WordPress user may not understand the excitement, even though the feature is a milestone in WordPress history. Let's find out what the WordPress REST API is, what it means for the future of WordPress, and why it's written in capital letters.

What is an API?

Let's start with the basics and terminology, since the name JSON REST API is entirely made up of acronyms. The first three letters of “API” stand for Application Programming Interface.

What is the API for?

Basically, the API is needed to connect different pieces of software, and you can think of it like a USB port.

USB ports are used to connect various types of devices to your computer. These could be printers, computer controls, portable hard drives, phones, etc. Through this port, the computer and device can interact with each other, exchanging information. An API is something similar, only it connects not devices, but programs. Thus, programs can exchange data within strictly defined limits, interacting with each other. You are constantly using the API without even noticing it. For example, if you use third-party programs to use your Twitter account, then this action is performed through the Twitter API. Thanks to API technology, I can be on Twitter every day without even going to the Twitter site.

The API is also necessary when you use email marketing services like MailChimp on your WordPress site. In short, an application programming interface allows developers to use the functions and data of other web applications or services for their own software in a completely secure manner.

What do REST and JSON mean?

REST is an abbreviation for Representational State Transfer. REST describes a specific API architecture designed to be lightweight, user-friendly, and suitable for a wide range of services. Google, Facebook, and Twitter use the REST style for many of their APIs, for the simple reason that REST is built on top of HTTP, a protocol that is used everywhere on the web, along with its more secure cousin HTTPS. Due to their high compatibility with modern technologies, REST-based APIs are gaining more and more popularity on the web, and not just in the case of WordPress. Almost any program that has access to the Internet can use this type of API. This seems to have great potential for interoperability between programs, doesn't it?

JSON is a text-based data interchange format based on JavaScript. The great thing about JSON is that it is a format that is both human and machine friendly. Developers can write and read it like a regular programming language, and computers can easily parse and generate it. Be that as it may, its most important advantage is that the main programming languages already have codifiers and decodifiers to convert the data structure into JSON or vice versa. This means that the JSON interface can act as a translator between two applications that were written in different languages and would otherwise never communicate with each other.

The JSON format can become something of a universal connector across the Internet, and for this reason, WordPress and other large services have decided to take advantage of this advantage. On top of that, in WordPress JSON also replaces the slightly outdated XML-RPC standard, which is more difficult to use.

With all this said, the following conclusions can be drawn:

API is a connector on any software;
REST is the design of this connector;
JSON is a cable with universal plugs at the ends;

JSON REST API and WORDPRESS

Okay, we realized that this thing is useful. But doesn't WordPress already use these APIs within its framework? Well, yes, there is one, and it is the WordPress API. It is used for WordPress plugins, and only works with internal WordPress processes. But if we are talking about interaction with software from the outside, then this API is outdated and not very user-friendly. The new WP API is much more universal, as it was created so that WordPress can easily interact with other websites and services on the Internet. Using a universal API, you can display and save content from other sites and applications, regardless of whether they use the WordPress engine or not. That's right, this API allows the WordPress platform to become a content management system suitable for any application written in any language.

Plus, the same thing works in reverse. Everything that is on your WordPress site will also be available on any external website and service, including:

Records;
Pages;
Custom post types;
Media;
Comments;
Taxonomies;
Users;
And much more

It works because everything is based on HTTP, which is available everywhere. The protocol allows sites to send, create, read, update or delete requests between two parties. In HTTP, the POST, GET, PUT, and DELETE commands are equivalent. In addition, the API understands URLs whose structure is similar to directories, and as we know, similar links are used by WordPress and other content management systems.

Summarizing what has been said, we can say that if you want to transfer all the records of a specific user from your site to another resource, then you can simply use the directive -

GET http://yoursite.com/users/username.

The same applies to updating single posts, deleting users, publishing pages and much more. In short, the API allows you to manage the WordPress admin area without the need for manual login and use non-WordPress content.

Great, but is it safe? The good news is that the WordPress REST API has built-in security measures. The magic word here is authentication. The interface has both cookie authentication and OAuth authentication. So cookie authentication works for plugins and themes, and OAuth is used to authenticate mobile, web, and desktop clients. Both methods limit third-party activities on your site. Since APIs are created so that platforms can exchange strictly defined information in a limited manner, your data is completely safe.

What does WP API mean for WORDPRESS?

Is this one of those things that only developers can use? How will this change affect the average website user? Adding the WordPress REST API is the first step towards making WordPress a full-fledged web application platform, as it opens up the WordPress platform to interact with the entire internet.

As mentioned above, APIs allow you to do the same things that the WordPress admin panel allowed you to do, but without bypassing the user interface. This means that a WordPress backend is no longer needed.

Any developer can create an alternative WordPress admin panel based on virtually any device or platform.
The new API could bring many alternatives to the standard backend, including mobile apps available for WordPress administration
Since JSON support is natively built into iOS and Android, the WordPress app monopoly will be history.
Third party content will also be available to WordPress. Even better, the API makes WordPress content language and environment independent, so you can take content from any source and display it however you want.
Ruby on Rails and other frameworks will have access to the functionality of WordPress and all the capabilities that come with it, and the benefits of these areas will be available to WordPress users.

This news will especially please developers who work with the frontend, as they will be able to change the frontend as they please without affecting the backend.

For non-developers, this technology can be used to create new solutions to integrate content from other web profiles with their WordPress sites.

WordPress enters a new era

Not only will new types of content become available to WordPress, but thanks to the new API, WordPress content will be available to the entire internet. Non-PHP systems will be able to use WordPress data and customize it with their own applications.

But the most interesting thing is the possibility of using WordPress products, for example, plugins, on other platforms and content management systems.

Mobile apps built on WordPress will be available everywhere, which is great news for all those who create or use them. I think there will be solutions that will allow the average user to automatically create mobile applications based on WordPress sites.

Eventually:

As you can see, the new WordPress REST API transforms WordPress into something new. It will open WordPress to the entire Internet, and allow the platform to more seamlessly interact with third-party applications and services. The appearance of the WordPress REST API will please not only developers, but also ordinary users who will receive many new features.

Hooks are provided by WordPress to allow your plugin to "hook into" the rest of WordPress; that is, to call functions in your plugin at specific times, and thereby set your plugin in motion. There are two kinds of hooks:

(Codex)
(Codex)

You can sometimes accomplish the same goal with either an action or a filter. For example, if you want your plugin to change the text of a post, you might add an action function to publish_post (so the post is modified as it is saved to the database), or a filter function to the_content (so the post is modified as it is displayed in the browser screen).

For a thorough listing of all action and filter hooks in WP see Adam Brown's WordPress Hooks Database.

Function Reference

Filter Functions

Actions Functions

Activation/Deactivation/Uninstall Functions

Actions

Actions are triggered by specific events that take place in WordPress, such as publishing a post, changing themes, or displaying an . An Action is a custom PHP function defined in your plugin (or theme) and hooked, i.e. set to respond, to some of these events. Actions usually do one or more of the following:

Modify database data.
Send an email message.
Modify the generated administration screen or front-end page sent to a user browser.

The basic steps to make this happen (described in more detail below) are:

Create a PHP function that should execute when a specific WordPress event occurs, in your plugin file.
Hook this function to the event by using the function.
Put your PHP function in a plugin file, and activate it.

Create an Action Function

The first step in creating an action in your plugin is to create a PHP function with the action functionality of your plugin and put it in your plugin file (your plugin file must go into the wp-content/plugins directory). For example, if you want your friends to get an email message whenever you create a new post, you might define the following function:

Function email_friends($post_ID) ( $friends = " [email protected],[email protected]"; mail($friends, "sally"s blog updated", "I just put something on my blog: http://blog.example.com"); return $post_ID; )

For most actions, your function should accept a single parameter (usually the post or comment ID, depending on the action). Some actions take more than one parameter -- check the documentation for the action (if available) or the WordPress source code for more information. Besides the one parameter, you can also access the , and call other WordPress functions (or functions in your plugin file).

Any text output by the function (e.g. with print) will appear in the page source at the location where the action was invoked.

NOTE: Keep in mind that other plugins or the WordPress core may already be using the function name you have thought of. See the next section, for more information.

Avoiding Function Name Collisions

It is possible that someone has created a plugin with a function named the same as one in your plugin.

This is a problem because PHP does not allow multiple functions with the same name. If two plugins provide a function with the same name, or a plugin provides a function with a name the same as a WordPress function, the blog could cease to function. There are two ways to avoid this problem.

The first solution is to prefix every function in your plugin with a unique set of characters. If your name is John Q. Public, you might declare your functions as function jqp_output() (...) . The likelihood that someone with the same initials does the same thing with their plugin is possible but low.

The second - and possibly easier - a solution is to enclose your plugin functions in a class and call the class methods statically. This sounds more complicated than it is.

Consider this class, which expands on the examples provided above:

Class emailer ( static function send($post_ID) ( $friends = " [email protected],[email protected]"; mail($friends,"sally"s blog updated","I just put something on my blog: http://blog.example.com"); return $post_ID; ) ) add_action("publish_post", array("emailer", "send"));

This class called emailer has a method send that implements the plugin functionality.

The add_action() function outside of the class adds the action to WordPress that tells it to call the send method when a post is published. The array used in the second parameter tells the plugin system to call the static method of the class "emailer" named "send".

The function send is protected from the global namespace by the class declaration. It is not possible to call send() directly, and so any other function named send will not collide with this one. If you did want to call send(), you would need to use a scope resolution operator, like this: emailer::send()

The above example is for static methods. If you have an instance of a class then that won"t work. To call a method of an instance you need to pass the instance as a variable. Consider the above example modified to take this into account:

Class emailer ( function send($post_ID) ( $friends = " [email protected],[email protected]"; mail($friends,"sally"s blog updated","I just put something on my blog: http://blog.example.com"); return $post_ID; ) ) $myEmailClass = new emailer(); add_action("publish_post", array($myEmailClass, "send"));

Classes are a complicated subject. Read more about them in the PHP documentation on classes.

Hook to WordPress

After your function is defined, the next step is to "hook" or register it with WordPress. To do this, call in the global execution space of your plugin file:

Add_action("hook_name", "your_function_name", , );

Hook_name The name of an action hook provided by WordPress, that tells what event your function should be associated with. your_function_name The name of the function that you want to be executed following the event specified by hook_name . This can be a standard php function, a function present in the WordPress core, or a function defined by you in the plugin file (such as "email_friends" defined above). priority An optional integer argument used to specify the order in which the functions associated with a particular action are executed (default: 10). Lower correspond numbers with earlier execution, and functions with the same priority are executed in the order added to the action. accepted_args An optional integer argument defining how many arguments your function can accept (default 1), useful because some hooks can pass more than one argument to your function. This parameter is new in release 1.5.1.

In the example above, we would put the following line in the plugin file:

Add_action("publish_post", "email_friends");

Install and Activate

The last step in getting your filter hook to work is to install the file and activate the plugin. The PHP function you wrote and the call must go into a PHP file together, and the PHP file must be installed in the wp-content/plugins directory. Once it is installed, you will need to visit the admin section of WordPress and activate your plugin; see for more details.

Current Hooks for Filters

Activation/Deactivation/Uninstall

If your plugin has tasks to complete only at activation or deactivation time, it can use and Action Reference - A listing of WordPress's action hooks

External Resources

Adam Brown"s WordPress Hooks Database, a database of all WordPress" hooks, showing which version they come from, and linking to the source code spots that use them. This is the most complete.
Otto on WordPress: