Joomla Programmers Documentation

https://manual.joomla.org/docs/
Admin
Comprehensive developer documentation for building Joomla extensions including components, modules,...
Tokens:247,545
Snippets:2,972
Trust Score:10
Update:4 months ago
Show doc for...
Tokens:
Raw
### Define Install SQL File

Source: https://manual.joomla.org/docs/building-extensions/install-update/installation/manifest

Specify the SQL file for initial database setup upon extension installation using the <install> and <sql> tags. Supports multiple drivers via separate <file> elements.

```xml
<install>
    <sql>
        <file driver="mysql" charset="utf8">sql/example.install.sql</file>
    </sql>
</install>
```

--------------------------------

### Joomla Installation Script File Example

Source: https://manual.joomla.org/docs/building-extensions/modules/module-development-tutorial/step6-script-file

This script file implements the InstallerScriptInterface to handle installation, update, uninstallation, preflight checks, and postflight operations. It includes checks for minimum Joomla and PHP versions using enqueueMessage for error reporting.

```php
<?php  
defined('_JEXEC') or die;  
  
use Joomla\CMS\Factory;
use Joomla\CMS\Installer\InstallerAdapter;
use Joomla\CMS\Installer\InstallerScriptInterface;
use Joomla\CMS\Language\Text;
  
return new class () implements InstallerScriptInterface {  
  
    private string $minimumJoomla = '4.4.0';  
    private string $minimumPhp    = '7.4.0';  
  
    public function install(InstallerAdapter $adapter): bool  
    {  
        echo "mod_hello install<br>";  
        return true;  
    }  
  
    public function update(InstallerAdapter $adapter): bool  
    {  

        echo "mod_hello update<br>";  
        return true;  
    }  
  
    public function uninstall(InstallerAdapter $adapter): bool  
    {  
        echo "mod_hello uninstall<br>";  
        return true;  
    }  
  
    public function preflight(string $type, InstallerAdapter $adapter): bool  
    {  
        echo "mod_hello preflight<br>";  
          
        if (version_compare(PHP_VERSION, $this->minimumPhp, '<')) {  
            Factory::getApplication()->enqueueMessage(sprintf(Text::_('JLIB_INSTALLER_MINIMUM_PHP'), $this->minimumPhp), 'error');  
            return false;  
        }  
  
        if (version_compare(JVERSION, $this->minimumJoomla, '<')) {  
            Factory::getApplication()->enqueueMessage(sprintf(Text::_('JLIB_INSTALLER_MINIMUM_JOOMLA'), $this->minimumJoomla), 'error');  
            return false;  
        }  
  
        return true;  
    }  
  
    public function postflight(string $type, InstallerAdapter $adapter): bool  
    {  
        echo "mod_hello postflight<br>";  
        return true;  
    }  
};  

```

--------------------------------

### Joomla Installer Script Example

Source: https://manual.joomla.org/docs/building-extensions/install-update/installation/install-process

This script file implements the ServiceProviderInterface to register an installer script class. It uses the InstallerScriptTrait for pre-defined functionalities and includes custom logic for install, update, uninstall, preflight, and postflight methods.

```php
<?php  
  
use Joomla\CMS\Application\AdministratorApplication;  
use Joomla\CMS\Installer\InstallerAdapter;  
use Joomla\CMS\Installer\InstallerScriptInterface;  
use Joomla\CMS\Installer\InstallerScriptTrait;  
use Joomla\CMS\Language\Text;  
use Joomla\Database\DatabaseInterface;  
use Joomla\DI\Container;  
use Joomla\DI\ServiceProviderInterface;  
use Joomla\Filesystem\File;  
use Joomla\Filesystem\Exception\FilesystemException;  
  
// phpcs:disable PSR1.Files.SideEffects  
\defined('_JEXEC') or die;  
// phpcs:enable PSR1.Files.SideEffects  
  
return new class () implements ServiceProviderInterface {  
  public function register(Container $container)  
  {  
    $container->set(  
      InstallerScriptInterface::class,  
      new class (  
      $container->get(AdministratorApplication::class),  
      $container->get(DatabaseInterface::class)  
      ) implements InstallerScriptInterface {  
        use InstallerScriptTrait {  
            InstallerScriptTrait::preflight as iScriptTraitPre;  
            InstallerScriptTrait::postflight as iScriptTraitPost;  
        };  
  
        private AdministratorApplication $app;  
        private DatabaseInterface $db;  
  
        /**  
         * Minimum PHP version required to install the extension  
         *  
         * @var    string  
         */  
        protected $minimumPhp = '8.4';  
  
        /**  
         * Minimum Joomla! version required to install the extension  
         *  
         * @var    string  
         */  
        protected $minimumJoomla = '6.0.0';  
  
        /**  
         * A list of files to be deleted  
         *  
         * @var    array  
         */  
        protected $deleteFiles = [];  
      
        /**  
         * A list of folders to be deleted  
         *  
         * @var    array  
         */  
        protected $deleteFolders = [];  
  
        public function __construct(AdministratorApplication $app, DatabaseInterface $db)  
        {  
          $this->app = $app;  
          $this->db  = $db;  
        }  
  
        public function install(InstallerAdapter $parent): bool  
        {  
          $this->app->enqueueMessage('Successful installed.');  
  
          return true;  
        }  
  
        public function update(InstallerAdapter $parent): bool  
        {  
          $this->app->enqueueMessage('Successful updated.');  
  
          return true;  
        }  
  
        public function uninstall(InstallerAdapter $parent): bool  
        {  
          $this->app->enqueueMessage('Successful uninstalled.');  
  
          return true;  
        }  
  
        public function preflight(string $type, InstallerAdapter $parent): bool  
        {  
          // Run trait preflight code  
          $this->iScriptTraitPre();  
  
          // Your custom preflight code  
  
          // Custom Dashboard Menu Module  
          // $this->addDashboardMenuModule('example', 'example');  
  
          return true;  
        }  
  
        public function postflight(string $type, InstallerAdapter $parent): bool  
        {  
           // Run trait postflight code  
           $this->iScriptTraitPost();  
  
          // Your custom postflight code  
  
          return true;  
        }  
      }  
    );  
  }  
};  

```

--------------------------------

### Clone Joomla Manual Examples Repository

Source: https://manual.joomla.org/docs/building-extensions/components/component-examples

Use this command to clone the repository containing all Joomla component examples for local inspection.

```bash
git clone https://github.com/joomla/manual-examples.git
```

--------------------------------

### Example SQL Update Filenames

Source: https://manual.joomla.org/docs/building-extensions/install-update/installation/manifest

Illustrates the naming convention for SQL update files used during Joomla extension installation.

```text
1.0.1.sql  
1.0.2.sql  
1.0.3.sql  

```

--------------------------------

### SQL File Content Example

Source: https://manual.joomla.org/docs/building-extensions/plugins/plugin-examples/console-plugin-sqlfile

Example SQL statements for the sqlfile.sql. Includes table creation and insertion.

```sql
CREATE TABLE IF NOT EXISTS `#__temp_table` (
  `s` VARCHAR(255) NOT NULL DEFAULT '',
  `i` INT NOT NULL DEFAULT 1,
  PRIMARY KEY (`i`)
);
INSERT INTO `#__temp_table` (`s`, `i`) VALUES ('Hello', 22),('there', 23);

```

--------------------------------

### Start Local Development Server

Source: https://manual.joomla.org/docs/get-started/git/github-manual

Build and start the local development server for the Joomla! Programmers Documentation. This will typically open the documentation in your web browser.

```bash
npm run start
```

--------------------------------

### Get Database Connection and Create Query Object

Source: https://manual.joomla.org/docs/general-concepts/database/insert-data

Demonstrates how to obtain a database connection instance and create a new query object using the DatabaseInterface. This is the starting point for query chaining.

```php
use Joomla\CMS\Factory;

// When used in the component's Model
$db = $this->getDatabase();

// When used in other places
$db = Factory::getContainer()->get(\Joomla\Database\DatabaseInterface::class);

$query = $db->createQuery();

```

--------------------------------

### Basic Content Plugin Example

Source: https://manual.joomla.org/docs/building-extensions/plugins/basic-content-plugin

This is an example of how to use placeholders within an article that will be replaced by plugin logic.

```html
On my Joomla instance {sitename} the default editor is {editor}.  

```

--------------------------------

### Package XML Manifest File Example

Source: https://manual.joomla.org/docs/building-extensions/install-update/installation/package

Defines the structure and contents of a package's XML manifest file, specifying constituent extensions and installation details.

```xml
<?xml version="1.0" encoding="UTF-8" ?>  
<extension type="package" version="1.6" method="upgrade">  
    <name>Hello World Package</name>  
    <author>Hello World Package Team</author>  
    <creationDate>today</creationDate>  
    <packagename>helloworld</packagename>  
    <version>1.0.0</version>  
    <url>http://www.yoururl.com/</url>  
    <packager>Hello World Package Team</packager>  
    <packagerurl>http://www.yoururl.com/</packagerurl>  
    <description>Example package to combine multiple extensions</description>  
    <update>http://www.updateurl.com/update</update>  
    <scriptfile>pkg_script.php</scriptfile>  
    <blockChildUninstall>true</blockChildUninstall>  
    <files folder="constituents">  
        <file type="component" id="com_helloworld">com_helloworld.zip</file>  
        <file type="module" id="helloworld" client="site">mod_helloworld.zip</file>  
        <file type="library" id="helloworld">lib_helloworld.zip</file>  
        <file type="plugin" id="helloworld" group="system">plg_sys_helloworld.zip</file>  
        <file type="template" id="helloworld" client="site">tpl_helloworld.zip</file>  
    </files>  
</extension>  

```

--------------------------------

### Extension Element with Attributes

Source: https://manual.joomla.org/docs/building-extensions/install-update/installation/manifest

Example of the root '<extension>' element with 'type' and 'method' attributes. 'type' specifies the extension type, and 'method' defines the installation approach (install or upgrade).

```xml
<extension type="component" method="upgrade">
...
</extension>
```

--------------------------------

### Command Line Execution Example

Source: https://manual.joomla.org/docs/building-extensions/plugins/plugin-examples/console-plugin-sqlfile

How to execute the sql:execute-file command with a specified SQL file.

```bash
php cli/joomla.php sql:execute-file sqlfile.sql

```

--------------------------------

### Install Project Dependencies

Source: https://manual.joomla.org/docs/get-started/git/github-manual

Install all the necessary Node.js packages required for the Docusaurus application.

```bash
npm install
```

--------------------------------

### Example Query Parameters

Source: https://manual.joomla.org/docs/general-concepts/routing/build

An example of the query parameters array passed to the build method, typically including Itemid, view, id, and catid.

```php
$query = array('Itemid' => '13', 'view' => 'article', 'id' => '21',  catid => '50', ...)

```

--------------------------------

### Specific Tour Uninstall (MySQL Example)

Source: https://manual.joomla.org/docs/general-concepts/guided-tours/create-whatsnewtour

Example of a more specific SQL query to uninstall tours by UID, preventing accidental removal.

```sql
SELECT `id` FROM `#__guidedtours` WHERE `uid` IN ('joomla-whatsnew-5.2', 'joomla-whatsnew-5.3', 'joomla-whatsnew-5.4')  

```

--------------------------------

### Getting Registry Values with a Default

Source: https://manual.joomla.org/docs/general-concepts/registry

Demonstrates using the get() method with a default value, which is returned if the specified key does not exist or is null.

```php
$d = $registry->get("d", "a default string");
```

--------------------------------

### Install npm Dependencies and Build Assets

Source: https://manual.joomla.org/docs/get-started/git/github-joomla-cms

Install Node.js dependencies and compile JavaScript and CSS files for the Joomla! CMS development branch using npm.

```bash
npm ci
```

--------------------------------

### Get Category Nodes

Source: https://manual.joomla.org/docs/general-concepts/categories/using-categories-api

Instantiate the Categories API, get the root node, and then retrieve its direct children. This is useful for starting to navigate the category tree.

```php
use Joomla\CMS\Categories\Categories; 
use Joomla\CMS\Categories\CategoryNode; 

$categories = Categories::getInstance("content"); 
$rootNode = $categories->get();     
$categoryNodes = $rootNode->getChildren();  

```

--------------------------------

### Basic Joomla Framework Script

Source: https://manual.joomla.org/docs/building-extensions/custom-script/basic-script

This script demonstrates how to boot the Joomla framework, instantiate the SiteApplication, and perform a simple database query. It includes essential setup for using Joomla APIs in a custom script.

```php
<?php  
  
use Joomla\CMS\Factory;
use Joomla\CMS\Session\Session;
use Joomla\CMS\Plugin\PluginHelper;
use Joomla\CMS\Language\Language;
use Joomla\CMS\Log\Log;
  
define('_JEXEC', 1);  
  
// define your preferred error reporting levels  
error_reporting(E_ALL);
ini_set('display_errors', 1);
  
// the line below assumes that this PHP script file is in a directory below the root of the joomla instance, eg in <root>/cli  
define('JPATH_BASE', realpath(dirname(__FILE__).'/..'));  
  
require_once JPATH_BASE . '/includes/defines.php';  
require_once JPATH_BASE . '/includes/framework.php';  
  
// Boot the DI container - this will load in the classes in libraries/src/Service/Provider/  
$container = \Joomla\CMS\Factory::getContainer();  
  
// We need to set up an alias to get the Session dependency from the DIC  
$container->alias(\Joomla\Session\SessionInterface::class, 'session.web.site');  
  
// Instantiate the application.  
$app = $container->get(\Joomla\CMS\Application\SiteApplication::class);
  
// Set what gets returned from Factory::getApplication()  
\Joomla\CMS\Factory::$application = $app;
  
// Optional - This is so that Joomla can find classes relating to extensions  
$app->createExtensionNamespaceMap();  
  
// Optional - Set up basic logging framework  
if ($app->get('log_everything')) {  
    Log::addLogger(['text_file' => 'everything.php']);
}
Log::add('logging initialised ok', Log::DEBUG, 'script-debug');  
  
// Optional - set up the language and load the joomla library text strings - select your preferred language  
$lang = Language::getInstance("en-GB");  
$app->loadLanguage($lang);
$app->getLanguage()->load('lib_joomla', JPATH_ADMINISTRATOR);
  
// Write below here what you want your script to do  
$db = $container->get(Joomla\Database\DatabaseInterface::class);
  
$query = $db->createQuery();  
$query->select('count(*)')  
    ->from('#__content');  
  
$db->setQuery($query);  
  
$count = $db->loadResult();  
  
echo "<h2>{$count} articles found</h2>";  

```

--------------------------------

### Module Entry Point Files

Source: https://manual.joomla.org/docs/building-extensions/modules/module-examples/basic-module

Specifies the folders containing the module's files, including the 'services' folder with the 'module="mod_example"' attribute to define the entry point.

```xml
<files>
      <folder module="mod_example">services</folder>
      <folder>src</folder>
  </files>
```

--------------------------------

### Uploaded File Information Structure

Source: https://manual.joomla.org/docs/general-concepts/input

Example structure of the array returned by $input->files->get('jform1'), detailing properties of uploaded files.

```php
Array  
(
    [test] => Array  
        (
            [0] => Array  
                (
                    [name] => youtube_icon.png      // filename on local system  
                    [type] => image/png             // mime type  
                    [tmp_name] => /tmp/phpXoIpSD    // name given by PHP in tmp directory  
                    [error] => 0                    // should be 0 for no error  
                    [size] => 34409                 // in bytes  
                )
  
            [1] => Array  
                (
                    [name] => Younger_Son_2.jpg  
                    [type] => image/jpeg  
                    [tmp_name] => /tmp/phpWDE7ye  
                    [error] => 0  
                    [size] => 99529  
                )
        )
)


```

--------------------------------

### Create Test SQL File

Source: https://manual.joomla.org/docs/building-extensions/plugins/plugin-examples/console-plugin-sqlfile

Example SQL statements to create a table and insert data, saved in a .sql file for execution by the plugin.

```sql
CREATE TABLE IF NOT EXISTS `#__temp_table` (  
  `s` VARCHAR(255) NOT NULL DEFAULT '',  
  `i` INT NOT NULL DEFAULT 1,  
  PRIMARY KEY (`i`)  
);
INSERT INTO `#__temp_table` (`s`, `i`) VALUES ('Hello', 22),('there', 23);  

```

--------------------------------

### Get Menu Items by Menu Type and Level

Source: https://manual.joomla.org/docs/general-concepts/menus-menuitems

Retrieves menu items filtered by both 'menutype' and 'level'. This example fetches items from the 'mainmenu' that are at level 1 or 2.

```php
$mainmenuItems = $sitemenu->getItems(array('menutype','level'), array('mainmenu',array("1","2")));

```

--------------------------------

### Plugin Files Section Example (No Services)

Source: https://manual.joomla.org/docs/building-extensions/install-update/installation/manifest

Defines the files for a plugin, specifying a main PHP file. Use this when your plugin does not yet use a services/provider.php file.

```xml
<files>
    <filename plugin="example">example.php</folder>
    ...
</files>
```

--------------------------------

### Accessing a Custom PHP Script via Browser

Source: https://manual.joomla.org/docs/building-extensions/custom-script

Example URL for accessing a custom PHP script (e.g., myscript.php) placed in the root folder of a Joomla installation.

```plaintext
https://example.com/myscript.php
```

--------------------------------

### Module Files Section Example (No Services)

Source: https://manual.joomla.org/docs/building-extensions/install-update/installation/manifest

Defines the files for a module, specifying a main PHP file. Use this when your module does not yet use a services/provider.php file.

```xml
<files>
    <filename module="mod_example">mod_example.php</folder>
    ...
</files>
```

--------------------------------

### Capturing the onAfterInitialise Event

Source: https://manual.joomla.org/docs/building-extensions/plugins/plugin-events/application

Example of a system plugin method to capture the onAfterInitialise event and access the application instance.

```php
use Joomla\CMS\Event\Application\AfterInitialiseEvent;  
  
public function onAfterInitialise(AfterInitialiseEvent $event): void  
{  
    $app = $event->getApplication();   
}
```

--------------------------------

### Initialize a New Git Repository

Source: https://manual.joomla.org/docs/get-started/git/git-basics

Use this command to create a new, empty Git repository in the current directory. This sets up the necessary .git folder to start tracking changes.

```bash
git init .
```

--------------------------------

### Accessing GET and POST Properties

Source: https://manual.joomla.org/docs/general-concepts/input

Use the 'get' and 'post' properties to access HTTP GET and POST parameters respectively.

```php
$input->get     // property to retrieve GET parameters  
$input->post    // property to retrieve POST parameters  
```

--------------------------------

### Retrieving a Specific GET Parameter

Source: https://manual.joomla.org/docs/general-concepts/input

Retrieve a GET parameter 'p1' using the get() method. The 'CMD' filter is applied by default.

```php
$value = $input->get->get('p1');  
```

--------------------------------

### Display Help for Hello World Joomla Console Command

Source: https://manual.joomla.org/docs/building-extensions/plugins/plugin-examples/basic-console-plugin-helloworld

Use this command to display the help text for the 'hello:world' console command, including its description and usage instructions.

```bash
php cli/joomla.php hello:world -h  

```

--------------------------------

### Get Parameter with Filter

Source: https://manual.joomla.org/docs/general-concepts/input

Retrieve a specific GET, POST, or routing parameter using the get() method. Specify a default value and a filter for sanitization. The default filter is 'cmd'.

```php
$val = $input->get(param_name, default_value, filter);
```

--------------------------------

### Initialize HTTP Client and Variables

Source: https://manual.joomla.org/docs/general-concepts/webservices

Sets up the necessary HTTP client and defines variables for API requests, including the base URL and API token. Ensure your API token is stored securely.

```php
// Before passing the HTTP METHOD to CURL  
use Joomla\Http\HttpFactory;
use Joomla\Uri\Uri;

$http = (new HttpFactory())->getAvailableDriver();
$url   = 'https://example.org/api/index.php/v1';
$uri  = new Uri($url);

// Put your Joomla! Api token in a safe place, for example a password manager or a vault storing secrets  
// We should not use environment variables to store secrets.  
// Here is why: https://www.trendmicro.com/en_us/research/22/h/analyzing-hidden-danger-of-environment-variables-for-keeping-secrets.html  

$token = '';

```

--------------------------------

### Update Installer Result and Message in onInstallerAfterInstaller

Source: https://manual.joomla.org/docs/building-extensions/plugins/plugin-events/installer

Use this event to update the installer result and message after an extension has been installed. Setting the message will override the default Joomla success or failure message.

```php
public function onInstallerAfterInstaller(
    Joomla\CMS\Event\Installer\AfterInstallerEvent $event
): void {
    $event->updateInstallerResult(false);
    $event->updateMessage("Some failure message");
}
```

--------------------------------

### Plugin Files Section Example

Source: https://manual.joomla.org/docs/building-extensions/install-update/installation/manifest

Defines the files for a plugin, specifying a folder or a main PHP file. Use this when your plugin has a services/provider.php file.

```xml
<files>
    <folder plugin="example">services</folder>
    ...
</files>
```

--------------------------------

### Example SEF URL Output

Source: https://manual.joomla.org/docs/general-concepts/routing/build

An example of a generated SEF URL after the routing process.

```http
http://localhost/joom/index.php/en/mountains/50-alps/21-mont-blanc  

```

--------------------------------

### Listing Available Console Applications

Source: https://manual.joomla.org/docs/building-extensions/plugins/plugin-examples/basic-console-plugin-helloworld

Demonstrates how to list all available console applications on a Joomla instance from the command line.

```bash
php cli/joomla.php  
```

--------------------------------

### Retrieving a GET Parameter with a Specific Filter

Source: https://manual.joomla.org/docs/general-concepts/input

Retrieve a GET parameter 'p1' and apply an 'INT' filter.

```php
$value = $input->get->get('p1', 0, "int");  
```

--------------------------------

### Display Help Text for SQL File Command

Source: https://manual.joomla.org/docs/building-extensions/plugins/plugin-examples/console-plugin-sqlfile

Shows how to display help text for the 'sql:execute-file' command, which includes information about its arguments and options. This is useful for users to understand how to use the command.

```bash
php cli/joomla.cli sql:execute-file -h
```

--------------------------------

### Navigate to Local Sites Directory

Source: https://manual.joomla.org/docs/get-started/git/github-joomla-cms

Before cloning the repository, change your current directory to your local sites folder where web projects are stored.

```bash
cd ~/
Sites
```

--------------------------------

### Retrieving an object using get()

Source: https://manual.joomla.org/docs/general-concepts/input

Illustrates how to retrieve an object using the get() method with default filter and value.

```php
$obj = $input->get(param_name, null, null);
```

--------------------------------

### Using get() with INT filter

Source: https://manual.joomla.org/docs/general-concepts/input

Demonstrates how to use the get() method with the INT filter to sanitize integer input.

```php
$input->get('memberId', 0, 'INT');
```

--------------------------------

### Helloworld Console Plugin Service Provider (provider.php)

Source: https://manual.joomla.org/docs/building-extensions/plugins/plugin-examples/basic-console-plugin-helloworld

This file registers the plugin with the Dependency Injection container. It sets up the HelloworldConsolePlugin class, injecting the dispatcher and application, and making it available for use.

```php
<?php  
defined('_JEXEC') or die;  
  
use Joomla\CMS\Extension\PluginInterface;  
use Joomla\CMS\Plugin\PluginHelper;  
use Joomla\DI\Container;  
use Joomla\DI\ServiceProviderInterface;  
use Joomla\Event\DispatcherInterface;  
use Joomla\CMS\Factory;  
use My\Plugin\Console\Helloworld\Extension\HelloworldConsolePlugin;  
  
return new class implements ServiceProviderInterface  
{  
    /**  
     * Registers the service provider with a DI container.  
     *  
     * @param   Container  $container  The DI container.  
     *  
     * @return  void  
     *  
     * @since   4.2.0  
     */  
    public function register(Container $container)  
    {  
        $container->set(  
            PluginInterface::class,  
            function (Container $container) {  
                $dispatcher = $container->get(DispatcherInterface::class);  
                $plugin     = new HelloworldConsolePlugin(  
                    $dispatcher,  
                    (array) PluginHelper::getPlugin('console', 'helloworld')  
                );  
                $plugin->setApplication(Factory::getApplication());  
  
                return $plugin;  
            }  
        );  
    }  
};  

```

--------------------------------

### Using get() with STRING filter

Source: https://manual.joomla.org/docs/general-concepts/input

Demonstrates how to use the get() method with the STRING filter to sanitize string input.

```php
$input->get('name', '', 'STRING');
```

--------------------------------

### Bootstrapping a Module Extension

Source: https://manual.joomla.org/docs/general-concepts/extension-and-dispatcher/extension-dispatcher-module

Instantiates a module extension class. Use this to get a module instance by its name and the application name (site or administrator).

```php
$module = $app->bootModule($moduleName, $applicationName);
```

--------------------------------

### Install Composer Dependencies

Source: https://manual.joomla.org/docs/get-started/git/github-joomla-cms

Install the necessary PHP dependencies for the Joomla! CMS development branch using Composer.

```bash
composer install
```

--------------------------------

### Complete Menu Entry with Dashboard, Submenu, and Quicktasks

Source: https://manual.joomla.org/docs/building-extensions/components/quicktasklink

An example demonstrating a complete Joomla menu entry including a dashboard link, submenu items, and quicktask links with both aliased and Font Awesome icons.

```xml
<menu>
    COM_EXAMPLE
    <params>
        <dashboard>example</dashboard>
    </params>
</menu>
<submenu>
    <menu link="option=com_example">
        COM_EXAMPLE_MENU
        <params>
            <menu-quicktask-title>COM_EXAMPLE_MENU_QUICKTASK_TITLE</menu-quicktask-title>
            <menu-quicktask>index.php?option=com_example&amp;view=example&amp;layout=edit</menu-quicktask>
        </params>
    </menu>
    <menu link="option=com_categories&amp;extension=com_example">
        COM_EXAMPLE_MENU_CATEGORIES
        <params>
            <menu-quicktask-title>COM_EXAMPLE_MENU_CATEGORIES</menu-quicktask-title>
            <menu-quicktask-icon>fas fa-person-hiking</menu-quicktask-icon>
            <menu-quicktask>index.php?option=com_categories&amp;view=category&amp;layout=edit&amp;extension=com_example</menu-quicktask>
        </params>
    </menu>
    <menu link="option=com_fields&amp;view=fields&amp;context=com_example,example">COM_EXAMPLE_MENU_FIELDS</menu>
    <menu link="option=com_fields&amp;view=groups&amp;context=com_example,example">COM_EXAMPLE_MENU_FIELDS_GROUP</menu>
</submenu>
```

--------------------------------

### Manage Presets with WebAssetManager in PHP

Source: https://manual.joomla.org/docs/general-concepts/web-asset-manager

Demonstrates how to use the WebAssetManager in PHP to attach, disable, register, and register-and-use presets. Includes examples for attaching all items from a preset and disabling a preset.

```php
$wa = Factory::getApplication()->getDocument()->getWebAssetManager();

// Attach all items from foobar preset to the document
$wa->usePreset('foobar');

// Disable all items from foobar preset from being attached
$wa->disablePreset('foobar');

// Register custom item without json definition
$wa->registerPreset('bar', '', [], [], ['core#script', 'bar#script']);

// And use it later
$wa->usePreset('bar');

// Register and attach a custom item in one run
$wa->registerAndUsePreset('bar','', [], [], ['core#script', 'bar#script']);
```

--------------------------------

### JavaScript Object Output Example

Source: https://manual.joomla.org/docs/general-concepts/javascript/adding-javascript

This is an example of the JavaScript Object structure that will be outputted to the browser console when retrieving options.

```javascript
{alpha: 1, beta: "test", gamma: null}

```

--------------------------------

### Retrieving All GET Parameters

Source: https://manual.joomla.org/docs/general-concepts/input

Retrieve all GET parameters as an associative array. Values are filtered using the 'STRING' filter by default.

```php
$value = $input->get->getArray();  
```

--------------------------------

### Executing a Specific Console Command

Source: https://manual.joomla.org/docs/building-extensions/plugins/plugin-examples/basic-console-plugin-helloworld

Shows how to execute a specific console command, in this case, the 'hello:world' command, from the Joomla CLI.

```bash
php cli/joomla.php hello:world  
```

--------------------------------

### API Response Example

Source: https://manual.joomla.org/docs/web-services-api/json-response-format

Example response received when making a request to the API endpoint after implementing the test code in displayModule.

```text
string(73)"Carlitorweb\Component\Vapi\Api\Controller\ModuleController::displayModule"
```

--------------------------------

### Get Help for SQL Execute File Command

Source: https://manual.joomla.org/docs/building-extensions/plugins/plugin-examples/console-plugin-sqlfile

View detailed help information for the sql:execute-file command, including its arguments and options.

```bash
php cli/joomla.php sql:execute-file -h  

```

--------------------------------

### SMTP Server Rejection Example

Source: https://manual.joomla.org/docs/general-concepts/mail

An example of an SMTP server rejection message indicating potential spam or phishing content.

```text
550-We're sorry, but we can't send your email.  Either the subject matter, a link, or an attachment potentially contains  
550 spam, or phishing or malware.  Please check or edit your message and try sending it again.  


```

--------------------------------

### Module Files Section Example

Source: https://manual.joomla.org/docs/building-extensions/install-update/installation/manifest

Defines the files for a module, specifying a folder or a main PHP file. Use this when your module has a services/provider.php file.

```xml
<files>
    <folder module="mod_example">services</folder>
    ...
</files>
```

--------------------------------

### Get Joomla Mail Instance via MailerFactoryAwareTrait

Source: https://manual.joomla.org/docs/general-concepts/mail

In a Controller or Model, use the MailerFactoryAwareTrait to get the MailerFactory and create a Mail instance.

```php
use Joomla\CMS\Factory;
use Joomla\CMS\Mail\MailerFactoryAwareTrait;
use Joomla\CMS\Mail\MailerFactoryAwareInterface;

class MyController extends ... implements MailerFactoryAwareInterface  
{
    use MailerFactoryAwareTrait;

    public function sendMail()
    {
        $mailer = $this->getMailerFactory()->createMailer();
        ...


```

--------------------------------

### Build Static Pages

Source: https://manual.joomla.org/docs/get-started/git/github-manual

Run this command to build the static HTML pages of the documentation. This helps identify issues like broken links or invalid content before submitting a pull request.

```bash
$ npm run build
```

--------------------------------

### Example JSON Response

Source: https://manual.joomla.org/docs/web-services-api/json-response-format

This is an example of the JSON output received when making a request to the API endpoint. It shows the structure of the data returned.

```json
string(49) "Joomla\Component\Content\Site\Model\ArticlesModel"  
```

--------------------------------

### Specifying Plugin/Module Entry Points

Source: https://manual.joomla.org/docs/building-extensions/install-update/installation/manifest

For plugins and modules, identify the entry point file or services folder. Use 'module' or 'plugin' attributes to specify the extension type.

```xml
<folder module="mod_example">services</folder>
or
<folder plugin="example">services</folder>
```

```xml
<filename module="mod_example">mod_example.php</folder>
or
<filename plugin="example">example.php</folder>
```

--------------------------------

### Navigate to Cloned Repository

Source: https://manual.joomla.org/docs/get-started/git/github-manual

Change the current directory into the newly cloned 'Manual' repository folder.

```bash
cd Manual
```

--------------------------------

### Joomla Dialog Initialization and Usage

Source: https://manual.joomla.org/docs/general-concepts/javascript/js-library/joomla-dialog

Demonstrates how to initialize a Joomla Dialog instance with various properties and how to use its methods like show(), addEventListener(), and the static methods alert() and confirm().

```APIDOC
## Joomla Dialog Script

### Description

The Joomla Dialog module allows for the display of various popup windows. You can use it by including `$wa->useScript('joomla.dialog')` and optionally `$wa->useScript('joomla.dialog-autocreate')` for automatic button binding.

### Usage

**Initialization with Properties:**

Properties can be set either in the constructor or as instance properties before rendering.

```javascript
// Using constructor
const dialog = new JoomlaDialog({
  textHeader: 'The header',
  popupContent: '<p class="p-3">Popup content text</p>',
  popupType: 'inline', // Supported types: 'inline', 'iframe', 'image', 'ajax'
  src: '', // Source path for iframe, image, ajax, or CSS selector for inline
  cancelable: true, // Default: true
  textClose: 'Close',
  iconHeader: 'fa fa-info-circle',
  width: '500px',
  height: '300px',
  popupTemplate: '', // String or HTMLTemplateElement
  preferredParent: null, // String, HTMLElement, or null
  popupButtons: [
    { label: 'Yes', onClick: () => dialog.destroy() },
    { label: 'No', onClick: () => dialog.destroy(), className: 'btn btn-outline-danger ms-2' },
    { label: 'Click me', onClick: () => dialog.destroy(), location: 'header' }
  ],
  className: 'my-custom-dialog',
  data: { fooBar: 1 } // Example for data-foo-bar="1"
});

// Using instance properties
const dialogInstance = new JoomlaDialog();
dialogInstance.textHeader = 'The header';
dialogInstance.popupContent = '<p class="p-3">Popup content text</p>';

// Showing the dialog
dialog.show();
dialogInstance.show();
```

**Methods:**

- `show()`: Displays the dialog. Appends to DOM if not already present.
- `close()`: Closes the dialog.
- `destroy()`: Destroys the dialog.
- `getBody()`: Returns the dialog body element.
- `getBodyContent()`: Returns the content element (popupContent, iframe, or image).
- `getHeader()`: Returns the header part of the dialog.
- `getFooter()`: Returns the footer part of the dialog.

**Static Methods:**

- `JoomlaDialog.alert(bodytext, headertext)`: Shows a text dialog with an "OK" button. Returns a Promise that resolves when the dialog is closed.
- `JoomlaDialog.confirm(bodytext, headertext)`: Shows a text dialog with "Yes/No" buttons. Returns a Promise that resolves with `true` or `false` based on user selection.
  * The `headertext` parameter is optional and defaults to "Info".

```javascript
// Example for alert
JoomlaDialog.alert('This is an alert message', 'Alert Title').then(result => {
  console.log('Alert closed');
});

// Example for confirm
JoomlaDialog.confirm('Are you sure?', 'Confirmation').then(response => {
  if (response) {
    console.log('User confirmed');
  } else {
    console.log('User cancelled');
  }
});
```

**Events:**

- `joomla-dialog:open`: Fired when the dialog is opened.
- `joomla-dialog:close`: Fired when the dialog is closed.
- `joomla-dialog:load`: Fired when the dialog content finishes loading.

```javascript
const dialogWithEvents = new JoomlaDialog({
  popupContent: '<p class="p-3">Popup content text</p>'
});

dialogWithEvents.addEventListener('joomla-dialog:open', () => {
    console.log('Dialog is opened!');
});

dialogWithEvents.addEventListener('joomla-dialog:close', () => {
    console.log('Dialog is closed!');
});

dialogWithEvents.addEventListener('joomla-dialog:load', () => {
    console.log('Dialog content is loaded!');
});

dialogWithEvents.show();
```
```

--------------------------------

### GET - Retrieve all articles from a Category

Source: https://manual.joomla.org/docs/general-concepts/webservices

Retrieves a list of articles from a specific category using a GET request. Allows filtering by category ID.

```APIDOC
## GET /content/articles?filter[category]={categoryId}

### Description
Retrieves a list of articles filtered by category.

### Method
GET

### Endpoint
/content/articles?filter[category]={categoryId}

### Parameters
#### Query Parameters
- **filter[category]** (integer) - Required - The ID of the category to filter articles by.

### Request Example
(No explicit request body example provided for GET requests in source)

### Response
#### Success Response (200)
- A list of articles matching the specified category (structure not specified in source).

#### Response Example
(Response structure not specified in source)
```

--------------------------------

### Example SEF URL Segments

Source: https://manual.joomla.org/docs/general-concepts/routing/build

An example of the final SEF URL segments, including a prefix segment, category ID-alias, and item ID-alias.

```http
/mountains/50-alps/21-mont-blanc

```

--------------------------------

### Constructed Download Key Query

Source: https://manual.joomla.org/docs/building-extensions/install-update/installation/manifest

This example shows the resulting query string appended to the download URL when the dlid tag is used with a download key.

```text
dlid=KEY&amp;dummy=my.zip
```

--------------------------------

### Boot Component Extension

Source: https://manual.joomla.org/docs/general-concepts/extension-and-dispatcher/extension-component

Call the boot function on the Extension instance, passing your component's Dependency Injection Container. This is an opportunity to set up classes or save a reference to the DIC.

```php
$extension->boot($container);
```

--------------------------------

### Update Package in onInstallerBeforeInstaller

Source: https://manual.joomla.org/docs/building-extensions/plugins/plugin-events/installer

Use this event to update the package details before installation begins. This allows you to override the administrator's selection for the package to be installed.

```php
public function onInstallerBeforeInstaller(
    Joomla\CMS\Event\Installer\BeforeInstallerEvent $event
): void {
    $newpkg = array("dir" => $pathToExtensionDirectory, "type" => "plugin", "extractdir" => null, "packagefile" => null);
    $event->updatePackage($newpkg);
}
```

--------------------------------

### Module Language Key Example

Source: https://manual.joomla.org/docs/general-concepts/multilingual/language-files

Shows how to define a language key for a module's button label, following the established naming conventions.

```ini
MOD_MYNEWS_LEARN_MORE_BTN_LABEL="Learn more"
```

--------------------------------

### Add Menu Module to Dashboard via Install Script

Source: https://manual.joomla.org/docs/general-concepts/dashboard

Adds a menu preset to the component's dashboard during installation using the InstallerScript API.

```javascript
// Add menu module to dashboard   
    $this->addDashboardMenu('example', 'example');
```

--------------------------------

### Get Dispatcher and Helper Instances

Source: https://manual.joomla.org/docs/building-extensions/modules/module-development-tutorial/step8-dependency-injection

Illustrates how to obtain Dispatcher and Helper class instances using their respective factory classes within the Extension class.

```php
public function getDispatcher(...) {  
    $dispatcher = $this->dispatcherFactory->createDispatcher(...);  
}  
public function getHelper(...) {  
    $helper = $this->helperFactory->getHelper(...);  
}  
```

--------------------------------

### Create Table Instance via Bootstrapped Component

Source: https://manual.joomla.org/docs/general-concepts/dependency-injection/di-issues

This method demonstrates how to create a Table instance for a specific component (e.g., 'content') by bootstrapping the component and accessing its MVCFactory.

```php
Factory::getApplication()->bootComponent('content')->getMVCFactory()->createTable($name, $prefix, $config);
```

--------------------------------

### Get Specific Menu Item by ID

Source: https://manual.joomla.org/docs/general-concepts/menus-menuitems

Retrieves a specific menu item using its ID. This is often used to get the default menu item for a language.

```php
$menuitem = $sitemenu->getItem($itemid);
```

--------------------------------

### Registering and Using a Script with Dependencies

Source: https://manual.joomla.org/docs/general-concepts/web-asset-manager

Register a new script asset and immediately enable it for use, specifying dependencies. The asset will be loaded if it exists and its dependencies are met.

```php
$wa->registerAndUseScript('bar', 'com_foobar/bar.js', [], [], ['core', 'foobar']);
```

--------------------------------

### GET - Retrieve Articles by Category using cURL

Source: https://manual.joomla.org/docs/general-concepts/webservices

Retrieves all articles belonging to a specific category using a GET request with cURL. Filters results by category ID.

```php
$categoryId = 2; // Joomla's default "Uncategorized" Category  
  
  
// HTTP request headers  
$headers = [  
'Accept: application/vnd.api+json',  
'Content-Type: application/json',  
sprintf('X-Joomla-Token: %s', trim($token)),  
];  
  
curl_setopt_array($curl, [  
		CURLOPT_URL            => sprintf('%s/content/articles?filter[category]=%d',$url,$categoryId),  
		CURLOPT_RETURNTRANSFER => true,  
		CURLOPT_ENCODING       => 'utf-8',  
		CURLOPT_MAXREDIRS      => 10,  
		CURLOPT_TIMEOUT        => 30,  
		CURLOPT_FOLLOWLOCATION => true,  
		CURLOPT_HTTP_VERSION   => CURL_HTTP_VERSION_2TLS,  
		CURLOPT_CUSTOMREQUEST  => 'GET',  
		CURLOPT_HTTPHEADER     => $headers,  
	]  
);  
  
$response = curl_exec($curl);  
curl_close($curl);  
echo $response;  


```
Tokens:
Raw