VikRestaurants APIs

By reaching this BASE URL you will get the authorisation error below:

{
    "errcode": 101,
    "error": "Authentication Error! The username is empty or invalid."
}

In order to use the API Framework it is required the authentication of your credentials.
This means that you have to extend the BASE URL to send your username and your password.

.../index.php?option=com_vikrestaurants&task=apis&username=[YOUR_USERNAME]&password=[YOUR_PASSWORD]

The system also accepts login credentials sent by using the HTTP BASIC_AUTH header.

@see API Users to create some valid API credentials.

Once the BASE URL will contain a valid username and password, it will raise another type of error:

{
    "errcode": 201,
    "error": "File Not Found! The event requested does not exists."
}

The API Framework is built to execute certain pieces of code and it is mandatory to specify also the name of the EVENT (or PLUGIN) to run.
To complete the BASE URL we have to add an additional parameter called event.

.../index.php?option=com_vikrestaurants&task=apis&username=[YOUR_USERNAME]&password=[YOUR_PASSWORD]&event=[YOUR_EVENT_NAME]

To make sure your BASE URL is correct, you can try to use a pre-installed event called connection_ping.
Your URL should look like the one below:

.../index.php?option=com_vikrestaurants&task=apis&username=my_username&password=my_password&event=connection_ping

which should return the successful message below:

{
    "status": 1
}

For this reason, it is possible to pass certain arguments within the BASE URL. The special &args[] field can be placed in the query string to send all the additional arguments needed for your plugin.

To pass, for example, the fields first name, last name and e-mail, we can use the following query string:

&args[first_name]=John&args[last_name]=Smith&args[email]=Questo indirizzo email è protetto dagli spambots. È necessario abilitare JavaScript per vederlo.

which must be concatenated to your BASE URL.

An API User can be configured with all the fields below.

• Application Name - the name of the application. If not specified, the username will be used.
• Username - the username of the application, used to authenticate the requests.
• Password - the password of the application, used to authenticate the requests. Press the icon to show the password.
  Press the Generate Password button to insert a random and safe password.
• Active - enable this option it the application can access to the API Framework.

It is possible to specify also one or more IP Addresses to restrict the origin from which the application can connect itself to your VikRestaurants.

Press the Add IP Address button to insert the 4 parts of your IP (min 0.0.0.0 and max 255.255.255.255).

By leaving the list of IPs empty, all the IP Addresses will be accepted.

You can also specify the plugins that the application can perform.

If you are not able to deny a certain plugin, it means that it is always enabled for all the active applications.
@see EventAPIs::alwaysAllowed() for a better explanation.

The username and password credentials MUST follow the restrictions of the API Framework, otherwise they won't be considered as valid and the authentication will fail.

Username Requirements

• It accepts only letters (uppercase and lowercase), digits, dots (.) and underscores (_). White spaces ARE NOT accepted.
• The username length MUST be between 3 and 128 characters.

Password Requirements

• It accepts only letters (uppercase and lowercase), digits, and all these !?@#$%{}[]()_-. symbols. White spaces ARE NOT accepted.
• The password length MUST be between 8 and 128 characters.
• The password MUST contain at least one letter.
• The password MUST contain at least one number.

• ID - the ID of the log. By deleting all the existing logs, the ID will be reset.
• Created On - the creation date of the log. Hover the mouse above these values to see the detailed date.
• Content - the description of the log.
• Status - the status of the log: OK on success, ERROR on failure. Depending on your configuration, you may not be able to see successful logs.
• Application Name - the name of the application authenticated, otherwise the caller IP Address.

• ID - the ID of the banned user.
• IP Address - the IP Address from which the user is attempting to authenticate itself.
• Last Update - the last update of the record. Hover the mouse above these values to see the detailed date.
• Failure Attempts - the current number of failures made in a row (failures / max_failures). When the failures count reaches the max_failures setting, the IP Address will be banned. When an IP Address authenticates itself successfully, the failures count will be reset (only if the failures count is still lower than the max_failure amount).

The plugins are simple .PHP files that extend the methods of the EventAPIs class of the API Framework library.
All these files are placed in the directory below:

/wp-content/plugins/vikrestaurants/site/helpers/library/apislib/apis/plugins/

If you are planning to implement your own plugin, it is recommended to use the apposite hook to safely load your third-party applications. This will avoid losing your files after updating VikRestaurants to a newer version. Here's the hook link: https://vikwp.com/support/knowledge-base/vik-restaurants/hooks/api/init-framework.

You can click the icon to see a full description of the installed plugins.
The description is generated starting from the string returned by the EventAPIs::getDescription() method.

Class constructor.

@param string $username The username of the user for login.
@param string $password The password of the user for login.
@param string $ip The IP address from which the user is trying to login (default NULL).

/* fatal error : abstract class */
$user = new UserAPIs("test", "test_pwd", "127.0.0.1");
/* correct instantiation */
$user = new LoginAPIs("test", "test_pwd", "127.0.0.1");

Get the username of the user.
The username is not empty only if it is verified from the constructor.

@return string The username of the user.

@see UserAPIs::getCredentials()   Get always the provided credentials, also in failure cases.

$username = $user->getUsername();

Get the password of the user.
The password is not empty only if it is verified from the constructor.

@return string The password of the user.

@see UserAPIs::getCredentials()   Get always the provided credentials, also in failure cases.

$password = $user->getPassword();

Get the credentials of the user, also in failure cases.

@return object An object containing the credentials of the user.

$credentials = $user->getCredentials();
echo $credentials->username . ", " . $credentials->password;

Set the ID of the user after a successful login.
By setting an ID through this method, the framework assumes that the user is currently connected.

@return UserAPIs This object to support chaining.

if ($id_user = doLogin()) { // this method does not exist
	$user->assign(id_user);
}

Get the ID of the user. Return NULL in case the user is not yet connected.

@return integer The ID of the user or NULL.

if ($user->id()) {
	/* user is logged */
}

Return true if the credentials provided match the structure requirements.
When true, it is possible to proceed with the login check, otherwise it means the username and/or password are not correctly filled in (for example they have not enough characters).

 @return boolean True if the username and password are not empty (accepted).

if ($user->isConnectable()) {
	/* user can login */
}

Get the origin IP address from which the user is trying to connect.

@return string The IP address if provided, otherwise NULL.

$ip = $user->getSourceIp();

Check if the user is able to perform the event provided.

@param EventAPIs $event The event to authorise.

@return boolean True if the event can be performed, otherwise false.

@see EventAPIs

/* the event below exists, but it must be included first */
$event = new ConnectionPing('connection_ping');
if ($user->authorise($event)) {
    /* the event can be performed */
}

Class constructor.

@param integer $errcode The code identifier.
@param string $error The text description.

$err = new ErrorAPIs(404, "Not Found!");

echo $err->errcode . ", " . $err->error;

Return this object encoded in JSON format.

@return string This object in JSON.

$json = $err->toJSON();
$obj = json_decode($json);
echo $obj->errcode . ", " . $obj->error;

static

Raise the specified error and stop the flow if needed.

This method can be accessed only statically.

@param integer $errcode The code identifier.
@param string $error The text description.
@param boolean $exit True to stop the execution, otherwise false (default true).

/* the code below */
ErrorAPIs::raise(404, "Not Found!");
/* is equals to this one */
$err = ErrorAPIs::raise(404, "Not Found!", false);
echo $err->toJSON();
exit;

Class constructor.

@param boolean $status True for success response, otherwise false (default false).
@param string $content The text description of the response (default empty string).

$response = new ResponseAPIs(false, "Response Error.");
/* or */
$response = new ResponseAPIs(true);

Set the status of the response.

@param boolean $status True for success response, otherwise false.

@return ResponseAPIs This object to support chaining.

$response->setStatus(true);

Return true if the status of the response is success, otherwise false.

@return boolean True on success, otherwise false.

if ($response->isVerified()) {
    /* status is TRUE */
}

Return true if the status of the response is failure, otherwise false.

@return boolean True on failure, otherwise false.

if ($response->isError()) {
    /* status is FALSE */
}

Set the text description of the response.

@param string $content The content of the response.

@return ResponseAPIs This object to support chaining.

$response->setContent("content [1]");

Append some text to the existing description of the response.

@param string $content The content of the response.

@return ResponseAPIs This object to support chaining.

$response->setContent("content [1]")
    ->appendContent(" - content [2]");

/* content [1] - content [2] */

Prepend some text to the existing description of the response.

@param string $content The content of the response.

@return ResponseAPIs This object to support chaining.

$response->setContent("content [1]")
    ->appendContent(" - content [2]");
    ->prependContent("content [0] - ");

/* content[0] - content [1] - content [2] */

Clear the text description of the response.

@return ResponseAPIs This object to support chaining.

$response->clearContent();

Get the text description of the response.

@return string The text description of the response.

$content = $response->getContent();

Get the initial unix timestamp of the response.
The initial time is recorded during the creation (instantiation) of the response.

@return integer The initial timestamp in seconds.

$created_on = $response->createdOn();
echo date('Y-m-d H:i:d', $created_on);

Get the elapsed time (in seconds) between the current time and the initial time.

@return integer The elapsed time in seconds.

$elapsed = $response->getElapsedTime();

Class constructor.

@param string $name The name of the event.
@param mixed $options An optional configuration array/object.

/* the event below exists, but it must be included first */
$event = new ConnectionPing('connection_ping');
if ($event instanceof EventAPIs) {
    /* ConnectionPing inherits EventAPIs class */
}

Get the name of the event.

@return string The name of the event.

$name = $event->getName(); /* connection_ping */

Get the title of the event.

@return string The title of the event.

$title = $event->getTitle(); /* Connection Ping */

Get the description (in HTML) of the event.

@return string Returns an empty string. To display a description, override this method from the child class.

$desc = $event->getDescription();

Returns true if the plugin is always authorised, otherwise false.
When this value is false, the system will need to authorise the plugin through the ACL of the user.

@return boolean Always false. To always allow this plugin, override this method from the child class.

$allowed = $event->alwaysAllowed();

Perform the specified action of the event.

@param array $args Some arguments to pass to the event.
@param ResponseAPIs &$response The response object for admin (passed by reference).

@return ErrorAPIs The error occurred, if any.

@uses EventAPIs::doAction()   Executes the code written in the child class.

@see ResponseAPIs
@see ErrorAPIs

$response = new ResponseAPIs(false);
/* the event below exists, but it must be included first */
$event = new ConnectionPing('connection_ping');

$err = $event->run(array(), $response);

if ($err && $err instanceof ErrorAPIs) {
	echo $err->toJSON();
	exit;
}
echo $response->getContent();

protected

The custom action that the event has to perform. This is an abstract method that should be defined from the child class.
This method should not contain any exit or die function, otherwise the event won't be stopped properly.

On success, all the information to return to the applications should be echoed instead.

In case of failure, you can return a new ErrorAPIs instance.

@param array $args Some arguments to pass to the event.
@param ResponseAPIs &$response The response object for admin (passed by reference).

@return ErrorAPIs The error occurred, if any.

@protected Use EventAPIs::run() instead.
@abstract Implement this method in a child class to perform all the actions you need.

@see ResponseAPIs
@see ErrorAPIs

class HeadsOrTails extends EventAPIs
{
	protected function doAction(array $args, ResponseAPIs &$response)
	{
		/* 0 for tails, 1 for heads */
		$coin = rand(0, 1);

		if (!$coin) {
			/* if tails, raise error */
			$response->setContent('It is Tails!'); // error for admin
			return new ErrorAPIs(501, 'Tails!'); // error for customer
		}

		/* otherwise, display message */
		$response->setStatus(1)
			->setContent('It is Heads!'); // success message for admin

		$obj = stdClass;
		$obj->message = 'Heads!'; // success message for customer

		echo json_encode($obj);
	}
}

protected

Class constructor.

@param string $event_path The dir path containing all the plugins (default empty string).
If no event path is provided, it will be used the default one:
/wp-content/plugins/vikrestaurants/site/helpers/library/apislib/apis/plugins/

@protected Use APIs::getInstance() instead to create this class.

/* fatal error : protected method */
$api = new APIs();
/* fatal error : abstract class */
$api = APIs::getInstance();
/* correct instantiation */
$api = FrameworkAPIs::getInstance();

static

Get the instance of the APIs object. Thanks to this method, it is possible to use a single and global instance of the APIs.

This method can be accessed only statically.

@param string $event_path The dir path containing all the plugins.

@return APIs The instance of the API framework.

$api = FrameworkAPIs::getInstance('/folder/plugins/');
$path = $api->getEventPath(); /* /folder/plugins/ */
$api = FrameworkAPIs::getInstance('/fake/folder/plugins/');
$path = $api->getEventPath(); /* /folder/plugins/ (it is still the same) */

Returns true if the APIs framework is enabled and accessible.

@return boolean True if enabled, otherwise false.

if ($api->isEnabled()) {
	/* $api object can be used */
}

Returns true if the user is correctly logged.

@return boolean True if logged, otherwise false.

if ($api->isConnected()) {
	/* user is authenticated */
}

Returns the object of the logged user.

@return UserAPIs The object of the authenticated user, otherwise NULL.

@see UserAPIs

if ($user = $api->getUser()) {
	echo $user->getUsername() . ", " . $user->getPassword();
}

Disconnect the authenticated user.

@return APIs This object to support chaining.

$api->disconnect();

Returns the list of folders from which the API will load the supported application plugins.

@return array A list of folders.

@since 1.1

$folders = $api->getIncludePaths();

Replaces the include path folders with the specified ones.

@param array A list of folders to set.

@return APIs This object to support chaining.

@since 1.1

$api->setIncludePaths([$folder]);

Adds the specified folder within the list of include paths. The path will be added only if it doesn't exist yet.

@param string The folder to insert.

@return APIs This object to support chaining.

@since 1.1

$api->addIncludePath($folder);

Adds the specified folders within the list of include paths. Each path will be added only if it doesn't exist yet.

@param array The folders to insert.

@return APIs This object to support chaining.

@since 1.1

$api->addIncludePaths($folders);

Get the path of the folder containing the plugins.

@return string The plugins folder.

$path = $api->getEventPath();
/* default path is /wp-content/plugins/vikrestaurants/site/helpers/library/apislib/apis/plugins/ */

Get the object of the given plugin name.
If not specified, it returns the object of all the installed plugins.

@param string $plg_name The name of the plugin to get (default "*" means all plugins).

@return array A list containing the plugins found.

/* get a specific plugin */
$arr = $api->getPluginsList('connection_ping');
if (count($arr)) {
	echo $arr[0]->getTitle(); /* Connection Ping */
}

/* get all the installed plugins */
$arr = $api->getPluginsList();
foreach ($arr as $plugin) {
	echo $plugin->getTitle() . "\n";
}

Returns true if an error has been raised.

@return boolean True in case of error, otherwise false.

if ($api->hasError()) {
	/* an error has been thrown */
}

Get the last error caught and clean it.

@return ErrorAPIs The error object if exists, otherwise NULL.

@see ErrorAPIs

if ($api->hasError()) {
	$err = $api->getError(); /* returns an error */
	$err = $api->getError(); /* returns NULL (error cleaned)*/
}

Check if the specified key is set in the configuration.

@param string $key The configuration key to check.

@return boolean True if exists, otherwise false.

if ($api->has('apimaxfail')) {
	/* the setting exists */
}

Get the configuration value of the specified setting.

@param string $key The configuration key to check.
@param mixed $def The default value if not exists (default null).

@return mixed The configuration value if exists, otherwise the default specified value.

$max_fail = $api->get('apimaxfail', 0); /* this setting always exists */ 
var_dump($max_fail); /* an integer higher than 0 */

$something = $api->get('something', null); /* this setting does not exist by default */
var_dump($something); /* null */

Set the configuration value for the specified setting.

@param string $key The key of the configuration value to set.
@param mixed $val The configuration value to set.

@return APIs This object to support chaining.

$fake = $api->get('fake', null);
var_dump($fake); /* null */

$api->set('fake', 100);
$fake = $api->get('fake', null);
var_dump($fake); /* 100 */

Connect the specified user to the APIs framework.

In case the login fails, here is evaluated a permanent BAN.
Otherwise the MANIFEST of the user is updated and the BAN is reset.

This method can raise the following internal errors:

• 100 - Authentication Error (Generic)
• 101 - The username is empty or invalid
• 102 - The password is empty or invalid
• 103 - The username and password do not match
• 104 - The account is blocked
• 105 - The source IP is not authorised

@param UserAPIs $user The object to represent the user login.

@return boolean True if the user is accepted, otherwise false.

@see UserAPIs

$input = JFactory::getApplication()->input;

$username = $input->getString('username');
$password = $input->getString('password');

$user = new LoginAPIs($username, $password);

if (!$api->connect($user)) {
	/* user is not authenticated */
	echo $api->getError()->toJSON();
	exit;
}
/* user is authenticated */

Trigger the specified event.
Accessible only in case the user is correctly connected.

This method can raise the following internal errors:

• 100 - Authentication Error (Generic)
• 201 - The event requested does not exists
• 202 - The event requested is not valid
• 203 - The event requested is not runnable
• 204 - The event requested is not authorised
• 500 - Internal error of the plugin executed (Generic)
• xxx - A custom error raised from the plugin.

The response of the plugin is always echoed.

@param string $event The filename of the plugin to run.
@param array $args The arguments to pass within the plugin (default empty array).
@param boolean $register True to register the response, otherwise false to ignore it (default true).

@return boolean True if the plugin is executed without errors.

/* only if the user is connected */
$event_name = 'connection_ping';
$args = array();
if (!$api->trigger($event_name, $args)) {
	/* plugin error */
	echo $api->getError()->toJSON();
	exit;
}
/* successful response automatically echoed from the plugin */

Dispatch the specified event to catch the response echoed from the plugin.
Accessible only in case the user is correctly connected.

This method can raise the following internal errors:

• 100 - Authentication Error (Generic)
• 201 - The event requested does not exists
• 202 - The event requested is not valid
• 203 - The event requested is not runnable
• 204 - The event requested is not authorised
• 500 - Internal error of the plugin executed (Generic)
• xxx - A custom error raised from the plugin.

The response of the plugin is never echoed.
This method is useful to dispatch events during the execution of other plugins, in order to manipulate the response retrieved.

@param string $event The filename of the plugin to run.
@param array $args The arguments to pass within the plugin (default empty array).
@param boolean $register True to register the response, otherwise false to ignore it (default true).

@return string The response echoed from the plugin on success.

@throws Exception In case of failure, an exception is thrown.

/* only if the user is connected */
$event_name = 'connection_ping';
$args = array();

try {
	$json = $api->dispatch($event_name, $args);
} catch (Exception $e) {
	/* plugin error */
	ErrorAPIs::raise($e->getCode(), $e->getMessage()); /* echoes the error and exit */
}

/* successful response retrieved from the plugin */
echo $json;
exit;

For example, our CLIENT software needs to retrieve the rooms & tables from VikRestaurants in JSON format.

The JSON structure below seems to be appropriate for our case:

[
	{
		"id": 1,
		"name": "Room A",
		"published": 1,
		"description": "",
		"tables": [
			{
				"id": 1,
				"name": "Table A1",
				"min": 2,
				"max": 4,
				"published": 1
			},
			{
				"id": 2,
				"name": "Table A2",
				"min": 4,
				"max": 6,
				"published": 0
			}
		]
	},
	{
		"id": 2,
		"name": "Room B",
		"published": 1,
		"description": "",
		"tables": [
			{
				"id": 3,
				"name": "Table B1",
				"min": 4,
				"max": 8,
				"published": 1
			}
		]
	},
	{
		"id": 3,
		"name": "Room C",
		"published": 0,
		"description": "",
		"tables": []
	}
]

We also may consider to implement a parameter to ignore/accept the unpublished rooms and tables. 

From the configuration of VikRestaurants in the back-end, under the Applications section, we have to make sure the APIs setting is enabled.

Once the framework is enabled, the See Users List button should become visible. Click this button to see the list of the users and press the NEW button to create an Application.

Feel free to configure your application as displayed in the image below (you can ignore all the other fields).

@see API Users for further details.

It is possible to test the authentication of your app by using one of the pre-installed plugins. You can see the list of plugins by clicking the See Installed Plugins button from the Applications section of the configuration.

Find the Connection Ping plugin and press its icon to see the full description.

Insert your credentials in the username and password fields, click outside of the input to refresh the URL properly and finally click it.

 The system should open the clicked URL in a different tab of your browser. Make sure the response you get is equals to the one below.

{
	"status": 1
}

Create a new file on your local computer and rename it as:

rooms_tables.php

Copy & paste the code below into the file created previously, or download it from HERE.

<?php

// No direct access to this file
defined('ABSPATH') or die('Restricted access');

class RoomsTables extends EventAPIs
{
	// parent override
	protected function doAction(array $args, ResponseAPIs &$response)
	{

	}

	// parent override
	public function alwaysAllowed()
	{
		return false;
	}

	// parent override
	public function getDescription()
	{
		return '';
	}
}

It is MANDATORY that the filename (rooms_tables.php) and the classname (RoomsTables) follow the standard described from the EventAPIs parent class.

Access to your server via FTP (e.g. by using FileZilla) and upload the rooms_tables.php file onto the directory below:

/wp-content/plugins/vikrestaurants/site/helpers/library/apislib/apis/plugins/

IMPORTANT NOTE: it is recommended to use the apposite hook to safely load your third-party applications. This will avoid losing your files after updating VikRestaurants to a newer version. Here's the hook link: https://vikwp.com/support/knowledge-base/vik-restaurants/hooks/api/init-framework.

Visit the Plugins List from the back-end of VikRestaurants and make sure the Rooms Tables plugin is visible.

The  icon is disabled because the EventAPIs::getDescription() method that we have initially defined is returning an empty string.

To test our new empty plugin, try to launch this URL (replace the ellipsis with your domain):

.../index.php?option=com_vikrestaurants&task=apis&event=rooms_tables&username=app&password=ABCD1234

and make sure the result is matching the one below:

{
	"errcode": 500,
	"error": ""
}

We are getting an error (this is normal) because we haven't verified yet the status of the response within the EventAPIs::doAction() method.

@see ResponseAPIs::setStatus() to understand how a plugin response can be confirmed.

/* 0 to load all, 1 to load only published rooms and tables */
$published = isset($_REQUEST['published']) ? (int) $_REQUEST['published'] : 0;

SELECT `r`.`id`, `r`.`name`, `r`.`published`, `r`.`description`,
`t`.`id` AS `id_table`, `t`.`name` AS `table_name`, `t`.`min_capacity`, `t`.`max_capacity`, 
`t`.`published` AS `table_published`
FROM `#__vikrestaurants_room` AS `r`
LEFT JOIN `#__vikrestaurants_table` AS `t` ON `r`.`id`=`t`.`id_room`
WHERE `r`.`published`>=[PUBLISHED] AND `t`.`published`>=[PUBLISHED]
ORDER BY `r`.`ordering` ASC, `t`.`name` ASC;

Before to launch the query, we have to replace all the #__ occurrences with the real prefix of the database (e.g. xyz_).

It is also needed to replace the [PUBLISHED] parameter with 0 or 1 values.

The result of the query, launched from your MySQL Panel, should look like the one below.

/* get database object */
$dbo = JFactory::getDbo();

/* get empty query */
$q = $dbo->getQuery(true);

/* build query */
$q->select('`r`.`id`, `r`.`name`, `r`.`published`, `r`.`description`')
	->select('`t`.`id` AS `id_table`, `t`.`name` AS `table_name`, `t`.`min_capacity`')
	->select('`t`.`max_capacity`, `t`.`published` AS `table_published`')
	->from($dbo->qn('#__vikrestaurants_room', 'r'))
	->join('LEFT', $dbo->qn('#__vikrestaurants_table', 't') . ' ON `r`.`id`=`t`.`id_room`')
	->where('`r`.`published` >= ' . $published . ' AND `t`.`published` >= ' . $published)
	->order('`r`.`ordering` ASC, `t`.`name` ASC');

/* setup query */
$dbo->setQuery($q);
/* run query */
$dbo->execute();

/* validate result */
if ($dbo->getNumRows() == 0) {
	/* verify the response */
	$response->setStatus(1);
	/* return empty result */
	echo "[]";
	return;
}

/* get fetched rows */
$rows = $dbo->loadObjectList();

/* manipulate response */
$rooms = array();

$last_room_id = -1;

foreach ($rows as $row) {

	if ($last_room_id != $row['id']) {
		/* push room */
		$rooms[] = array(
			"id" => $row['id'],
			"name" => $row['name'],
			"published" => $row['published'],
			"description" => $row['description'],
			"tables" => array(),
		);

		/* store ID last room pushed */
		$last_room_id = $row['id'];
	}

	if (!empty($row['id_table'])) {
		/* push table in last room */
		$rooms[count($rooms)-1]['tables'][] = array(
			"id" => $row['id_table'],
			"name" => $row['table_name'],
			"min" => $row['min_capacity'],
			"max" => $row['max_capacity'],
			"published" => $row['table_published'],
		);
	}
}

/* verify the response */
$response->setStatus(1);
/* write some logs for the administrator */
$response->setContent('Fetched #' . count($rooms) . ' rooms.');

/* return fetched result */
echo json_encode($rooms);
return;

[
	{
		"id": "1",
		"name": "Main Room",
		"published": "1",
		"description": "",
		"tables": [
			{
				"id": "1",
				"name": "t1",
				"min": "2",
				"max": "2",
				"published": "1"
			},
			{
				"id": "2",
				"name": "t2",
				"min": "2",
				"max": "4",
				"published": "0"
			},
			{
				"id": "3",
				"name": "t3",
				"min": "2",
				"max": "4",
				"published": "1"
			},
			{
				"id": "4",
				"name": "t4",
				"min": "2",
				"max": "4",
				"published": "1"
			},
			{
				"id": "5",
				"name": "t5",
				"min": "2",
				"max": "4",
				"published": "1"
			},
			{
				"id": "6",
				"name": "t6",
				"min": "2",
				"max": "4",
				"published": "1"
			},
			{
				"id": "7",
				"name": "t7",
				"min": "4",
				"max": "8",
				"published": "1"
			}
		]
	},
	{
		"id": "2",
		"name": "Garden",
		"published": "1",
		"description": "",
		"tables": [
			{
				"id": "9",
				"name": "g1",
				"min": "2",
				"max": "6",
				"published": "1"
			},
			{
				"id": "10",
				"name": "g2",
				"min": "2",
				"max": "10",
				"published": "1"
			}
		]
	},
	{
		"id": "4",
		"name": "Private",
		"published": "1",
		"description": "",
		"tables": [
			{
				"id": "11",
				"name": "p1",
				"min": "2",
				"max": "20",
				"published": "1"
			}
		]
	}
]

/* define params */
$params = array(
	"event" => "rooms_tables",
	"username" => "app",
	"password" => "ABCD1234",
);

/* specify your domain URL */
$ch = curl_init('http://domain.com/index.php?option=com_vikrestaurants&task=apis');

/* configure cURL connection */
curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, http_build_query($params));
curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);

/* connect to the URL and retrieve the JSON response */
$json = curl_exec($ch);

/* evaluate error */
if ($errno = curl_errno($ch)) {
	echo "Error ($errno) : " . curl_error($ch) . "\n";
	exit;
}

/* otherwise decode the response */
$rooms = json_decode($json);

echo print_r($rooms, true) . "\n";

Something gone wrong while it was authenticating the application.
You should see this error only if you are triggering an event (via code) without the authentication, such as the example below.

FrameworkAPIs::getInstance()->trigger('connection_ping');

The username provided is empty or invalid. Make sure the connection URL contains the &username=[USERNAME] parameter.
@see also Credentials Requirements to check if your username matches the system requirements.

The password provided is empty or invalid. Make sure the connection URL contains the &password=[PASSWORD] parameter.
@see also Credentials Requirements to check if your password matches the system requirements.

The username and password do not match. Your application may not exist or the credentials may not be correct.

The account is blocked. The application you are using is blocked, you need to re-enable it from the back-end of VikRestaurants.
Even if you are seeing this error, the username and password you are using are correct.

Otherwise, the IP Address from which you are trying to connect may be banned. In this case, check the Banned List from the back-end of VikRestaurants.

@see Banned List

The IP Address from which you are trying to connect is not allowed. Make sure the list of allowed IPs for this application is empty or includes your origin address. Even if you are seeing this error, the credentials are correct.

@see Allowed IPs

The event requested does not exist. Make sure the event you are requesting is listed in the plugins folder.

 @see API Plugins Path

The event requested is not valid. Make sure the classname of the event follows the standard of the EventAPIs class.

 @see EventAPIs

The event requested is not runnable. Make sure the event you are requesting inherits correctly the EventAPIs class.

 @see EventAPIs

The event requested is not authorised. Make sure your application owns the permissions to run the event you are requesting.

 @see API Users Plugin Rules

If you are seeing this error, it means that you are correctly running the plugin but there is still something wrong.

If the error message is empty, make sure you are verifying the response within the code.

@see ResponseAPIs::setStatus()

Otherwise it means that the plugin is throwing an own error.

Any other error code you see should be considered as a custom error thrown by the plugin.
In order to understand the reason of this error, you should read the description of the plugin that you are running.

 @see API Plugins Description