Actions

API16

JInstallerPlugin/install

From Joomla! Documentation

< API16:JInstallerPlugin
Replacement filing cabinet.png
This Namespace has been archived - Please Do Not Edit or Create Pages in this namespace. Pages contain information for a Joomla! version which is no longer supported. It exists only as a historical reference, will not be improved and its content may be incomplete.

Contents

Description

Custom install method

[<! removed edit link to red link >]

<! removed transcluded page call, red link never existed >

Syntax

install()


Returns

boolean True on success

Defined in

libraries/joomla/installer/adapters/plugin.php

Importing

jimport( 'joomla.installer.adapters.plugin' );

Source Body

public function install()
{
        // Get a database connector object
        $db = &$this->parent->getDbo();
 
        // Get the extension manifest object
        $this->manifest = $this->parent->getManifest();
 
        $xml = $this->manifest;
 
        // Set the extensions name
        $name = (string)$xml->name;
        $name = JFilterInput::getInstance()->clean($name, 'string');
        $this->set('name', $name);
 
        // Get the component description
        $description = (string)$xml->description;
        if ($description) {
                $this->parent->set('message', JText::_($description));
        }
        else {
                $this->parent->set('message', '');
        }
 
        /*
         * Backward Compatability
         * @todo Deprecate in future version
         */
        $type = (string)$xml->attributes()->type;
 
        // Set the installation path
        if (count($xml->files->children()))
        {
                foreach ($xml->files->children() as $file)
                {
                        if ((string)$file->attributes()->$type)
                        {
                                $element = (string)$file->attributes()->$type;
                                break;
                        }
                }
        }
        $group = (string)$xml->attributes()->group;
        if (!empty ($element) && !empty($group)) {
                $this->parent->setPath('extension_root', JPATH_ROOT.DS.'plugins'.DS.$group.DS.$element);
        }
        else
        {
                $this->parent->abort(JText::_('Plugin').' '.JText::_($this->route).': '.JText::_('No plugin file specified'));
                return false;
        }
 
 
        /*
         * Check if we should enable overwrite settings
         */
        // Check to see if a plugin by the same name is already installed
        $query = 'SELECT `extension_id`' .
                        ' FROM `#__extensions`' .
                        ' WHERE folder = '.$db->Quote($group) .
                        ' AND element = '.$db->Quote($element);
        $db->setQuery($query);
        try {
                $db->Query();
        }
        catch(JException $e)
        {
                // Install failed, roll back changes
                $this->parent->abort(JText::_('Plugin').' '.JText::_($this->route).': '.$db->stderr(true));
                return false;
        }
        $id = $db->loadResult();
 
        // if its on the fs...
        if (file_exists($this->parent->getPath('extension_root')) && (!$this->parent->getOverwrite() || $this->parent->getUpgrade()))
        {
                $updateElement = $xml->update;
                // upgrade manually set
                // update function available
                // update tag detected
                if ($this->parent->getUpgrade() || ($this->parent->manifestClass && method_exists($this->parent->manifestClass,'update')) || is_a($updateElement, 'JXMLElement'))
                {
                        // force these one
                        $this->parent->setOverwrite(true);
                        $this->parent->setUpgrade(true);
                        if ($id) { // if there is a matching extension mark this as an update; semantics really
                                $this->route = 'Update';
                        }
                }
                else if (!$this->parent->getOverwrite())
                {
                        // overwrite is set
                        // we didn't have overwrite set, find an udpate function or find an update tag so lets call it safe
                        $this->parent->abort(JText::_('Plugin').' '.JText::_($this->route).': '.JText::_('Another extension is already using directory').': "'.$this->parent->getPath('extension_root').'"');
                        return false;
                }
        }
 
        // If there is an manifest class file, lets load it; we'll copy it later (don't have dest yet)
        if ((string)$xml->scriptfile)
        {
                $manifestScript = (string)$xml->scriptfile;
                $manifestScriptFile = $this->parent->getPath('source').DS.$manifestScript;
                if (is_file($manifestScriptFile))
                {
                        // load the file
                        include_once $manifestScriptFile;
                }
                // Set the class name
                $classname = 'plg'.$group.$element.'InstallerScript';
                if (class_exists($classname))
                {
                        // create a new instance
                        $this->parent->manifestClass = new $classname($this);
                        // and set this so we can copy it later
                        $this->set('manifest_script', $manifestScript);
                        // Note: if we don't find the class, don't bother to copy the file
                }
        }
 
        // run preflight if possible (since we know we're not an update)
        ob_start();
        ob_implicit_flush(false);
        if ($this->parent->manifestClass && method_exists($this->parent->manifestClass,'preflight')) {
                $this->parent->manifestClass->preflight($this->route, $this);
        }
        $msg = ob_get_contents(); // create msg object; first use here
        ob_end_clean();
 
        // If the plugin directory does not exist, lets create it
        $created = false;
        if (!file_exists($this->parent->getPath('extension_root')))
        {
                if (!$created = JFolder::create($this->parent->getPath('extension_root')))
                {
                        $this->parent->abort(JText::_('Plugin').' '.JText::_($this->route).': '.JText::_('FAILED_TO_CREATE_DIRECTORY').': "'.$this->parent->getPath('extension_root').'"');
                        return false;
                }
        }
 
        /*
         * If we created the plugin directory and will want to remove it if we
         * have to roll back the installation, lets add it to the installation
         * step stack
         */
        if ($created) {
                $this->parent->pushStep(array ('type' => 'folder', 'path' => $this->parent->getPath('extension_root')));
        }
 
        // Copy all necessary files
        if ($this->parent->parseFiles($xml->files, -1) === false)
        {
                // Install failed, roll back changes
                $this->parent->abort();
                return false;
        }
 
        // Parse optional tags -- media and language files for plugins go in admin app
        $this->parent->parseMedia($xml->media, 1);
        $this->parent->parseLanguages($xml->languages, 1);
 
        // If there is a manifest script, lets copy it.
        if ($this->get('manifest_script'))
        {
                $path['src'] = $this->parent->getPath('source').DS.$this->get('manifest_script');
                $path['dest'] = $this->parent->getPath('extension_root').DS.$this->get('manifest_script');
 
                if (!file_exists($path['dest']))
                {
                        if (!$this->parent->copyFiles(array ($path)))
                        {
                                // Install failed, rollback changes
                                $this->parent->abort(JText::_('Plugin').' '.JText::_($this->route).': '.JText::_('Could not copy PHP manifest file.'));
                                return false;
                        }
                }
        }
 
        // Was there a plugin already installed with the same name?
        if ($id)
        {
                if (!$this->parent->getOverwrite())
                {
                        // Install failed, roll back changes
                        $this->parent->abort(JText::_('Plugin').' '.JText::_($this->route).': '.JText::_('Plugin').' "'. $this->get('name') .'" '.JText::_('ALREADY_EXISTS'));
                        return false;
                }
 
        }
        else
        {
                // Store in the extensions table (1.6)
                $row = & JTable::getInstance('extension');
                $row->name = $this->get('name');
                $row->type = 'plugin';
                $row->ordering = 0;
                $row->element = $element;
                $row->folder = $group;
                $row->enabled = 0;
                $row->protected = 0;
                $row->access = 1;
                $row->client_id = 0;
                $row->params = $this->parent->getParams();
                $row->custom_data = ''; // custom data
                $row->system_data = ''; // system data
                $row->manifest_cache = $this->parent->generateManifestCache();
 
                // Editor plugins are published by default
                if ($group == 'editors') {
                        $row->enabled = 1;
                }
 
                if (!$row->store())
                {
                        // Install failed, roll back changes
                        $this->parent->abort(JText::_('Plugin').' '.JText::_($this->route).': '.$db->stderr(true));
                        return false;
                }
 
                // Since we have created a plugin item, we add it to the installation step stack
                // so that if we have to rollback the changes we can undo it.
                $this->parent->pushStep(array ('type' => 'extension', 'id' => $row->extension_id));
                $id = $row->extension_id;
        }
 
        /*
         * Let's run the queries for the module
         *      If Joomla 1.5 compatible, with discreet sql files - execute appropriate
         *      file for utf-8 support or non-utf-8 support
         */
        // try for Joomla 1.5 type queries
        // second argument is the utf compatible version attribute
        $utfresult = $this->parent->parseSQLFiles($xml->{strtolower($this->route)}->sql);
        if ($utfresult === false)
        {
                // Install failed, rollback changes
                $this->parent->abort(JText::_('Module').' '.JText::_($this->route).': '.JText::_('SQLERRORORFILE')." ".$db->stderr(true));
                return false;
        }
 
        // Start Joomla! 1.6
        ob_start();
        ob_implicit_flush(false);
        if ($this->parent->manifestClass && method_exists($this->parent->manifestClass,$this->route)) {
                $this->parent->manifestClass->{$this->route}($this);
        }
        $msg .= ob_get_contents(); // append messages
        ob_end_clean();
 
        // Lastly, we will copy the manifest file to its appropriate place.
        if (!$this->parent->copyManifest(-1))
        {
                // Install failed, rollback changes
                $this->parent->abort(JText::_('Plugin').' '.JText::_($this->route).': '.JText::_('COULD_NOT_COPY_SETUP_FILE'));
                return false;
        }
        // And now we run the postflight
        ob_start();
        ob_implicit_flush(false);
        if ($this->parent->manifestClass && method_exists($this->parent->manifestClass,'postflight')) {
                $this->parent->manifestClass->postflight($this->route, $this);
        }
        $msg .= ob_get_contents(); // append messages
        ob_end_clean();
        if ($msg != '') {
                $this->parent->set('extension_message', $msg);
        }
        return $id;
}

[<! removed edit link to red link >] <! removed transcluded page call, red link never existed >

Examples

<CodeExamplesForm />