Source for file plugin.php

Documentation is available at plugin.php

  1. <?php
  2. /**
  3.  * @package     Joomla.Libraries
  4.  * @subpackage  Installer
  5.  *
  6.  * @copyright   Copyright (C) 2005 - 2013 Open Source Matters, Inc. All rights reserved.
  7.  * @license     GNU General Public License version 2 or later; see LICENSE
  8.  */
  9.  
  10. defined('JPATH_PLATFORM') or die;
  11.  
  12. jimport('joomla.base.adapterinstance');
  13. jimport('joomla.filesystem.folder');
  14.  
  15. /**
  16.  * Plugin installer
  17.  *
  18.  * @package     Joomla.Libraries
  19.  * @subpackage  Installer
  20.  * @since       3.1
  21.  */
  22. class JInstallerAdapterPlugin extends JAdapterInstance
  23. {
  24.     /**
  25.      * Install function routing
  26.      *
  27.      * @var    string 
  28.      * @since  3.1
  29.      */
  30.     protected $route = 'install';
  31.  
  32.     /**
  33.      * The installation manifest XML object
  34.      *
  35.      * @var    SimpleXMLElement 
  36.      * @since  3.1
  37.      */
  38.     protected $manifest = null;
  39.  
  40.     /**
  41.      * A path to the PHP file that the scriptfile declaration in
  42.      * the manifest refers to.
  43.      *
  44.      * @var    string 
  45.      * @since  3.1
  46.      */
  47.     protected $manifest_script = null;
  48.  
  49.     /**
  50.      * Name of the extension
  51.      *
  52.      * @var    string 
  53.      * @since  3.1
  54.      */
  55.     protected $name = null;
  56.  
  57.     /**
  58.      * <scriptfile> element of the extension manifest
  59.      *
  60.      * @var    object 
  61.      * @since  3.1
  62.      */
  63.     protected $scriptElement = null;
  64.  
  65.     /**
  66.      * <files> element of the old extension manifest
  67.      *
  68.      * @var    object 
  69.      * @since  3.1
  70.      */
  71.     protected $oldFiles = null;
  72.  
  73.     /**
  74.      * Custom loadLanguage method
  75.      *
  76.      * @param   string  $path  The path where to find language files.
  77.      *
  78.      * @return  void 
  79.      *
  80.      * @since   3.1
  81.      */
  82.     public function loadLanguage($path = null)
  83.     {
  84.         $source = $this->parent->getPath('source');
  85.  
  86.         if (!$source)
  87.         {
  88.             $this->parent->setPath('source', JPATH_PLUGINS . '/' . $this->parent->extension->folder . '/' . $this->parent->extension->element);
  89.         }
  90.         $this->manifest = $this->parent->getManifest();
  91.         $element = $this->manifest->files;
  92.  
  93.         if ($element)
  94.         {
  95.             $group = strtolower((string) $this->manifest->attributes()->group);
  96.             $name = '';
  97.  
  98.             if (count($element->children()))
  99.             {
  100.                 foreach ($element->children() as $file)
  101.                 {
  102.                     if ((string) $file->attributes()->plugin)
  103.                     {
  104.                         $name = strtolower((string) $file->attributes()->plugin);
  105.                         break;
  106.                     }
  107.                 }
  108.             }
  109.             if ($name)
  110.             {
  111.                 $extension = "plg_${group}_${name}";
  112.                 $lang = JFactory::getLanguage();
  113.                 $source = $path ? $path : JPATH_PLUGINS . "/$group/$name";
  114.                 $folder = (string) $element->attributes()->folder;
  115.  
  116.                 if ($folder && file_exists("$path/$folder"))
  117.                 {
  118.                     $source = "$path/$folder";
  119.                 }
  120.                 $lang->load($extension . '.sys', $source, null, false, true)
  121.                     || $lang->load($extension . '.sys', JPATH_ADMINISTRATOR, null, false, true);
  122.             }
  123.         }
  124.     }
  125.  
  126.     /**
  127.      * Custom install method
  128.      *
  129.      * @return  boolean  True on success
  130.      *
  131.      * @since   3.1
  132.      */
  133.     public function install()
  134.     {
  135.         // Get a database connector object
  136.         $db = $this->parent->getDbo();
  137.  
  138.         // Get the extension manifest object
  139.         $this->manifest = $this->parent->getManifest();
  140.  
  141.         $xml = $this->manifest;
  142.  
  143.         /*
  144.          * ---------------------------------------------------------------------------------------------
  145.          * Manifest Document Setup Section
  146.          * ---------------------------------------------------------------------------------------------
  147.          */
  148.  
  149.         // Set the extension name
  150.         $name = (string) $xml->name;
  151.         $name = JFilterInput::getInstance()->clean($name, 'string');
  152.         $this->set('name', $name);
  153.  
  154.         // Get the plugin description
  155.         $description = (string) $xml->description;
  156.  
  157.         if ($description)
  158.         {
  159.             $this->parent->set('message', JText::_($description));
  160.         }
  161.         else
  162.         {
  163.             $this->parent->set('message', '');
  164.         }
  165.  
  166.         /*
  167.          * Backward Compatibility
  168.          * @todo Deprecate in future version
  169.          */
  170.         $type = (string) $xml->attributes()->type;
  171.  
  172.         // Set the installation path
  173.         if (count($xml->files->children()))
  174.         {
  175.             foreach ($xml->files->children() as $file)
  176.             {
  177.                 if ((string) $file->attributes()->$type)
  178.                 {
  179.                     $element = (string) $file->attributes()->$type;
  180.                     break;
  181.                 }
  182.             }
  183.         }
  184.         $group = (string) $xml->attributes()->group;
  185.  
  186.         if (!empty($element) && !empty($group))
  187.         {
  188.             $this->parent->setPath('extension_root', JPATH_PLUGINS . '/' . $group . '/' . $element);
  189.         }
  190.         else
  191.         {
  192.             $this->parent->abort(JText::sprintf('JLIB_INSTALLER_ABORT_PLG_INSTALL_NO_FILE', JText::_('JLIB_INSTALLER_' . $this->route)));
  193.  
  194.             return false;
  195.         }
  196.  
  197.         // Check if we should enable overwrite settings
  198.  
  199.         // Check to see if a plugin by the same name is already installed.
  200.         $query = $db->getQuery(true)
  201.             ->select($db->quoteName('extension_id'))
  202.             ->from($db->quoteName('#__extensions'))
  203.             ->where($db->quoteName('folder') . ' = ' . $db->quote($group))
  204.             ->where($db->quoteName('element') . ' = ' . $db->quote($element));
  205.         $db->setQuery($query);
  206.  
  207.         try
  208.         {
  209.             $db->execute();
  210.         }
  211.         catch (RuntimeException $e)
  212.         {
  213.             // Install failed, roll back changes
  214.             $this->parent
  215.                 ->abort(JText::sprintf('JLIB_INSTALLER_ABORT_PLG_INSTALL_ROLLBACK', JText::_('JLIB_INSTALLER_' . $this->route), $db->stderr(true)));
  216.  
  217.             return false;
  218.         }
  219.         $id = $db->loadResult();
  220.  
  221.         // If it's on the fs...
  222.         if (file_exists($this->parent->getPath('extension_root')) && (!$this->parent->isOverwrite() || $this->parent->isUpgrade()))
  223.         {
  224.             $updateElement = $xml->update;
  225.  
  226.             // Upgrade manually set or update function available or update tag detected
  227.             if ($this->parent->isUpgrade() || ($this->parent->manifestClass && method_exists($this->parent->manifestClass, 'update'))
  228.                 || $updateElement)
  229.             {
  230.                 // Force this one
  231.                 $this->parent->setOverwrite(true);
  232.                 $this->parent->setUpgrade(true);
  233.  
  234.                 if ($id)
  235.                 {
  236.                     // If there is a matching extension mark this as an update; semantics really
  237.                     $this->route = 'update';
  238.                 }
  239.             }
  240.             elseif (!$this->parent->isOverwrite())
  241.             {
  242.                 // Overwrite is set
  243.                 // We didn't have overwrite set, find an update function or find an update tag so lets call it safe
  244.                 $this->parent
  245.                     ->abort(
  246.                     JText::sprintf(
  247.                         'JLIB_INSTALLER_ABORT_PLG_INSTALL_DIRECTORY', JText::_('JLIB_INSTALLER_' . $this->route),
  248.                         $this->parent->getPath('extension_root')
  249.                     )
  250.                 );
  251.  
  252.                 return false;
  253.             }
  254.         }
  255.  
  256.         /*
  257.          * ---------------------------------------------------------------------------------------------
  258.          * Installer Trigger Loading
  259.          * ---------------------------------------------------------------------------------------------
  260.          */
  261.  
  262.         // If there is an manifest class file, let's load it; we'll copy it later (don't have destination yet).
  263.         if ((string) $xml->scriptfile)
  264.         {
  265.             $manifestScript = (string) $xml->scriptfile;
  266.             $manifestScriptFile = $this->parent->getPath('source') . '/' . $manifestScript;
  267.  
  268.             if (is_file($manifestScriptFile))
  269.             {
  270.                 // Load the file
  271.                 include_once $manifestScriptFile;
  272.             }
  273.             // If a dash is present in the group name, remove it
  274.             $groupClass = str_replace('-', '', $group);
  275.  
  276.             // Set the class name
  277.             $classname = 'plg' . $groupClass . $element . 'InstallerScript';
  278.  
  279.             if (class_exists($classname))
  280.             {
  281.                 // Create a new instance
  282.                 $this->parent->manifestClass = new $classname($this);
  283.  
  284.                 // And set this so we can copy it later
  285.                 $this->set('manifest_script', $manifestScript);
  286.             }
  287.         }
  288.  
  289.         // Run preflight if possible (since we know we're not an update)
  290.         ob_start();
  291.         ob_implicit_flush(false);
  292.  
  293.         if ($this->parent->manifestClass && method_exists($this->parent->manifestClass, 'preflight'))
  294.         {
  295.             if ($this->parent->manifestClass->preflight($this->route, $this) === false)
  296.             {
  297.                 // Install failed, rollback changes
  298.                 $this->parent->abort(JText::_('JLIB_INSTALLER_ABORT_PLG_INSTALL_CUSTOM_INSTALL_FAILURE'));
  299.  
  300.                 return false;
  301.             }
  302.         }
  303.  
  304.         // Create msg object; first use here
  305.         $msg = ob_get_contents();
  306.         ob_end_clean();
  307.  
  308.         /*
  309.          * ---------------------------------------------------------------------------------------------
  310.          * Filesystem Processing Section
  311.          * ---------------------------------------------------------------------------------------------
  312.          */
  313.  
  314.         // If the plugin directory does not exist, lets create it
  315.         $created = false;
  316.  
  317.         if (!file_exists($this->parent->getPath('extension_root')))
  318.         {
  319.             if (!$created = JFolder::create($this->parent->getPath('extension_root')))
  320.             {
  321.                 $this->parent
  322.                     ->abort(
  323.                     JText::sprintf(
  324.                         'JLIB_INSTALLER_ABORT_PLG_INSTALL_CREATE_DIRECTORY', JText::_('JLIB_INSTALLER_' . $this->route),
  325.                         $this->parent->getPath('extension_root')
  326.                     )
  327.                 );
  328.  
  329.                 return false;
  330.             }
  331.         }
  332.  
  333.         // If we're updating at this point when there is always going to be an extension_root find the old XML files
  334.         if ($this->route == 'update')
  335.         {
  336.             // Hunt for the original XML file
  337.             $old_manifest = null;
  338.  
  339.             // Create a new installer because findManifest sets stuff; side effects!
  340.             $tmpInstaller = new JInstaller;
  341.  
  342.             // Look in the extension root
  343.             $tmpInstaller->setPath('source', $this->parent->getPath('extension_root'));
  344.  
  345.             if ($tmpInstaller->findManifest())
  346.             {
  347.                 $old_manifest = $tmpInstaller->getManifest();
  348.                 $this->oldFiles = $old_manifest->files;
  349.             }
  350.         }
  351.  
  352.         /*
  353.          * If we created the plugin directory and will want to remove it if we
  354.          * have to roll back the installation, let's add it to the installation
  355.          * step stack
  356.          */
  357.  
  358.         if ($created)
  359.         {
  360.             $this->parent->pushStep(array('type' => 'folder', 'path' => $this->parent->getPath('extension_root')));
  361.         }
  362.  
  363.         // Copy all necessary files
  364.         if ($this->parent->parseFiles($xml->files, -1, $this->oldFiles) === false)
  365.         {
  366.             // Install failed, roll back changes
  367.             $this->parent->abort();
  368.  
  369.             return false;
  370.         }
  371.  
  372.         // Parse optional tags -- media and language files for plugins go in admin app
  373.         $this->parent->parseMedia($xml->media, 1);
  374.         $this->parent->parseLanguages($xml->languages, 1);
  375.  
  376.         // If there is a manifest script, lets copy it.
  377.         if ($this->get('manifest_script'))
  378.         {
  379.             $path['src'] = $this->parent->getPath('source') . '/' . $this->get('manifest_script');
  380.             $path['dest'] = $this->parent->getPath('extension_root') . '/' . $this->get('manifest_script');
  381.  
  382.             if (!file_exists($path['dest']))
  383.             {
  384.                 if (!$this->parent->copyFiles(array($path)))
  385.                 {
  386.                     // Install failed, rollback changes
  387.                     $this->parent
  388.                         ->abort(JText::sprintf('JLIB_INSTALLER_ABORT_PLG_INSTALL_MANIFEST', JText::_('JLIB_INSTALLER_' . $this->route)));
  389.  
  390.                     return false;
  391.                 }
  392.             }
  393.         }
  394.  
  395.         /*
  396.          * ---------------------------------------------------------------------------------------------
  397.          * Database Processing Section
  398.          * ---------------------------------------------------------------------------------------------
  399.          */
  400.  
  401.         $row = JTable::getInstance('extension');
  402.  
  403.         // Was there a plugin with the same name already installed?
  404.         if ($id)
  405.         {
  406.             if (!$this->parent->isOverwrite())
  407.             {
  408.                 // Install failed, roll back changes
  409.                 $this->parent
  410.                     ->abort(
  411.                     JText::sprintf(
  412.                         'JLIB_INSTALLER_ABORT_PLG_INSTALL_ALLREADY_EXISTS', JText::_('JLIB_INSTALLER_' . $this->route),
  413.                         $this->get('name')
  414.                     )
  415.                 );
  416.  
  417.                 return false;
  418.             }
  419.             $row->load($id);
  420.             $row->name = $this->get('name');
  421.             $row->manifest_cache = $this->parent->generateManifestCache();
  422.  
  423.             // Update the manifest cache and name
  424.             $row->store();
  425.         }
  426.         else
  427.         {
  428.             // Store in the extensions table (1.6)
  429.             $row->name = $this->get('name');
  430.             $row->type = 'plugin';
  431.             $row->ordering = 0;
  432.             $row->element = $element;
  433.             $row->folder = $group;
  434.             $row->enabled = 0;
  435.             $row->protected = 0;
  436.             $row->access = 1;
  437.             $row->client_id = 0;
  438.             $row->params = $this->parent->getParams();
  439.  
  440.             // Custom data
  441.             $row->custom_data = '';
  442.  
  443.             // System data
  444.             $row->system_data = '';
  445.             $row->manifest_cache = $this->parent->generateManifestCache();
  446.  
  447.             // Editor plugins are published by default
  448.             if ($group == 'editors')
  449.             {
  450.                 $row->enabled = 1;
  451.             }
  452.  
  453.             if (!$row->store())
  454.             {
  455.                 // Install failed, roll back changes
  456.                 $this->parent
  457.                     ->abort(
  458.                     JText::sprintf('JLIB_INSTALLER_ABORT_PLG_INSTALL_ROLLBACK', JText::_('JLIB_INSTALLER_' . $this->route), $db->stderr(true))
  459.                 );
  460.  
  461.                 return false;
  462.             }
  463.  
  464.             // Since we have created a plugin item, we add it to the installation step stack
  465.             // so that if we have to rollback the changes we can undo it.
  466.             $this->parent->pushStep(array('type' => 'extension', 'id' => $row->extension_id));
  467.             $id = $row->extension_id;
  468.         }
  469.  
  470.         // Let's run the queries for the plugin
  471.         if (strtolower($this->route) == 'install')
  472.         {
  473.             $result = $this->parent->parseSQLFiles($this->manifest->install->sql);
  474.  
  475.             if ($result === false)
  476.             {
  477.                 // Install failed, rollback changes
  478.                 $this->parent
  479.                     ->abort(
  480.                     JText::sprintf('JLIB_INSTALLER_ABORT_PLG_INSTALL_SQL_ERROR', JText::_('JLIB_INSTALLER_' . $this->route), $db->stderr(true))
  481.                 );
  482.  
  483.                 return false;
  484.             }
  485.  
  486.             // Set the schema version to be the latest update version
  487.             if ($this->manifest->update)
  488.             {
  489.                 $this->parent->setSchemaVersion($this->manifest->update->schemas, $row->extension_id);
  490.             }
  491.         }
  492.         elseif (strtolower($this->route) == 'update')
  493.         {
  494.             if ($this->manifest->update)
  495.             {
  496.                 $result = $this->parent->parseSchemaUpdates($this->manifest->update->schemas, $row->extension_id);
  497.  
  498.                 if ($result === false)
  499.                 {
  500.                     // Install failed, rollback changes
  501.                     $this->parent->abort(JText::sprintf('JLIB_INSTALLER_ABORT_PLG_UPDATE_SQL_ERROR', $db->stderr(true)));
  502.  
  503.                     return false;
  504.                 }
  505.             }
  506.         }
  507.  
  508.         // Run the custom method based on the route
  509.         ob_start();
  510.         ob_implicit_flush(false);
  511.  
  512.         if ($this->parent->manifestClass && method_exists($this->parent->manifestClass, $this->route))
  513.         {
  514.             if ($this->parent->manifestClass->{$this->route}($this) === false)
  515.             {
  516.                 // Install failed, rollback changes
  517.                 $this->parent->abort(JText::_('JLIB_INSTALLER_ABORT_PLG_INSTALL_CUSTOM_INSTALL_FAILURE'));
  518.  
  519.                 return false;
  520.             }
  521.         }
  522.  
  523.         // Append messages
  524.         $msg .= ob_get_contents();
  525.         ob_end_clean();
  526.  
  527.         /**
  528.          * ---------------------------------------------------------------------------------------------
  529.          * Finalization and Cleanup Section
  530.          * ---------------------------------------------------------------------------------------------
  531.          */
  532.  
  533.         // Lastly, we will copy the manifest file to its appropriate place.
  534.         if (!$this->parent->copyManifest(-1))
  535.         {
  536.             // Install failed, rollback changes
  537.             $this->parent->abort(JText::sprintf('JLIB_INSTALLER_ABORT_PLG_INSTALL_COPY_SETUP', JText::_('JLIB_INSTALLER_' . $this->route)));
  538.  
  539.             return false;
  540.         }
  541.  
  542.         // And now we run the postflight
  543.         ob_start();
  544.         ob_implicit_flush(false);
  545.  
  546.         if ($this->parent->manifestClass && method_exists($this->parent->manifestClass, 'postflight'))
  547.         {
  548.             $this->parent->manifestClass->postflight($this->route, $this);
  549.         }
  550.  
  551.         // Append messages
  552.         $msg .= ob_get_contents();
  553.         ob_end_clean();
  554.  
  555.         if ($msg != '')
  556.         {
  557.             $this->parent->set('extension_message', $msg);
  558.         }
  559.  
  560.         return $id;
  561.     }
  562.  
  563.     /**
  564.      * Custom update method
  565.      *
  566.      * @return   boolean  True on success
  567.      *
  568.      * @since    3.1
  569.      */
  570.     public function update()
  571.     {
  572.         // Set the overwrite setting
  573.         $this->parent->setOverwrite(true);
  574.         $this->parent->setUpgrade(true);
  575.  
  576.         // Set the route for the install
  577.         $this->route = 'update';
  578.  
  579.         // Go to install which handles updates properly
  580.         return $this->install();
  581.     }
  582.  
  583.     /**
  584.      * Custom uninstall method
  585.      *
  586.      * @param   integer  $id  The id of the plugin to uninstall
  587.      *
  588.      * @return  boolean  True on success
  589.      *
  590.      * @since   3.1
  591.      */
  592.     public function uninstall($id)
  593.     {
  594.         $this->route = 'uninstall';
  595.  
  596.         $row = null;
  597.         $retval = true;
  598.         $db = $this->parent->getDbo();
  599.  
  600.         // First order of business will be to load the plugin object table from the database.
  601.         // This should give us the necessary information to proceed.
  602.         $row = JTable::getInstance('extension');
  603.  
  604.         if (!$row->load((int) $id))
  605.         {
  606.             JLog::add(JText::_('JLIB_INSTALLER_ERROR_PLG_UNINSTALL_ERRORUNKOWNEXTENSION'), JLog::WARNING, 'jerror');
  607.  
  608.             return false;
  609.         }
  610.  
  611.         // Is the plugin we are trying to uninstall a core one?
  612.         // Because that is not a good idea...
  613.         if ($row->protected)
  614.         {
  615.             JLog::add(JText::sprintf('JLIB_INSTALLER_ERROR_PLG_UNINSTALL_WARNCOREPLUGIN', $row->name), JLog::WARNING, 'jerror');
  616.  
  617.             return false;
  618.         }
  619.  
  620.         // Get the plugin folder so we can properly build the plugin path
  621.         if (trim($row->folder) == '')
  622.         {
  623.             JLog::add(JText::_('JLIB_INSTALLER_ERROR_PLG_UNINSTALL_FOLDER_FIELD_EMPTY'), JLog::WARNING, 'jerror');
  624.  
  625.             return false;
  626.         }
  627.  
  628.         // Set the plugin root path
  629.         $this->parent->setPath('extension_root', JPATH_PLUGINS . '/' . $row->folder . '/' . $row->element);
  630.  
  631.         $this->parent->setPath('source', $this->parent->getPath('extension_root'));
  632.  
  633.         $this->parent->findManifest();
  634.         $this->manifest = $this->parent->getManifest();
  635.  
  636.         // Attempt to load the language file; might have uninstall strings
  637.         $this->parent->setPath('source', JPATH_PLUGINS . '/' . $row->folder . '/' . $row->element);
  638.         $this->loadLanguage(JPATH_PLUGINS . '/' . $row->folder . '/' . $row->element);
  639.  
  640.         /**
  641.          * ---------------------------------------------------------------------------------------------
  642.          * Installer Trigger Loading
  643.          * ---------------------------------------------------------------------------------------------
  644.          */
  645.  
  646.         // If there is an manifest class file, let's load it; we'll copy it later (don't have dest yet)
  647.         $manifestScript = (string) $this->manifest->scriptfile;
  648.  
  649.         if ($manifestScript)
  650.         {
  651.             $manifestScriptFile = $this->parent->getPath('source') . '/' . $manifestScript;
  652.  
  653.             if (is_file($manifestScriptFile))
  654.             {
  655.                 // Load the file
  656.                 include_once $manifestScriptFile;
  657.             }
  658.             // If a dash is present in the folder, remove it
  659.             $folderClass = str_replace('-', '', $row->folder);
  660.  
  661.             // Set the class name
  662.             $classname = 'plg' . $folderClass . $row->element . 'InstallerScript';
  663.  
  664.             if (class_exists($classname))
  665.             {
  666.                 // Create a new instance
  667.                 $this->parent->manifestClass = new $classname($this);
  668.  
  669.                 // And set this so we can copy it later
  670.                 $this->set('manifest_script', $manifestScript);
  671.             }
  672.         }
  673.  
  674.         // Run preflight if possible (since we know we're not an update)
  675.         ob_start();
  676.         ob_implicit_flush(false);
  677.  
  678.         if ($this->parent->manifestClass && method_exists($this->parent->manifestClass, 'preflight'))
  679.         {
  680.             if ($this->parent->manifestClass->preflight($this->route, $this) === false)
  681.             {
  682.                 // Preflight failed, rollback changes
  683.                 $this->parent->abort(JText::_('JLIB_INSTALLER_ABORT_PLG_INSTALL_CUSTOM_INSTALL_FAILURE'));
  684.  
  685.                 return false;
  686.             }
  687.         }
  688.  
  689.         // Create the $msg object and append messages from preflight
  690.         $msg = ob_get_contents();
  691.         ob_end_clean();
  692.  
  693.         // Let's run the queries for the plugin
  694.         $utfresult = $this->parent->parseSQLFiles($this->manifest->uninstall->sql);
  695.  
  696.         if ($utfresult === false)
  697.         {
  698.             // Install failed, rollback changes
  699.             $this->parent->abort(JText::sprintf('JLIB_INSTALLER_ABORT_PLG_UNINSTALL_SQL_ERROR', $db->stderr(true)));
  700.  
  701.             return false;
  702.         }
  703.  
  704.         // Run the custom uninstall method if possible
  705.         ob_start();
  706.         ob_implicit_flush(false);
  707.  
  708.         if ($this->parent->manifestClass && method_exists($this->parent->manifestClass, 'uninstall'))
  709.         {
  710.             $this->parent->manifestClass->uninstall($this);
  711.         }
  712.  
  713.         // Append messages
  714.         $msg .= ob_get_contents();
  715.         ob_end_clean();
  716.  
  717.         // Remove the plugin files
  718.         $this->parent->removeFiles($this->manifest->files, -1);
  719.  
  720.         // Remove all media and languages as well
  721.         $this->parent->removeFiles($this->manifest->media);
  722.         $this->parent->removeFiles($this->manifest->languages, 1);
  723.  
  724.         // Remove the schema version
  725.         $query = $db->getQuery(true)
  726.             ->delete('#__schemas')
  727.             ->where('extension_id = ' . $row->extension_id);
  728.         $db->setQuery($query);
  729.         $db->execute();
  730.  
  731.         // Now we will no longer need the plugin object, so let's delete it
  732.         $row->delete($row->extension_id);
  733.         unset($row);
  734.  
  735.         // Remove the plugin's folder
  736.         JFolder::delete($this->parent->getPath('extension_root'));
  737.  
  738.         if ($msg != '')
  739.         {
  740.             $this->parent->set('extension_message', $msg);
  741.         }
  742.  
  743.         return $retval;
  744.     }
  745.  
  746.     /**
  747.      * Custom discover method
  748.      *
  749.      * @return  array  JExtension) list of extensions available
  750.      *
  751.      * @since   3.1
  752.      */
  753.     public function discover()
  754.     {
  755.         $results = array();
  756.         $folder_list = JFolder::folders(JPATH_SITE . '/plugins');
  757.  
  758.         foreach ($folder_list as $folder)
  759.         {
  760.             $file_list = JFolder::files(JPATH_SITE . '/plugins/' . $folder, '\.xml$');
  761.  
  762.             foreach ($file_list as $file)
  763.             {
  764.                 $manifest_details = JInstaller::parseXMLInstallFile(JPATH_SITE . '/plugins/' . $folder . '/' . $file);
  765.                 $file = JFile::stripExt($file);
  766.  
  767.                 // Ignore example plugins
  768.                 if ($file == 'example')
  769.                 {
  770.                     continue;
  771.                 }
  772.  
  773.                 $extension = JTable::getInstance('extension');
  774.                 $extension->set('type', 'plugin');
  775.                 $extension->set('client_id', 0);
  776.                 $extension->set('element', $file);
  777.                 $extension->set('folder', $folder);
  778.                 $extension->set('name', $file);
  779.                 $extension->set('state', -1);
  780.                 $extension->set('manifest_cache', json_encode($manifest_details));
  781.                 $extension->set('params', '{}');
  782.                 $results[] = $extension;
  783.             }
  784.             $folder_list = JFolder::folders(JPATH_SITE . '/plugins/' . $folder);
  785.  
  786.             foreach ($folder_list as $plugin_folder)
  787.             {
  788.                 $file_list = JFolder::files(JPATH_SITE . '/plugins/' . $folder . '/' . $plugin_folder, '\.xml$');
  789.  
  790.                 foreach ($file_list as $file)
  791.                 {
  792.                     $manifest_details = JInstaller::parseXMLInstallFile(
  793.                         JPATH_SITE . '/plugins/' . $folder . '/' . $plugin_folder . '/' . $file
  794.                     );
  795.                     $file = JFile::stripExt($file);
  796.  
  797.                     if ($file == 'example')
  798.                     {
  799.                         continue;
  800.                     }
  801.  
  802.                     // Ignore example plugins
  803.                     $extension = JTable::getInstance('extension');
  804.                     $extension->set('type', 'plugin');
  805.                     $extension->set('client_id', 0);
  806.                     $extension->set('element', $file);
  807.                     $extension->set('folder', $folder);
  808.                     $extension->set('name', $file);
  809.                     $extension->set('state', -1);
  810.                     $extension->set('manifest_cache', json_encode($manifest_details));
  811.                     $extension->set('params', '{}');
  812.                     $results[] = $extension;
  813.                 }
  814.             }
  815.         }
  816.         return $results;
  817.     }
  818.  
  819.     /**
  820.      * Custom discover_install method.
  821.      *
  822.      * @return  mixed 
  823.      *
  824.      * @since   3.1
  825.      */
  826.     public function discover_install()
  827.     {
  828.         /*
  829.          * Plugins use the extensions table as their primary store
  830.          * Similar to modules and templates, rather easy
  831.          * If it's not in the extensions table we just add it
  832.          */
  833.         $client = JApplicationHelper::getClientInfo($this->parent->extension->client_id);
  834.  
  835.         if (is_dir($client->path . '/plugins/' . $this->parent->extension->folder . '/' . $this->parent->extension->element))
  836.         {
  837.             $manifestPath = $client->path . '/plugins/' . $this->parent->extension->folder . '/' . $this->parent->extension->element . '/'
  838.                 . $this->parent->extension->element . '.xml';
  839.         }
  840.         else
  841.         {
  842.             $manifestPath = $client->path . '/plugins/' . $this->parent->extension->folder . '/' . $this->parent->extension->element . '.xml';
  843.         }
  844.         $this->parent->manifest = $this->parent->isManifest($manifestPath);
  845.         $description = (string) $this->parent->manifest->description;
  846.  
  847.         if ($description)
  848.         {
  849.             $this->parent->set('message', JText::_($description));
  850.         }
  851.         else
  852.         {
  853.             $this->parent->set('message', '');
  854.         }
  855.         $this->parent->setPath('manifest', $manifestPath);
  856.         $manifest_details = JInstaller::parseXMLInstallFile($manifestPath);
  857.         $this->parent->extension->manifest_cache = json_encode($manifest_details);
  858.         $this->parent->extension->state = 0;
  859.         $this->parent->extension->name = $manifest_details['name'];
  860.         $this->parent->extension->enabled = ('editors' == $this->parent->extension->folder) ? 1 : 0;
  861.         $this->parent->extension->params = $this->parent->getParams();
  862.  
  863.         if ($this->parent->extension->store())
  864.         {
  865.             return $this->parent->extension->get('extension_id');
  866.         }
  867.         else
  868.         {
  869.             JLog::add(JText::_('JLIB_INSTALLER_ERROR_PLG_DISCOVER_STORE_DETAILS'), JLog::WARNING, 'jerror');
  870.  
  871.             return false;
  872.         }
  873.     }
  874.  
  875.     /**
  876.      * Refreshes the extension table cache.
  877.      *
  878.      * @return  boolean  Result of operation, true if updated, false on failure.
  879.      *
  880.      * @since   3.1
  881.      */
  882.     public function refreshManifestCache()
  883.     {
  884.         /*
  885.          * Plugins use the extensions table as their primary store
  886.          * Similar to modules and templates, rather easy
  887.          * If it's not in the extensions table we just add it
  888.          */
  889.         $client = JApplicationHelper::getClientInfo($this->parent->extension->client_id);
  890.         $manifestPath = $client->path . '/plugins/' . $this->parent->extension->folder . '/' . $this->parent->extension->element . '/'
  891.             . $this->parent->extension->element . '.xml';
  892.         $this->parent->manifest = $this->parent->isManifest($manifestPath);
  893.         $this->parent->setPath('manifest', $manifestPath);
  894.         $manifest_details = JInstaller::parseXMLInstallFile($this->parent->getPath('manifest'));
  895.         $this->parent->extension->manifest_cache = json_encode($manifest_details);
  896.  
  897.         $this->parent->extension->name = $manifest_details['name'];
  898.  
  899.         if ($this->parent->extension->store())
  900.         {
  901.             return true;
  902.         }
  903.         else
  904.         {
  905.             JLog::add(JText::_('JLIB_INSTALLER_ERROR_PLG_REFRESH_MANIFEST_CACHE'), JLog::WARNING, 'jerror');
  906.  
  907.             return false;
  908.         }
  909.     }
  910. }
  911.  
  912. /**
  913.  * Deprecated class placeholder. You should use JInstallerAdapterPlugin instead.
  914.  *
  915.  * @package     Joomla.Libraries
  916.  * @subpackage  Installer
  917.  * @since       3.1
  918.  * @deprecated  4.0
  919.  * @codeCoverageIgnore
  920.  */
  921. class JInstallerPlugin extends JInstallerAdapterPlugin
  922. {
  923. }

Documentation generated on Tue, 19 Nov 2013 15:10:48 +0100 by phpDocumentor 1.4.3